南昌航空大学21207230题目集1-3第一次总结性blog-526互联

（1）前言：

　　第一次作业比较简单，也是老师发给我们练练手，主要还是熟悉一下java的输入输出格式，题目很多都在以前学习c语言的时候有写过，从第二，三次作业开始就正式开始学习java了，由于从来没有接触过java，刚开始写的时候感觉很陌生，但是在系统的学习一部分以后越发熟练和熟悉了，第二次写pta的时候一开始并不知道有正则表达式这个东西，但是我还是用遍历的方法强行通过了测试点，第三次作业难度就上来了，还需要自己不断地改进的进步。

　　知识点主要是正则表达式，可以参考这个网站：正则表达式- CSDN搜索，然后还用到了分割的一个函数split；浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365；还有一个学生类对象的数据封装：Java之类与对象(学生类封装)_java通过反射的方式创建学生对象,然后封装读取出来的每一个学生信息。-CSDN博客

　　难度当然是伴随着作业一次次地提高，第二次写得很慢但最后还是把分数都拿差不多了，只是在一些特定的检测上存在相关错误，第三次就比较痛苦了，正则表达式不会用，参考类图要求的功能太多，梳理不清楚导致题目最后结果错误，最后只是拿到40分，总的来说开始学期时未意料java的学习会这么快（比如我开学后只学了基础的语法）；思维固化（在学c语言的时候，就有所有方法扔主函数的陋习，到java写类的时候就很不适应）。

（2）设计与分析：

题目集2：

7-1

创建学生类，包含

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

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

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

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

注：未用学生类对象封装数据的，本题计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

输入样例:

在这里给出一组输入。例如：

22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94

输出样例:

在这里给出相应的输出。例如：

22201311 张琳 240 80.00
22201312 黄昊 229 76.33
22201313 李少辰 233 77.67
22201314 袁婷 231 77.00
22201315 朱哲一 266 88.67
代码如下：

import java.util.Scanner;
class Student 
{
    private String id;
    private String name;
    private int x;
    private int y;
    private int z;
    public void setId(String id) 
    {
        this.id = id;
    }
    public void setName(String name) 
    {
        this.name = name;
    }
    public void setX(int x) 
    {
        this.x = x;
    }
    public void setY(int y) 
    {
        this.y = y;
    }
    public void setZ(int z) 
    {
        this.z = z;
    }
    public int calculateall() 
    {
        return x + y + z;
    }
    public double calculateAverage() 
    {
        double all = calculateall();
        return (double)(Math.round((all * 100)/ 3)/100.0);
    }

    public String getFee() 
    {
        int all = calculateall();
        double average = calculateAverage();
        return id + " " + name + " " + all + " " + String.format("%.2f", average);
    }
}

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

        for (int i = 0; i < 5; i++) 
        {
                String id = scanner.next();
                String name = scanner.next();
                int x = scanner.nextInt();
                int y = scanner.nextInt();
                int z = scanner.nextInt();
                Student student = new Student();
                student.setId(id);
                student.setName(name);
                student.setX(x);
                student.setY(y);
                student.setZ(z);

                students[i] = student;
            } 

        for (Student student : students) 
        {
            System.out.println(student.getFee());
        }
    }
}

心得体会：本题总体而言还是比较简单的，只需要再输入数据后进行总分和平均分的计算，最后输出就可以了，需要住的就是输出格式上的问题，主要保留俩位小数，最后不要留下不必要的换行和空格就可正确的完成此题。

HashMap 是一种常用的 Java 集合类，它可以用来存储键值对，并且可以快速地根据键来查找对应的值。以下是 HashMap 的主要方面：

创建 HashMap 对象

我们可以直接使用 new 关键字和 HashMap 类的构造函数来创建一个 HashMap 对象，例如：

HashMap<String, Integer> map = new HashMap<>();

上述代码创建了一个 HashMap 对象，用于存储字符串和整数键值对。

添加元素

使用 put() 方法可以向 HashMap 中添加元素，例如：

map.put("apple", 10);

map.put("banana", 20);

以上代码向 HashMap 中添加了两个键值对：

键为 "apple"，值为 10；

键为 "banana"，值为 20。

如果键已经存在，则新值将会取代旧值。

获取元素

使用 get() 方法可以从 HashMap 中获取指定键的值，例如：

int appleCount = map.get("apple"); // 获取键为 "apple" 的值

以上代码获取了键为 "apple" 的值，并将其存储在 appleCount 变量中。

删除元素

使用 remove() 方法可以从 HashMap 中删除指定键的键值对，例如：

map.remove("banana"); // 删除键为 "banana" 的键值对

以上代码删除了键为 "banana" 的键值对。

判断键是否存在

使用 containsKey() 方法可以判断 HashMap 中是否包含指定键，例如：

boolean contains = map.containsKey("apple"); // 判断是否包含键 "apple"

以上代码判断了 HashMap 中是否包含键 "apple"。

获取 HashMap 元素个数

使用 size() 方法可以获取 HashMap 中键值对的个数，例如：

int size = map.size(); // 获取键值对的个数

以上代码获取了 HashMap 中的键值对个数。

遍历 HashMap

通过遍历 keySet() 方法返回的键集合，可以遍历 HashMap 的键值对，例如：

for (String key : map.keySet()) {

int value = map.get(key);

System.out.println(key + ": " + value);

}

以上代码遍历了 HashMap 中的每一个键值对，并将其输出到控制台上。

以上是 HashMap 的一些常用方面，还有其他操作如清空 HashMap、判断值是否存在等，使用方法类似。需要注意的是，HashMap 是一种散列表数据结构，它的键值对是无序的。

题目集2：

7-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

输入样例:

在这里给出一组输入。例如：

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

输出样例:

在这里给出相应的输出。例如：

22201311 张琳 242 76.67 84.00 80.67
22201312 黄昊 234 75.00 80.67 78.00
22201313 李少辰 236 83.67 76.00 78.67

代码如下

import java.util.*;

class Score {
    private int dailyScore;
    private int finalScore;

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

    public int getTotalScore() 
    {
        return (int) (dailyScore * 0.4 + finalScore * 0.6);
    }

    public int getDailyScore() 
    {
        return dailyScore;
    }

    public int getFinalScore() 
    {
        return finalScore;
    }
}

class Student 
{
    private String studentNumber;
    private String name;
    private List<Score> scores;

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

    public void setScore(int dailyScore, int finalScore) 
    {
        Score score = new Score(dailyScore, finalScore);
        scores.add(score);
    }

    public int getTotalScore() 
    {
        int totalScore = 0;
        for (Score score : scores) 
        {
            totalScore += score.getTotalScore();
        }
        return totalScore;
    }

    public double getAverageDailyScore() 
    {
        int totalDailyScore = 0;
        for (Score score : scores) 
        {
            totalDailyScore += score.getDailyScore();
        }
        return totalDailyScore / (double) scores.size();
    }

    public double getAverageFinalScore() 
    {
        int totalFinalScore = 0;
        for (Score score : scores) 
        {
            totalFinalScore += score.getFinalScore();
        }
        return totalFinalScore / (double) scores.size();
    }

    public String getStudentNumber() 
    {
        return studentNumber;
    }

    public String getName() 
    {
        return name;
    }

    public List<Score> getScores() 
    {
        return scores;
    }
}

public class Main 
{
    public static void main(String[] args) 
    {
        Map<String, Student> studentMap = new HashMap<>();
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) 
        {
            String studentNumber = scanner.next();
            String name = scanner.next();
            String courseName = scanner.next();
            int dailyScore = scanner.nextInt();
            int finalScore = scanner.nextInt();

            if (!studentMap.containsKey(studentNumber)) 
            {
                studentMap.put(studentNumber, new Student(studentNumber, name));
            }

            studentMap.get(studentNumber).setScore(dailyScore, finalScore);
        }

        for (Student student : studentMap.values()) 
        {
            int totalScore = student.getTotalScore();
            double averageDailyScore = student.getAverageDailyScore();
            double averageFinalScore = student.getAverageFinalScore();
            double averageScore = (totalScore / (double) student.getScores().size());

            System.out.printf("%s %s %d %.2f %.2f %.2f%n",
                    student.getStudentNumber(), student.getName(),
                    totalScore, averageDailyScore, averageFinalScore, averageScore);
        }
    }
}

心得体会：本题是对一第一题的进一步扩展，在第一题的基础上增加俩个平均分的计算，通过识别输入课程的不同成绩，进行运算后输出，但是在输入课程顺序不一致的时候会发生答案错误，这是由于代码中缺少了关于课程识别的问题，导致输入顺序错误是仍会按照定义的运算方式进行运算后输出，对于这种方式可以通过增加一个新的定义，来判断具体输入的是哪个学科的成绩，然后将改成绩赋予给对应的学科变量，这样就可以杜绝在顺序不一致时发生的错误

class Score {
    private int dailyScore;
    private int finalScore;

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

    public int getTotalScore() 
    {
        return (int) (dailyScore * 0.4 + finalScore * 0.6);
    }

    public int getDailyScore() 
    {
        return dailyScore;
    }

    public int getFinalScore() 
    {
        return finalScore;
    }

可以在上述代码进行数据输入前，增加一个判断语句，识别输入的是否是正确的顺序，如果是正常进行下一步操作，如果数据不符合则输出顺序错误。

题目集2：

7-7 菜单计价程序

某饭店提供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”，**是不能识别的菜名

输入样例:

在这里给出一组输入。例如：

麻婆豆腐 2
西红柿炒蛋 3
end

输出样例:

在这里给出相应的输出。例如：

输入样例1:

订单中包含不存在的菜品记录。例如：

麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end

输出样例1:

在这里给出相应的输出。例如：

炒脆肚 does not exist
48

代码如下：

import java.util.Scanner;
class Dish 
{
    String name;
    int unitPrice;
    public Dish(String name, int unitPrice) 
    {
        this.name = name;
        this.unitPrice = unitPrice;
    }
    public int getPrice(int portion) 
    {
        double price = unitPrice;
        if (portion == 2) 
        {
            price *= 1.5;
        } 
        else if (portion == 3)
        {
            price *= 2;
        }
        return (int) Math.round(price);
    }
}
class Menu 
{
    Dish[] dishes;

    public Menu(Dish[] dishes) 
    {
        this.dishes = dishes;
    }

    public Dish search(String dishName) 
    {
        for (Dish dish : dishes)
        {
            if (dish.name.equals(dishName)) 
            {
                return dish;
            }
        }
        return null;
    }
}
class Record 
{
    Dish dish;
    int portion;

    public Record(Dish dish, int portion) 
    {
        this.dish = dish;
        this.portion = portion;
    }
    public int getPrice() 
    {
        return dish.getPrice(portion);
    }
}
class Order 
{
    Record[] records;
    int size;

    public Order(int capacity) 
    {
        records = new Record[capacity];
        size = 0;
    }
    public int getTotalPrice() 
    {
        int totalPrice = 0;
        for (int i = 0; i < size; i++) 
        {
            totalPrice += records[i].getPrice();
        }
        return totalPrice;
    }
    public Record addARecord(String dishName, int portion, Menu menu)
    {
        Dish dish = menu.search(dishName);
        if (dish == null) 
        {
            System.out.println(dishName + " does not exist");
            return null;
        }
        Record record = new Record(dish, portion);
        records[size] = record;
        size++;
        return record;
    }
}
public class Main 
{
    public static void main(String[] args)
    {
        Dish[] dishes = 
        {
                new Dish("西红柿炒蛋", 15),
                new Dish("清炒土豆丝", 12),
                new Dish("麻婆豆腐", 12),
                new Dish("油淋生菜", 9)
        };
        Menu menu = new Menu(dishes);
        Order order = new Order(100);
        Scanner scanner = new Scanner(System.in);
        while (true) 
        {
            String input = scanner.nextLine();
            if (input.equals("end")) 
            {
                break;
            }
            String[] dishFee = input.split(" ");
            String dishName = dishFee[0];
            int portion = Integer.parseInt(dishFee[1]);
            order.addARecord(dishName, portion, menu);
        }
        int totalPrice = order.getTotalPrice();
        System.out.println(totalPrice);
    }
}

心得体会：在最开始的编译运行中，没有只要到对于不存在菜品的识别语句，导致在运行中产生错误，需要添加一个if语句进行判断即可：

public Record addARecord(String dishName, int portion, Menu menu)
    {
        Dish dish = menu.search(dishName);
        if (dish == null) 
        {
            System.out.println(dishName + " does not exist");
            return null;
        }
        Record record = new Record(dish, portion);
        records[size] = record;
        size++;
        return record;
    }
}

通过上述代码的添加即可实现对于不存在的菜品输入后进行相关显示来告知错误，进而运行后得到正确的答案

ArrayList 是 Java 集合框架中的一个动态数组类，可以方便地动态地添加、删除、访问和搜索元素。以下是 ArrayList 的主要用法：

创建 ArrayList 对象

创建一个 ArrayList 对象需要使用 new 关键字和 ArrayList 类的构造函数，例如：

// 创建一个存储 String 类型元素的 ArrayList 对象

List<String> list = new ArrayList<String>();

添加元素

使用 add() 方法可以向 ArrayList 中添加元素，例如：

// 添加单个元素

list.add("Java");

// 添加多个元素

list.add("C++");

list.add("Python");

获取元素

使用 get() 方法可以获取 ArrayList 中指定位置的元素，位置从 0 开始计数，例如：

String element = list.get(0); // 获取第一个元素

修改元素

可以使用 set() 方法修改 ArrayList 中指定位置的元素，例如：

list.set(0, "JavaScript"); // 修改第一个元素为 "JavaScript"

删除元素

使用 remove() 方法可以删除 ArrayList 中指定位置或指定元素的元素，例如：

list.remove(0); // 删除第一个元素

list.remove("C++"); // 删除元素值为 "C++" 的元素

判断元素是否存在

使用 contains() 方法可以判断 ArrayList 中是否包含指定元素，例如：

boolean contains = list.contains("Java"); // 判断是否包含 "Java"

获取 ArrayList 元素个数

使用 size() 方法可以获取 ArrayList 中元素的个数，例如：

int size = list.size(); // 获取元素个数

以上是 ArrayList 的主要用法，其他操作和 ArrayList 操作类似，如遍历、清空等。需要注意的是，ArrayList 可以存储任何引用类型的对象，如包装类型、自定义类类型等。

题目集3：

7-2：

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

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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）成绩平均分只取整数部分，小数部分丢弃

参考类图：

输入样例1:

仅有课程。例如：

java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end

输出样例1:

在这里给出相应的输出。例如：

java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet

输入样例2:

单门考试课程单个学生。例如：

java 必修 考试
20201103 张三 java 20 40
end

输出样例2:

在这里给出相应的输出。例如：

20201103 张三 34
java 20 40 34
202011 34

输入样例3:

单门考察课程单个学生。例如：

java 选修 考察
20201103 张三 java 40
end

输出样例3:

在这里给出相应的输出。例如：

20201103 张三 40
java 40 40
202011 40

输入样例4:

考试课程单个学生不匹配的考核方式。例如：

java 必修 考试
20201103 张三 java 20
end

输出样例4:

在这里给出相应的输出。例如：

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet

输入样例5:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

java 必修 考察
20201103 张三 java 40
end

输出样例5:

在这里给出相应的输出。例如：

java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet

输入样例6:

单门课程，多个学生。例如：

java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end

输出样例6:

在这里给出相应的输出。例如：

20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53

输入样例7:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end

输出样例7:

在这里给出相应的输出。例如：

20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73

输入样例8:

单门课程，单个学生，成绩越界。例如：

数据结构 选修 考察
20201103 李四 数据结构 101
end

输出样例8:

在这里给出相应的输出。例如：

wrong format
数据结构 has no grades yet

输入样例9:

多门课程，多个学生，多个成绩。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end

输出样例9:

在这里给出相应的输出。例如：

20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72

代码如下：

import java.util.*;

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

        Map<String, Course> courses = new HashMap<>();
        List<Grade> grades = new ArrayList<>();

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

            String[] inputs = input.split(" ");
            String courseName = inputs[0];
            String type = inputs[1];
            String accessMode = inputs[2];

            if (!type.equals("必修") && !type.equals("选修")) {
                System.out.println("wrong format");
                continue;
            }
            if (!accessMode.equals("考试") && !accessMode.equals("考察")) {
                System.out.println("wrong format");
                continue;
            }
            Course course = new Course(courseName, type, accessMode);
            courses.put(courseName, course);
        }

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

            String[] inputs = input.split(" ");
            String id = inputs[0];
            String name = inputs[1];
            String courseName = inputs[2];
            int quizGrade = Integer.parseInt(inputs[3]);
            int finalGrade = Integer.parseInt(inputs[4]);

            Grade grade = new Grade(id, name, courseName, quizGrade, finalGrade);
            grades.add(grade);
        }

        String targetCourseName = "java";
        String targetType = "必修";
        String targetAccessMode = "考试";

        List<Grade> targetGrades = new ArrayList<>();
        for (Grade grade : grades) {
            if (grade.getCourseName().equals(targetCourseName)) {
                targetGrades.add(grade);
            }
        }

        int totalGradeSum = 0;
        for (Grade targetGrade : targetGrades) {
            totalGradeSum += targetGrade.getTotalGrade();
        }
        int averageTotalGrade = totalGradeSum / targetGrades.size();

        System.out.println(targetCourseName + " " + averageTotalGrade);

        for (Grade targetGrade : targetGrades) {
            System.out.println(targetGrade.getId() + " " + targetGrade.getName() + " "
                    + targetGrade.getQuizGrade() + " " + targetGrade.getFinalGrade() + " "
                    + targetGrade.getTotalGrade());
        }

        scanner.close();
    }

    static class Course {
        private String name;
        private String type;
        private String accessMode;

        public Course(String name, String type, String accessMode) {
            this.name = name;
            this.type = type;
            this.accessMode = accessMode;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }

        public String getAccessMode() {
            return accessMode;
        }

        public void setAccessMode(String accessMode) {
            this.accessMode = accessMode;
        }
    }

    static class Grade {
        private String id;
        private String name;
        private String courseName;
        private int quizGrade;
        private int finalGrade;
        private int totalGrade;

        public Grade(String id, String name, String courseName, int quizGrade, int finalGrade) {
            this.id = id;
            this.name = name;
            this.courseName = courseName;
            this.quizGrade = quizGrade;
            this.finalGrade = finalGrade;
            this.totalGrade = (int) Math.round(quizGrade * 0.3 + finalGrade * 0.7);
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getCourseName() {
            return courseName;
        }

        public void setCourseName(String courseName) {
            this.courseName = courseName;
        }

        public int getQuizGrade() {
            return quizGrade;
        }

        public void setQuizGrade(int quizGrade) {
            this.quizGrade = quizGrade;
        }

        public int getFinalGrade() {
            return finalGrade;
        }

        public void setFinalGrade(int finalGrade) {
            this.finalGrade = finalGrade;
        }

        public int getTotalGrade() {
            return totalGrade;
        }

        public void setTotalGrade(int totalGrade) {
            this.totalGrade = totalGrade;
        }
    }
}

心得体会：第一次接触这么复杂的题目，略微有点难度，在第一次的书写中存在很多很多的错误，最开始时编译的错误：

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Map<String, Course> courses = new HashMap<>();
        Map<String, Student> students = new HashMap<>();
        Map<String, List<Integer>> classGrades = new HashMap<>();

在这的格式顺序上存在错误，导致{}的编写存在错误，再修改后：

package com.study.ok;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ChooseCourse chooseCourse = new ChooseCourse();
        while (true) {
            String s = sc.nextLine();
            if (!("end".equals(s))) {
                chooseCourse.handleInput(s);
            } else {
                break;
            }
        }
        chooseCourse.inputStudent();
        chooseCourse.inputCourse();
        chooseCourse.inputClass();
    }
}

class Student implements Comparable<Student> {
    int id;
    String name;
    String course;
    int[] scores;

    public Student(int id, String name, String course) {
        this.id = id;
        this.name = name;
        this.course = course;
    }

    public int getPersonScore() {
        int i = scores.length;
        int sum = 0;
        switch (i) {
            case 1:
                return scores[0];
            case 2:
                return (int) (scores[0] * 0.3 + scores[1] * 0.7);
            case 3:
                return -1;
            default:
                for (int i1 = 1; i1 < scores.length; i1++) {
                    sum += scores[i1];
                }
                return sum / scores[0];
        }
    }

    @Override
    public int compareTo(Student o) {
        return this.id - o.id;
    }
}

class Course implements Comparable<Course> {
    String name;
    String nature;
    String format;
    ArrayList<Integer> sum = new ArrayList<>();
    int i = 0;

    public Course(String name, String nature, String format) {
        this.name = name;
        this.nature = nature;
        this.format = format;
    }

    public int[] getCourseScore() {
        int i = this.sum.size();
        int[] sum;
        int otherSum = 0;
        switch (i) {
            case 1:
                return new int[]{this.sum.get(0) / this.i, this.sum.get(0) / this.i};
            case 2:
                sum = new int[3];
                sum[0] = this.sum.get(0) / this.i;
                sum[1] = this.sum.get(1) / this.i;
                sum[2] = (int) (sum[0] * 0.3) + (int) (sum[1] * 0.7);
                return sum;
            case 3:
                return new int[]{-1};
            default:
                for (int j = 1; j < this.sum.size(); j++) {
                    otherSum += this.sum.get(j);
                }
                return new int[]{otherSum / this.sum.get(0)};
        }
    }

    @Override
    public int compareTo(Course o) {
        return this.name.compareTo(o.name);
    }
}

class Class {
    int id;
    int sum = 0;
    int i = 0;

    Class(int id) {
        this.id = id;
    }
}

class ChooseCourse {
    ArrayList<Course> courses = new ArrayList<>();
    ArrayList<Student> students = new ArrayList<>();
    ArrayList<Class> classes = new ArrayList<>();

    public void handleInput(String s) {
        String[] split = s.split(" ");
        if ("必修".equals(split[1]) || "选修".equals(split[1]) || "实验".equals(split[1])) {
            Course course = new Course(split[0], split[1], split[2]);
            courses.add(course);
        } else {
            Student student = new Student(Integer.parseInt(split[0]), split[1], split[2]);
            int[] scores = new int[split.length - 3];
            ArrayList<String> list = new ArrayList<>();
            for (int i = 0; i < courses.size(); i++) {
                Course course = courses.get(i);
                if ("实验".equals(course.format)) {
                    list.add(course.name);
                }
            }
            for (int j = 0; j < list.size(); j++) {
                if (list.get(j).equals(split[2])) {
                    if (Integer.parseInt(split[3]) < 4) {
                        System.out.println(split[2] + " : course type & access mode mismatch");
                        System.out.println("wrong format");
                        System.exit(0);
                    } else if (Integer.parseInt(split[3]) == split.length - 4) {
                        for (int i = 3; i < split.length; i++) {
                            scores[i - 3] = Integer.parseInt(split[i]);
                        }
                    } else {
                        System.out.println(student.id + " " + student.name + " : access mode mismatch");
                    }
                } else {
                    for (int i = 3; i < split.length; i++) {
                        scores[i - 3] = Integer.parseInt(split[i]);
                    }
                }
            }
            student.scores = scores;
            students.add(student);
            for (int i = 0; i < courses.size(); i++) {
                Course course1 = courses.get(i);
                if (course1.name.equals(split[2])) {
                    Course course = course1;
                    if (course.i == 0) {
                        for (int j = 0; j < scores.length; j++) {
                            int sum = scores[j];
                            course.sum.add(sum);
                        }
                    } else {
                        for (int j = 0; j < scores.length; j++) {
                            int sum = course.sum.get(j);
                            sum += scores[j];
                            course.sum.set(j, sum);
                        }
                    }
                    course.i += 1;
                    courses.set(i, course);
                    break;
                }
            }
        }
    }

    public void inputStudent() {
        Collections.sort(students);
        for (int i = 0; i < students.size(); i++) {
            Student student = students.get(i);
            System.out.println(student.id + " " + student.name + " " + student.getPersonScore());
            int classId = student.id / 100;
            if (classes.size() == 0) {
                Class class007 = new Class(classId);
                class007.sum += student.getPersonScore();
                class007.i += 1;
                classes.add(class007);
            } else {
                for (int j = 0; j < classes.size(); j++) {
                    if (classes.get(j).id == classId) {
                        Class class007 = classes.get(j);
                        class007.sum += student.getPersonScore();
                        class007.i += 1;
                        classes.set(j, class007);
                        break;
                    } else if (j == classes.size() - 1) {
                        Class class007 = new Class(classId);
                        class007.sum += student.getPersonScore();
                        class007.i += 1;
                        classes.add(class007);
                        break;
                    }
                }
            }
        }
    }

    public void inputCourse() {
        Collections.sort(courses);
        for (int i = 0; i < courses.size(); i++) {
            Course course = courses.get(i);
            System.out.print(course.name);
            int[] courseScore = course.getCourseScore();
            if (courseScore.length == 1) {
                System.out.println(" " + courseScore[0]);
            } else if (courseScore.length == 2) {
                System.out.println(" " + courseScore[0] + " " + courseScore[1]);
            } else if (courseScore.length == 3) {
                System.out.println(" " + courseScore[0] + " " + courseScore[1] + " " + courseScore[2]);
            }
        }
    }

    public void inputClass() {
        for (int i = 0; i < classes.size(); i++) {
            System.out.println(classes.get(i).id + " " + classes.get(i).sum / classes.get(i).i);
        }
    }
}

在对于代码进行修改后，可惜的是还是存在不少的错误，在时间上已经略微来不及了，希望在下次可以更用心，写的更加好，最后的分数也是比较可惜

（3）对于这道题我做出了如下心得总结：

1. 缺失类的定义

代码中使用了一些自定义的类，但是这些类的定义并没有出现在代码中。由于缺失类的定义，编译器无法识别这些类，导致代码无法编译运行。

2. 未使用泛型ArrayList

代码中用了原生的ArrayList来声明变量，但是并没有指定它的类型。这种做法容易引起类型转换异常等问题。

3. 格式不符

代码中没有提供输入格式的定义，因此无法确定输入数据的格式是否与要求的格式一致。如果输入数据的格式与代码要求的格式不一致，也会导致代码无法正常运行。

解决方法：提供输入格式的定义，并严格按照格式要求输入数据。

（4）改进建议：

1. 提供输相关定义

给出清晰明了的格式定义，在main中对于相关数据进行明确说明，以便在运行和测试的过程中能够正确的识别相关数据，避免因为格式问题而产生的相关错误。

2. 使用泛型ArrayList

使用泛型ArrayList，明确指定所存储数据的类型，避免因类型转换异常等问题。

3. 统一输出格式

在运行测试中注意自己的输出，按照pta所给出的标准输出进行严格的要求进行标准的修改，做到注意每一个细节即可

（5）总结：

1.对本阶段三次题目集的综合性总结，主要还是刚接触java就直接要上手做题，太过于仓促的突然，有点没适应过来，老师上课提供了很多实用性的点子，也让我们做了相关知识点的课堂作业，感觉这个对于我的提升很大，能让我较为快速的掌握做题的技巧，促进我的学习

　2.学到了类对于java编程的重要性，此次作业没有分类，导致主类过于冗长，正则表达式需要好好掌握，确实比较难，对于较长代码的编写能力还有待提高和进步，需要进一步加强训练。

3.对于刚接触的我而言，题目难度上升的可能有一点超过我的预期，加上其他课程也比较多，在时间安排上存在不少的问题，挑战性过高，导致我第三次作业的第二题自己写了十几个小时还是存在不小的遗憾，但也正是说明了我还需要继续努力和提高自己的能力，希望在以后的练习中能更好的提升自己，当然再通过这几次题目的练习，我感觉我的心态越来越好了，不会再有刚开始学习的时候因为一次次代码的修改而烦躁，更加的沉着冷静，能够更好的梳理自己思维逻辑和结构，让自己的书写更加流畅。