java题目编写及分析-526互联

首先想分享给大家的是三个题目集，其难易程度是由易到难(我会着重挑几个题目给大家分析)

第一个题目集所包含的题目为身体质量指数BMI测算，长度质量单位换算，奇数求和，房产税费计算，游戏角色选择，学号识别，巴比伦法求平方根近似值，二进制数值提取，判断三角形类型共九个题目，在第一个题目集中着重考察了这段代码涉及的知识点主要包括基本的输入输出、条件判断和基本的数学运算。它的难度属于入门级别，适合初学者学习和练习。后面增加了一些数学运算及各类情况的思考，更加考验耐心和细心，但总体来说第一个题目集所设计的Java专业知识并不是特别多，适合用来锻练基本功

而第二个题目集所展现出的难度则跟题目一不在一个层次了，分别为成绩计算-1-类,数组的基本运用，成绩计算-2-关联类，有重复的数据，去掉重复的数据，面向对象编程(封装性),GPS测绘中度分秒转换，菜单计价程序-1，jmu-java-日期类的基本使用。在这些题目中除了特别用法的考察，代码基本上都超过了100行。这里我就挑出第一题，第二题和第七题来和大家进行讨论。

首先是第一题成绩计算-1-类,数组的基本运用，要求为

创建学生类，包含

属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）

方法：计算总分、计算平均分

输入5个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365

注意：未用学生类对象封装数据的，本题计0分

输入格式:

5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80

22201312 黄昊 66 82 81

22201313 李少辰 77 76 80

22201314 袁婷 62 79 90

22201315 朱哲一 74 98 94

输出格式:

5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：

22201311 张琳 240 80.00

22201312 黄昊 229 76.33

22201313 李少辰 233 77.67

22201314 袁婷 231 77.00

22201315 朱哲一 266 88.67

代码如下:

import java.util.Scanner;
import java.text.DecimalFormat;
public class Main {
    public static void main(String[] args) {
        Scanner put = new Scanner(System.in);

        Student[] students = new Student[5];

        for (int i = 0; i < 5; i++) {
            String input = put.nextLine();

            String[] info = input.split(" ");
            String ID = info[0];
            String name = info[1];
            int Chinese = Integer.parseInt(info[2]);
            int Math = Integer.parseInt(info[3]);
            int Physics = Integer.parseInt(info[4]);

            students[i] = new Student(ID, name, Chinese, Math, Physics);
        }

        for (int i = 0; i < 5; i++) {
            Student student = students[i];
            int totalScore = student.calculateSum();
            double averageScore = student.calculateAverage();

            System.out.println(student.getID() + " " + student.getName() + " " + totalScore + " " + String.format("%.2f", averageScore));
        }
    }
}

    class Student {
    private String name;
    private String ID;
    private int Chinese;
    private int Math;
    private int Physics;

    public Student(String ID, String name, int Chinese, int Math, int Physics) {
        this.ID = ID;
        this.name = name;
        this.Chinese = Chinese;
        this.Math = Math;
        this.Physics = Physics;
    }

    public String getID() {
        return ID;
    }

    public String getName() {
        return name;
    }
    public int calculateSum() {//计算数组中元素的平均值
        return Chinese + Math + Physics;
    }

    public double calculateAverage() {//计算数组中元素的平均值
        double totalScore = calculateSum();
        double averageScore = totalScore / 3;
        return Double.parseDouble(String.format("%.2f", averageScore));
    }
}

这段代码涉及的知识点主要包括数组、类与对象、字符串处理、格式化输出等。整体难度适中，适合在掌握了基本的Java语法后进行学习和练习。

以下为主要操作
1. 导入 `java.util.Scanner` 和 `java.text.DecimalFormat` 类，用于从控制台读取输入和格式化输出。
2. 创建一个 `Scanner` 对象 `put`，用于接收用户的输入。
3. 创建一个长度为5的 `Student` 数组 `students`，用于存储学生对象。
4. 使用循环，读取用户输入的学生信息，并将其存储到 `students` 数组中。
5. 根据已经存储的学生信息，使用循环计算每个学生的总分和平均分，并使用 `String.format` 方法对平均分保留两位小数。
6. 使用循环遍历 `students` 数组，依次输出每个学生的学号、姓名、总分和平均分。

在代码中，定义了一个 `Student` 类，用于表示学生的信息。该类有私有的名称、学号、语文、数学和物理成绩属性，并提供了相应的获取方法。还有两个公有的方法 `calculateSum` 和 `calculateAverage`，用于计算学生的总分和平均分。
整体来说，这段代码涉及了一些基本的Java编程概念，如数组、类与对象、字符串处理和格式化输出。通过这个示例，我们可以学习如何使用对象数组、类的构造函数、封装和方法等基本的面向对象编程技巧。

在这道题目中，容易发生数组越界错误，在处理学生数组时，要注意数组的索引范围。数组索引从 0 开始，因此访问数组元素时要确保索引不会超出数组的有效范围。也有可能缺乏错误处理，在代码中可能缺乏对异常情况的处理，如输入超出范围、除零错误等。要考虑和实现适当的错误处理机制，提高代码的健壮性。

然后是第二道题成绩计算-2-关联类，要求如下

创建成绩类，包含：

属性：平时成绩（int）、期末成绩（int）

方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）

创建学生类，包含：

属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）

方法：计算总分、计算平均分

输入3个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365

注意：未用学生类对象封装数据的，本题计0分

输入格式:

依次输入3个学生的每门课成绩，每个学生成绩信息格式：

学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致

例如：
22201311 张琳语文 70 80

22201311 张琳数学 85 89

22201311 张琳物理 75 83

22201312 黄昊语文 66 78

22201312 黄昊数学 76 82

22201312 黄昊物理 83 82

22201313 李少辰语文 86 76

22201313 李少辰数学 78 76

22201313 李少辰物理 87 76

输出格式:

3个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：

22201311 张琳 242 80.67

22201312 黄昊 234 78.00

22201313 李少辰 236 78.67

代码如下

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        Map<String, Student> studentMap = new HashMap<>();

        while (scanner.hasNextLine()) {
            String input = scanner.nextLine();
            if (input.isEmpty()) {
                break;
            }
            String[] info = input.split(" ");
            String id = info[0];
            String name = info[1];
            String subject = info[2];
            int usualScore = Integer.parseInt(info[3]);
            int finalScore = Integer.parseInt(info[4]);

            Student student = studentMap.get(id);
            if (student == null) {
                student = new Student(id, name);
                studentMap.put(id, student);
            }

            student.addScore(subject, usualScore, finalScore);
        }

        DecimalFormat decimalFormat = new DecimalFormat("0.00");

        List<String> outputLines = new ArrayList<>();
        List<String> subjectOrder = new ArrayList<>();
        for (Student student : studentMap.values()) {
            for (String subject : student.getSubjectOrder()) {
                if (!subjectOrder.contains(subject)) {
                    subjectOrder.add(subject);
                }
            }
            int totalAverage = student.calculateTotalScoreAverage();
            double average = totalAverage / 3.0;
            double usualAverage = student.calculateUsualScoreAverage();
            double finalAverage = student.calculateFinalScoreAverage();

            String output = student.getId() + " " + student.getName() +
                    " " + totalAverage + " " +
                    decimalFormat.format(usualAverage) + " " +
                    decimalFormat.format(finalAverage) + " " +
                    decimalFormat.format(average);

            outputLines.add(output);
        }

        for (String line : outputLines) {
            System.out.println(line);
        }
    }
}

class Score {
    private int usualScore;
    private int finalScore;

    public Score(int usualScore, int finalScore) {
        this.usualScore = usualScore;
        this.finalScore = finalScore;
    }

    public int getUsualScore() {
        return usualScore;
    }

    public int getFinalScore() {
        return finalScore;
    }

    public int calculateTotalScore() {
        return (int)((usualScore * 0.4) + (finalScore * 0.6));
    }
}  

class Student {
        private String id;
        private String name;
        private Map<String, Score> scores;
        private List<String> subjectOrder;

        public Student(String id, String name) {
            this.id = id;
            this.name = name;
            this.scores = new HashMap<>();
            this.subjectOrder = new ArrayList<>();
        }

        public String getId() {
            return id;
        }

        public String getName() {
            return name;
        }

        public void addScore(String subject, int usualScore, int finalScore) {
            Score score = new Score(usualScore, finalScore);
            scores.put(subject, score);
            if (!subjectOrder.contains(subject)) {
                subjectOrder.add(subject);
            }
        }
        public List<String> getSubjectOrder() {
            return subjectOrder;
        }
        public int calculateTotalScoreAverage() {
            int totalScore = 0;
            for (Score score : scores.values()) {
                totalScore += score.calculateTotalScore();
            }
            return totalScore;
        }

        public double calculateUsualScoreAverage() {
            double totalUsualScore = 0;
            int count = 0;
            for (Score score : scores.values()) {
                totalUsualScore += score.getUsualScore();
                count++;
            }
            return count > 0 ? totalUsualScore / count : 0;
        }

        public double calculateFinalScoreAverage() {
            double totalFinalScore = 0;
            int count = 0;
            for (Score score : scores.values()) {
                totalFinalScore += score.getFinalScore();
                count++;
            }
            return count > 0 ? totalFinalScore / count : 0;
        }
    }

这段代码涉及的知识点包括使用集合类（`HashMap`、`ArrayList`）、格式化输出、字符串处理、类与对象的使用等。整体难度适中，适合在掌握了基本的Java语法和集合类的使用后进行学习和练习。

主要操作如下

1. 导入了 `java.util.Scanner`、`java.text.DecimalFormat`，并定义了 `Main`、`Score` 和 `Student` 三个类。

2. 在 `Main` 类的 `main` 方法中，创建了一个 `Scanner` 对象用于读取用户输入，创建了一个 `HashMap` 对象 `studentMap` 用于存储学生信息。

3. 使用循环读取用户的输入，将学生信息存储到 `studentMap` 中。每次读取一行输入，并根据输入的信息创建 `Student` 对象和 `Score` 对象，并将它们添加到 `studentMap` 中。
4. 使用 `DecimalFormat` 对象 `decimalFormat` 设置输出的格式，保留小数点后两位。
5. 使用循环遍历 `studentMap`，计算每个学生的总分平均值、平时成绩平均值和期末成绩平均值，并将计算结果转换成对应的格式。
6. 将学生的信息以一定的格式保存到 `outputLines` 列表中，然后使用循环遍历 `outputLines`，输出学生的信息。

`Score` 类表示学生的成绩，包括平时成绩和期末成绩，提供了获取平时成绩、期末成绩和计算总分的方法。
`Student` 类表示学生，包括学号、姓名、成绩等信息，提供了添加成绩、获取成绩顺序、计算总分平均值、计算平时成绩平均值和计算期末成绩平均值的方法。
整体来说，这段代码涉及了一些较为高级的Java编程概念，如集合类的使用、格式化输出和类与对象的应用。通过这个示例，你可以学习如何使用集合类对学生信息进行管理和计算，以及如何进行格式化的输出。

编写代码时要注意以下两种错误，类与对象使用错误：在使用类和对象时，可能会出现对象未初始化或未正确创建、属性访问错误、方法调用错误等错误。确保正确地使用类的构造函数、属性获取方法和方法调用方式。数值类型转换错误：在将字符串类型转换为数值类型（如整型或浮点型）时，可能会出现格式错误、溢出或无效转换等错误。要确保使用合适的转换方法，并处理可能出现的异常情况。

还有就是第七题，题目如下

某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9

设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）

不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。

参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}

点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}

订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}

输入格式:

每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。

输出格式:

订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名

代码如下

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner put = new Scanner(System.in);

        Menu menu = new Menu();

        Dish dish1 = new Dish();
        dish1.name = "西红柿炒蛋";
        dish1.unit_price = 15;

        Dish dish2 = new Dish();
        dish2.name = "清炒土豆丝";
        dish2.unit_price = 12;

        Dish dish3 = new Dish();
        dish3.name = "麻婆豆腐";
        dish3.unit_price = 12;

        Dish dish4 = new Dish();
        dish4.name = "油淋生菜";
        dish4.unit_price = 9;

        menu.dishes = new Dish[] { dish1, dish2, dish3, dish4 };

        Order order = new Order();
        order.records = new Record[0];

        while (true) {
            String input = put.nextLine();
            if (input.equals("end")) {
                break;
            }

            String[] parts = input.split(" ");
            String dishName = parts[0];
            int portion = Integer.parseInt(parts[1]);

            order.addARecord(dishName, portion, menu);
        }

        int totalPrice = order.getTotalPrice();
        System.out.println(totalPrice);
    }
}
class Dish {
    String name; // 菜品名称
    int unit_price; // 单价

    int getPrice(int portion) {
        double price = unit_price;
        if (portion == 2) {
            price *= 1.5;
        } else if (portion == 3) {
            price *= 2;
        }
        return (int) Math.round(price);
    }
}

class Menu {
    Dish[] dishes; // 菜品数组

    Dish searchDish(String dishName) {
        for (Dish dish : dishes) {
            if (dish.name.equals(dishName)) {
                return dish;
            }
        }
        return null;
    }
}

class Record {
    Dish dish; // 菜品
    int portion; // 份额

    int getPrice() {
        return dish.getPrice(portion);
    }
}

class Order {
    Record[] records; // 订单上的记录

    int getTotalPrice() {
        int totalPrice = 0;
        for (Record record : records) {
            totalPrice += record.getPrice();
        }
        return totalPrice;
    }

    Record addARecord(String dishName, int portion, Menu menu) {
        Dish dish = menu.searchDish(dishName);
        if (dish == null) {
            System.out.println(dishName + " does not exist");
            return null;
        }

        Record record = new Record();
        record.dish = dish;
        record.portion = portion;

        Record[] newRecords = new Record[records.length + 1];
        System.arraycopy(records, 0, newRecords, 0, records.length);
        newRecords[records.length] = record;

        records = newRecords;

        return record;
    }
}

此代码则是超过了一百行，涉及的知识点主要包括类与对象、数组、字符串处理、条件判断、循环和输入输出等。整体难度适中，适合初学者学习和练习。
主要操作如下
1. 在主类 `Main` 中，使用 `Scanner` 对象 `put` 读取用户的输入。定义了一个 `Menu` 对象 `menu` 表示菜单，创建了几个 `Dish` 对象表示不同的菜品，将这些菜品存储在 `menu` 的 `dishes` 数组中。
2. 定义了一个 `Order` 对象 `order` 表示订单，其中的 `records` 数组存储订单上的记录。
3. 使用循环不断读取用户的输入，直到输入为 "end" 时结束循环。每次读取一行输入，根据输入的菜品名称和份数调用 `order` 的方法 `addARecord` 添加一条记录。
4. 在 `Dish` 类中，定义了菜品的名称和单价属性，以及根据份数计算价格的方法 `getPrice`。
5. 在 `Menu` 类中，定义了菜品数组 `dishes`，并提供了根据菜品名称查找菜品的方法 `searchDish`。
6. 在 `Record` 类中，定义了菜品和份数属性，以及根据菜品和份数计算价格的方法 `getPrice`。
7. 在 `Order` 类中，定义了订单上记录的数组 `records`，并提供了计算总价格的方法 `getTotalPrice` 和添加一条记录的方法 `addARecord`。
整体来说，这段代码涉及了一些基本的Java编程概念，如类与对象的使用、数组、字符串处理和输入输出等。通过这个示例，你可以学习如何使用类和对象表示不同的实体、如何使用数组存储和处理多个对象，以及如何进行输入和输出的交互。

写此题目时小编也犯了很多错误，例如数组越界错误，在处理数组时，出现索引越界错误，例如在访问数组元素时使用了错误的索引，要确保索引在正确的范围内。还有字符串比较错误，在比较字符串时，要使用 `equals` 方法而不是 `==` 运算符。使用错误的字符串比较方法可能导致错误的结果。还有数值类型转换错误，在将字符串类型转换为数值类型（如整型）时，可能会出现格式错误、溢出或无效转换等错误。要确保使用合适的转换方法，并处理可能出现的异常情况。

最后便是第三个题目集3了，分别为jmu-java-日期类的基本使用，课程成绩统计程序，面向对象编程(封装性),判断两个日期的先后，计算间隔天数，周数。由此可见第三次题目集有两道题目重复，这里就不赘述了。重点是第二题和第四题，尤其是第二题，实际上第二题小编到现在也没写出来，如有大佬还请指点。题目如下

某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。

考察的总成绩直接等于期末成绩

必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。

1、输入：

包括课程、课程成绩两类信息。

课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。

课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

课程性质输入项：必修、选修

考核方式输入选项：考试、考察

课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

以上信息的相关约束：

1）平时成绩和期末成绩的权重默认为0.3、0.7

2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】

3）学号由8位数字组成

4）姓名不超过10个字符

5）课程名称不超过10个字符

6）不特别输入班级信息，班级号是学号的前6位。

2、输出：

输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。

为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。

1）学生课程总成绩平均分按学号由低到高排序输出

格式：学号+英文空格+姓名+英文空格+总成绩平均分

如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"

2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出

格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分

如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"

3）班级所有课程总成绩平均分按班级由低到高排序输出

格式：班级号+英文空格+总成绩平均分

如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"

异常情况：

1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"

2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"

以上两种情况如果同时出现，按第一种情况输出结果。

3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"

4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"

5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

信息约束：

1）成绩平均分只取整数部分，小数部分丢弃

参考类图：

而我未写出来的代码如下

import java.awt.color.ICC_ColorSpace;
import java.text.Collator;
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        Students students = new Students();
        Courses courses = new Courses();
        Grades grades = new Grades();
        boolean coursesOnly = true; 
        while(scanner.hasNext())
        {
            String line = scanner.nextLine();
            String[] parts = line.split("\\s+");
            if(parts[0].equals("end")){
            {
                coursesOnly = false;
                continue;
            }
            }
            if(coursesOnly)
            { 
                String course_Name = parts[0];
                String course_Nature = parts[1];
                String course_Way = parts[2];
                courses.addCourse(course_Name, course_Nature, course_Way);
            } 
                else 
                { 
                String number = parts[0];
                String name = parts[1];
                String courseName = parts[2];
                int grade1 = Integer.parseInt(parts[3]);
                int grade2 = parts.length > 4 ? Integer.parseInt(parts[4]) : 0; // handle optional grade2
                students.addStudent(number, name);
                Choose_course choose_course = grades.addChoose_course(number, name, courseName, grade1, grade2, courses, students);
            }
        if(coursesOnly)
               {
            for (Course course : courses.courseMap.values()) 
            {
                System.out.println(course.Course_Name + " has no grades yet");
            }
        } 
               else { 
            Map<String, StudentGrade> studentGrades = new HashMap<>();
            for (Choose_course choose_course : grades.Choose_courses) 
            {
                String number = choose_course.number;
                String name = choose_course.name;
                StudentGrade studentGrade = studentGrades.getOrDefault(number, new StudentGrade(number, name));
                studentGrade.add(choose_course.Full_Grade);
                studentGrades.put(number, studentGrade);
            }
            List<StudentGrade> studentGradeList = new ArrayList<>(studentGrades.values());
            for (StudentGrade studentGrade : studentGradeList) 
            {
                studentGrade.calculateAverage();
            }
            Collections.sort(studentGradeList, (c1, c2) -> c1.number.compareTo(c2.number));
            for (StudentGrade studentGrade : studentGradeList) 
            {
                System.out.println(studentGrade.getNumber() + " " + studentGrade.getName() + " " + studentGrade.getAverage());
            }
        }
       
       Map<String,StudentGrade>studentGrades = new HashMap<>();
        for (Choose_course choose_course : grades.Choose_courses) 
               {
            String number = choose_course.number;
            String name = choose_course.name;
            StudentGrade studentGrade = studentGrades.getOrDefault(number, new StudentGrade(number,name));
            studentGrade.add(choose_course.Full_Grade);
            studentGrades.put(number, studentGrade);
        }
        List<StudentGrade> studentGradeList = new ArrayList<>(studentGrades.values());
        for (StudentGrade studentGrade : studentGradeList) 
        {
            studentGrade.calculateAverage();
        }
        Collections.sort(studentGradeList, (c1, c2) -> c1.number.compareTo(c2.number));
        for (StudentGrade studentGrade : studentGradeList) 
        {
            System.out.println( studentGrade.getNumber()+" "+studentGrade.getName()+" "+studentGrade.getAverage());
        }

        //课目成绩排序
        Map<String,CourseGrade>courseGrades = new HashMap<>();

        for (Choose_course choose_course : grades.Choose_courses) 
        {
            String name = choose_course.Course_Name;
            int grade1 = choose_course.Grade1;
            int grade2 = choose_course.Grade2;
            int grade = choose_course.Full_Grade;
            CourseGrade courseGrade = courseGrades.getOrDefault(name, new CourseGrade(name));
            courseGrade.add(choose_course.Grade1, choose_course.Grade2, choose_course.Full_Grade);
            courseGrades.put(name, courseGrade);
        }
        List<CourseGrade> courseGradeList = new ArrayList<>(courseGrades.values());
        for (CourseGrade courseGrade : courseGradeList) 
        {
            courseGrade.calculateAverage();
        }
        Collator collator = Collator.getInstance(Locale.CHINA);
        Collections.sort(courseGradeList, (o1, o2) -> collator.compare(o1.courseName, o2.courseName));
        for (CourseGrade courseGrade : courseGradeList) 
            {
            if(courseGrade.getAverage2()!=0)
            {
                System.out.println(courseGrade.courseName+" "+courseGrade.getAverage1() + " " + courseGrade.getAverage2() + " " + courseGrade.getAverage());
            }
            if(courseGrade.getAverage2()==0)
            {
                System.out.println(courseGrade.courseName+" "+courseGrade.getAverage1() + " "  + courseGrade.getAverage());
            }
        }
        //求班级的平均分，输出班级
        Map<String, Classroom> classrooms = new HashMap<>();

        // 遍历Choose_courses，将学生按班级分组，并累计每个班级的总成绩和班级人数
        for (Choose_course choose_course : grades.Choose_courses) 
        {
            String number = choose_course.number;
            String classroomNum = number.substring(0, 6);
            Classroom classroom = classrooms.getOrDefault(classroomNum, new Classroom(classroomNum));
            classroom.add(choose_course.Full_Grade);
            classrooms.put(classroomNum, classroom);
        }

        // 计算每个班级的平均分，并将平均分存储到班级对象中
        List<Classroom> classroomList = new ArrayList<>(classrooms.values());
        for (Classroom classroom : classroomList)
        {
            classroom.calculateAverage();
        }

        // 按平均分排序，
        Comparator<Classroom> averageComparator = new Comparator<Classroom>() 
        {
           /* @Override*/
            public int compare(Classroom o1, Classroom o2) 
            {
                return Double.compare(o2.getAverage(), o1.getAverage());
            }
        };
        Collections.sort( classroomList, averageComparator);
        for (Classroom classroom : classroomList) 
               {
            System.out.println( classroom.getClassroomNum()+" "+classroom.getAverage());
        }
    }
}
}

class Student{
    String number;
    String name;
    public Student(String number,String name){
        this.name = name;
        this.number = number;
    }
}

class Students{
    Map<String,Student>studentMap = new HashMap<>();
    public Student searchStudent(String number){
        return studentMap.get(number);
    }
    public Student addStudent(String studentNumber,String studentName){
        Student student = new Student(studentNumber,studentName);
        studentMap.put(studentNumber,student);
        return student;
    }
}

class Classroom {
    private String classroomNum;
    private int total;
    private int count;
    private int average;

    public Classroom(String classroomNum) {
        this.classroomNum = classroomNum;
    }
    public int getTotal() {
        return total;
    }

    public int getCount() {
        return count;
    }

    public String getClassroomNum() {
        return classroomNum;
    }

    public int getAverage() {
        return average;
    }

    public void add(int score) {
        total += score;
        count++;
    }

    public void calculateAverage() {
        average = (int)(total * 1.0 / count);
    }
}

class StudentGrade {
     String number;
     String name;
    private int total;
    private int count;
    private int average;

    public StudentGrade(String number ,String name) {
        this.number = number;
        this.name = name;
    }
    public String getNumber() {
        return number;
    }
    public String getName() {
        return name;
    }

    public int getAverage() {
        return average;
    }
    public int getTotal() {
        return total;
    }

    public int getCount() {
        return count;
    }

    public void add(int grade) {
        total += grade;
        count++;
    }

    public void calculateAverage() {
        average = (int)(total * 1.0 / count);
    }
}

class CourseGrade {
     String courseName;
    private int count;
    private int Grade1; private int average1;
    private int Grade2; private int average2;
    private int Grade; private int average;

    public CourseGrade(String courseName) {
        this.courseName = courseName;
    }

    public String courseName() {
        return courseName;
    }


    public int getCount() {
        return count;
    }
    public int getAverage() {
        return average;
    }
    public int getAverage1() {
        return average1;
    }
    public int getAverage2() {
        return average2;
    }

    public void add(int grade1,int grade2,int grade) {
        Grade1 +=grade1;
        Grade2 +=grade2;
        Grade +=grade;
        count++;
    }

    public void calculateAverage() {
        average1 = (int)(Grade1 * 1.0 / count);
        average2 = (int)(Grade2 * 1.0 / count);
        average = (int)(Grade * 1.0 / count);

    }
}

class Course{
    String Course_Name;
    String Course_Nature;
    String Course_Way;
    public Course(String Course_Name,String Course_Nature,String Course_Way){
        this.Course_Name = Course_Name;
        this.Course_Nature = Course_Nature;
        this.Course_Way = Course_Way;
    }
}

class Courses{
    Map<String,Course>courseMap = new HashMap<>();
    public Course searchCourse(String Course_Name){
         Course course= courseMap.get(Course_Name);
     return course;
    }
    public Course addCourse(String Course_Name,String Course_Nature,String Course_Way){
        Course course = new Course(Course_Name,Course_Nature,Course_Way);
        courseMap.put(Course_Name,course);
        return course;
    }
}

class Choose_course{
    String number;
    String name;
    String Course_Name;
    int Grade1;
    int Grade2;
    int Full_Grade;
    public Choose_course(String number,String name,String Course_Name,int Grade1,int Grade2){
        this.number = number;
        this.name = name;
        this.Course_Name = Course_Name;
        this.Grade1 = Grade1;
        this.Grade2 = Grade2;
        if(Grade2==0){
            this.Full_Grade = Grade1 ;
        }
        if(Grade2!=0){
            this.Full_Grade = (int)(Grade1*0.3 +Grade2*0.7);
        }
    }

    public int getGrade(String Course_Way) {
        int Grade = 0;
        if(Course_Way.equals("考试")){
            Grade = (int)(Grade1*0.3 +Grade2*0.7);
        }
        if(Course_Way.equals("考察")){
            Grade = Grade1 + Grade2;
        }
        return Grade;
    }
}

class Grades{
    List<Choose_course>Choose_courses = new ArrayList<>();
    public Choose_course addChoose_course(String number,String name,String Course_Name,int Grade1,int Grade2,Courses courses,Students students){
        Course course = courses.searchCourse(Course_Name);
        Student student = students.searchStudent(number);
        Choose_course choose_course = new Choose_course(number,name,Course_Name,Grade1,Grade2);
        Choose_courses.add(choose_course);
        return choose_course;
    }
}

对于小编来说这道题过于复杂，也许并不难，但小编实在是懒哈哈哈，也不够细心，还希望能有高人指点。

最后本篇随笔就写到这啦，对于以上内容如果有什么疑惑都可以进行提问，小编不一定会就对了哈哈哈(还是希望能有高人指点)