第三次博客作业

前言

这是第三次博客作业，总结了近三次PTA大作业的完成情况，作业7、8次的大作业的小题目围绕着HashMap、ArrayList和自定义接口来展开，大题目则是课程成绩程序的第二次第三次迭代，因为第一次课程成绩的程序写的结构不太好，于是重新写的，第三次迭代并没有拿到满分，后面也没有时间改了。期末考试则是由29个选择题和四个编程题组成。
关于类和整个程序的设计：

类是面向对象编程中的核心概念，通过类可以定义一组数据和与之相关的操作。在设计程序时，通常需要先考虑需要哪些对象和它们的属性和行为，然后将这些信息组织成类的结构。在类的设计中，需要考虑类的名称、属性、方法、访问权限等方面。
除了类的设计，程序的整体设计也非常重要。程序的整体设计涉及到程序的架构、模块划分、代码组织方式、代码风格等方面。程序的整体设计需要遵循一些基本原则，如低耦合、高内聚、模块化等，以确保程序的可维护性、扩展性和可重用性。
在设计程序时，还需要考虑程序的性能、安全性、可靠性等方面。这些方面的考虑需要在程序开发的不同阶段进行，例如在编码阶段需要考虑程序的性能优化，而在测试阶段需要考虑程序的安全性和可靠性。
三次题目集的知识点、题量、难度等情况：

（对于重难点题目将会给出完整题目）

第七次大作业：

容器-HashMap：

HashMap是Java中常用的容器类之一，它实现了Map接口，用于存储键值对。下面是HashMap的用法：

• 创建HashMap对象：
  1. HashMap<Key类型, Value类型> hashMap = new HashMap<>();

  复制代码
• 添加元素：
  1. hashMap.put(key, value);

  复制代码
• 获取元素：
  1. Value value = hashMap.get(key);

  复制代码
• 删除元素：
  1. hashMap.remove(key);

  复制代码
• 判断键是否存在：
  1. boolean containsKey = hashMap.containsKey(key);

  复制代码
• 判断值是否存在：
  1. boolean containsValue = hashMap.containsValue(value);

  复制代码
• 获取HashMap的大小：
  1. int size = hashMap.size();

  复制代码
• 遍历HashMap：
  1. // 遍历键
  2. for (Key key : hashMap.keySet()) {
  3.     // 根据键获取值
  4.     Value value = hashMap.get(key);
  5.     // 处理值
  6. }
  8. // 遍历值
  9. for (Value value : hashMap.values()) {
  10.     // 处理值
  11. }
  13. // 遍历键值对
  14. for (Map.Entry<Key, Value> entry : hashMap.entrySet()) {
  15.     Key key = entry.getKey();
  16.     Value value = entry.getValue();
  17.     // 处理键值对
  18. }

  复制代码

需要注意的是，HashMap中的键是唯一的，如果重复添加相同的键，后面的值会替代前面的值；值可以重复。此外，HashMap是无序的，元素的顺序不保证一致。
除了基本的用法，还可以使用其他方法和构造函数来满足不同的需求，例如通过构造函数指定初始容量和负载因子，使用putAll()方法将另一个Map中的元素添加到当前HashMap中，使用isEmpty()方法判断HashMap是否为空等。
7-3 课程成绩统计程序-2

课程成绩统计程序-2在第一次的基础上增加了实验课，以下加粗字体显示为本次新增的内容。
某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
实验的总成绩等于课程每次实验成绩的平均分
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修、实验
考核方式输入选项：考试、考察、实验
考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
考试/考查课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩
实验次数至少4次，不超过9次
实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
以上信息的相关约束：
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）成绩平均分只取整数部分，小数部分丢弃
参考类图（与第一次相同，其余内容自行补充）：

 
第八次大作业：

容器-ArrayList：

ArrayList是Java中常用的动态数组类，它实现了List接口，用于存储一组有序的元素。下面是ArrayList的用法：

• 创建ArrayList对象：
  1. ArrayList<ElementType> arrayList = new ArrayList<>();

  复制代码
• 添加元素：
  1. arrayList.add(element);

  复制代码
  元素将会被添加到ArrayList的尾部。
  
• 获取元素：
  1. ElementType element = arrayList.get(index);

  复制代码
  使用索引位置来获取ArrayList中指定位置的元素，索引从0开始。
  
• 修改元素：
  1. arrayList.set(index, newElement);

  复制代码
  使用索引位置来替换ArrayList中指定位置的元素。
  
• 删除元素：
  1. arrayList.remove(index);

  复制代码
  使用索引位置来删除ArrayList中指定位置的元素。
  
• 判断元素是否存在：
  1. boolean containsElement = arrayList.contains(element);

  复制代码
  使用contains()方法来判断ArrayList中是否包含指定元素。
  
• 获取ArrayList的大小：
  1. int size = arrayList.size();

  复制代码
  使用size()方法来获取ArrayList的大小。
  
• 遍历ArrayList：
  1. for (ElementType element : arrayList) {
  2.     // 处理元素
  3. }

  复制代码

需要注意的是，ArrayList可以存储任意类型的元素，包括基本类型的包装类和自定义类型。ArrayList的容量会根据需要进行自动扩容，以适应元素的添加。
除了上述基本用法，ArrayList还提供了许多其他方法，如addAll()方法可以将另一个集合中的元素添加到当前ArrayList中，使用isEmpty()方法判断ArrayList是否为空，使用clear()方法清空ArrayList中的所有元素等。
7-2 课程成绩统计程序-3

课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，
要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。
完成课程成绩统计程序-2、3两次程序后，比较继承和组合关系的区别。思考一下哪一种关系运用上更灵活，更能够适应变更。
题目最后的参考类图未做修改，大家根据要求自行调整，以下内容加粗字体显示的内容为本次新增的内容。
某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
实验的总成绩等于课程每次实验成绩乘以权重后累加而得。
课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。
考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重
考察课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重
实验次数至少4次，不超过9次
课程性质输入项：必修、选修、实验
考核方式输入选项：考试、考察、实验
考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
考试/考查课程成绩信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝
实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
以上信息的相关约束：
1）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
2）学号由8位数字组成
3）姓名不超过10个字符
4）课程名称不超过10个字符
5）不特别输入班级信息，班级号是学号的前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）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
6）如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"
7）如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
期末考试：

（这里只分析编程题）
前三题均为关于正方形、正三棱锥及其魔方的迭代问题：

在魔方问题的基础上，

重构类设计，实现列表内魔方的排序功能（按照魔方的体积进行排序）。
提示：题目中RubikCube类要实现Comparable接口。
其中，Main类源码如下（可直接拷贝使用）：
 

1. public class Main {
2.     public static void main(String[] args) {
3.         // TODO Auto-generated method stub
4.         Scanner input = new Scanner(System.in);
5.         
6.         String color;
7.         int layer;
8.         double side;
9.         RubikCube cube;
10.         
11.         ArrayList<RubikCube> list = new ArrayList<>();
12.         
13.         int choice = input.nextInt();
14.         
15.         while(choice != 0) {
16.             switch(choice) {
17.             case 1://SquareCube
18.                 color = input.next();
19.                 layer = input.nextInt();
20.                 side = input.nextDouble();
21.                 cube = new SquareCube(color, layer,new Cube(side));
22.                 list.add(cube);
23.                 break;
24.             case 2://RegularPyramidCube
25.                 color = input.next();
26.                 layer = input.nextInt();
27.                 side = input.nextDouble();
28.                 cube = new RegularPyramidCube(color, layer,new RegularPyramid(side));
29.                 list.add(cube);
30.                 break;
31.             }
32.             choice = input.nextInt();
33.         }
34.         
35.         list.sort(Comparator.naturalOrder());//正向排序
36.         
37.         for(int i = 0; i < list.size(); i++) {
38.             System.out.print(list.get(i).getColor() + " " +
39.         String.format("%.2f", list.get(i).getArea()) + " " +
40.         String.format("%.2f", list.get(i).getVolume()) );
41.             System.out.println("");
42.         }            
43.     }   
44. }<br>

复制代码

输入格式:
输入魔方类型（1：正方体魔方；2：正三棱锥魔方；0：结束输入）
魔方颜色、魔方阶数、魔方单元正方体、正三棱锥边长
..循环..
输出格式:
按魔方体积升序输出列表中各魔方的信息（实型数均保留两位小数），输出样式参见输出样例。
输入样例:
在这里给出一组输入。例如：

1. 1 blue 3 4.5
2. 2 red 4 2.1
3. 1 yellow 5 2.3
4. 2 black 4 9.42
5. 1 white 4 5.4423
6. 0<br>

复制代码

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

1. red 122.21 69.85
2. yellow 793.50 1520.88
3. blue 1093.50 2460.38
4. black 2459.14 6304.73
5. white 2843.39 10316.38

复制代码

7-4 销售步枪问题（附加题）

前亚利桑那州境内的一位步枪销售商销售密苏里州制造的步枪机（lock）、枪托（stock）和枪管（barrel）。枪机卖45美元，枪托卖30美元，枪管卖25美元。销售商每月至少要售出一支完整的步枪，且生产限额是销售商在一个月内可销售70个枪机、80个枪托和90个枪管。
根据每个月的销售情况，计算销售商的佣金（提成）算法如下：

• 不到（含）1000美元的部分为10%；
  
• 1000（含）~1800美元的部分为15%；
  
• 超过1800美元的部分为20%。
  

佣金程序生成月份销售报告，汇总销售商的销售总额和佣金。
编程要求：必须符合面向对象编程，且保证类设计的单一职责模式，使用面向过程编程判定0分。
提示：可以设置一个销售订单类。参考类图如下：

输入格式:输入销售商每个月售出枪机、枪托、枪管的数量，可以用空格或者回车分隔。
输出格式:分别输出销售商在该月的销售额和佣金，中间用空格分开。
输入样例1:
在这里给出一组输入。例如：30 40 50
输出样例1:
在这里给出相应的输出。例如：3800.00 620.00
输入样例2:
在这里给出一组输入。例如：88 56 98
输出样例2:
在这里给出相应的输出。例如：Wrong Format
设计与分析与主要问题和其解决方法

（这里只会提供重点题目的代码）
第七次大作业：

课程成绩2：

1.   1 import java.io.BufferedReader;
2.   2 import java.io.IOException;
3.   3 import java.io.InputStreamReader;
4.   4 import java.text.Collator;
5.   5 import java.util.*;
6.   6 import java.util.Comparator;
7.   7 import java.util.Locale;
8.   8 import java.util.regex.PatternSyntaxException;
9.   9 import java.util.stream.Collectors;
10. 10 import java.util.stream.IntStream;
11. 11 import java.util.List;
12. 12 import java.util.ArrayList;
13. 13
14. 14
15. 15 public class Main {
16. 16     public static void main(String[] args) {
17. 17     try (BufferedReader in = new BufferedReader(new InputStreamReader(System.in))) {
18. 18         MessageGetAndPrint messageGetAndPrint = new MessageGetAndPrint();
19. 19         messageGetAndPrint.print = new Print();
20. 20         
21. 21         in.lines().takeWhile(line -> !line.equals("end")).forEach(messageGetAndPrint::getMessage);
22. 22         
23. 23         messageGetAndPrint.print.personPrint(messageGetAndPrint.students, messageGetAndPrint.courseSelections);
24. 24         messageGetAndPrint.print.coursePrint(messageGetAndPrint.courses, messageGetAndPrint.courseSelections);
25. 25         messageGetAndPrint.print.classPrint(messageGetAndPrint.classes, messageGetAndPrint.courseSelections);
26. 26     } catch (IOException e) {
27. 27         e.printStackTrace();
28. 28     }
29. 29 }
30. 30 }
31. 31 class Class {
32. 32     private String classNum;
33. 33     HashMap<String , Student> students;
34. 34     Class(String classNum) {
35. 35         setClassNum(classNum);
36. 36     }
37. 37     public void setClassNum(String classNum) {
38. 38         this.classNum = classNum;
39. 39     }
40. 40     public String getClassNum() {
41. 41         return classNum;
42. 42     }
43. 43     public void addStudent(Student student) {
44. 44         students.put(student.getStudentNum() , student);
45. 45     }
46. 46 }
47. 47 class Student {
48. 48     private String name;
49. 49     private String studentNum;
50. 50     Student(String name , String studentNum) {
51. 51         setName(name);
52. 52         setStudentNum(studentNum);
53. 53     }
54. 54     public String getName() {
55. 55         return name;
56. 56     }
57. 57     public void setName(String name) {
58. 58         this.name = name;
59. 59     }
60. 60     public String getStudentNum() {
61. 61         return studentNum;
62. 62     }
63. 63     public void setStudentNum(String studentNum) {
64. 64         this.studentNum = studentNum;
65. 65     }
66. 66 }
67. 67 class Course {
68. 68     private String className;
69. 69     private int classQuality;
70. 70     private int assessmentMethodology;
71. 71     Course(String className , int classQuality , int assessmentMethodology) {
72. 72         setClassName(className);
73. 73         setClassQuality(classQuality);
74. 74         setAssessmentMethodology(assessmentMethodology);
75. 75     }
76. 76     public String getClassName() {
77. 77         return className;
78. 78     }
79. 79     public void setClassName(String className) {
80. 80         this.className = className;
81. 81     }
82. 82     public int getClassQuality() {
83. 83         return classQuality;
84. 84     }
85. 85     public void setClassQuality(int classQuality) {
86. 86         this.classQuality = classQuality;
87. 87     }
88. 88     public int getAssessmentMethodology() {
89. 89         return assessmentMethodology;
90. 90     }
91. 91     public void setAssessmentMethodology(int assessmentMethodology) {
92. 92         this.assessmentMethodology = assessmentMethodology;
93. 93     }
94. 94 }
95. 95 class CourseSelection {
96. 96     Student student;
97. 97     Course course;
98. 98     Grade grade;
99. 99 }
100. 100 abstract class Grade {
101. 101     int allGrade;
102. 102     abstract void getAllGrade();
103. 103 }
104. 104 class GradeA extends Grade {//考试
105. 105     private int finalGrade;
106. 106     private int usualGrade;
107. 107     GradeA(int finalGrade , int usualGrade) {
108. 108         setFinalGrade(finalGrade);
109. 109         setUsualGrade(usualGrade);
110. 110     }
111. 111     public void setFinalGrade(int finalGrade) {
112. 112         this.finalGrade = finalGrade;
113. 113     }
114. 114     public int getFinalGrade() {
115. 115         return finalGrade;
116. 116     }
117. 117     public void setUsualGrade(int usualGrade) {
118. 118         this.usualGrade = usualGrade;
119. 119     }
120. 120     public int getUsualGrade() {
121. 121         return usualGrade;
122. 122     }
123. 123     @Override
124. 124     void getAllGrade() {
125. 125         allGrade = (int) (finalGrade*0.7+usualGrade*0.3);
126. 126     }
127. 127 }
128. 128 class GradeB extends Grade {//考察
129. 129     private int finalGrade;
130. 130     GradeB(int finalGrade) {
131. 131         setFinalGrade(finalGrade);
132. 132     }
133. 133     public void setFinalGrade(int finalGrade) {
134. 134         this.finalGrade = finalGrade;
135. 135     }
136. 136     public int getFinalGrade() {
137. 137         return finalGrade;
138. 138     }
139. 139     @Override
140. 140     void getAllGrade() {
141. 141         allGrade = finalGrade;
142. 142     }
143. 143 }
144. 144 class GradeC extends Grade {//实验
145. 145     ArrayList<Integer> usualGrades;
146. 146     GradeC(ArrayList<Integer> usualGrades) {
147. 147         this.usualGrades = usualGrades;
148. 148     }
149. 149     @Override
150. 150     void getAllGrade() {
151. 151         allGrade = 0;
152. 152         for(int x:usualGrades){
153. 153             allGrade+=x;
154. 154         }
155. 155         allGrade = allGrade/usualGrades.size();
156. 156     }
157. 157 }
158. 158 class Print {
159. 159     public void personPrint(HashMap<String , Student> students, ArrayList<CourseSelection> courseSelections) {
160. 160         students.keySet().stream()
161. 161                 .sorted()
162. 162                 .forEach(key -> {
163. 163                     Student student = students.get(key); // 获取当前学生信息
164. 164                     int[] gradeData = courseSelections.stream()
165. 165                             .filter(cs -> cs.student.getStudentNum().equals(student.getStudentNum()))
166. 166                             .mapToInt(cs -> {
167. 167                                 cs.grade.getAllGrade(); // 更新成绩状态
168. 168                                 return cs.grade.allGrade; // 提取当前的总成绩
169. 169                             })
170. 170                             .toArray();
171. 171                     if (gradeData.length == 0) { // 没有成绩数据
172. 172                         System.out.println(student.getStudentNum() + " " + student.getName() + " did not take any exams");
173. 173                     } else {
174. 174                         // 计算平均分并打印
175. 175                         int averageGrade = Arrays.stream(gradeData).sum() / gradeData.length;
176. 176                         System.out.println(student.getStudentNum() + " " + student.getName() + " " + averageGrade);
177. 177                     }
178. 178                 });
179. 179     }
180. 180     public void coursePrint(HashMap<String, Course> courses, ArrayList<CourseSelection> courseSelections) {
181. 181         courses.keySet().stream()
182. 182                 .sorted(new SoftName())
183. 183                 .forEach(key -> {
184. 184                     Course course = courses.get(key);
185. 185                     // 根据课程筛选相关的选课记录
186. 186                     List<CourseSelection> selected = new ArrayList<>();
187. 187 for (CourseSelection cs : courseSelections) {
188. 188     if (cs.course.getClassName().equals(course.getClassName())) {
189. 189         selected.add(cs);
190. 190     }
191. 191 }
192. 192
193. 193                     if (selected.isEmpty()) {
194. 194                         System.out.println(course.getClassName() + " has no grades yet");
195. 195                         return;
196. 196                     }
197. 197                     // 计算总分和平均分
198. 198                     double allGradesSum = 0;
199. 199                     double finalGradeSum = 0;
200. 200                     double usualGradeSum = 0;
201. 201                     int gradesCount = 0;
202. 202                     int usualGradesCount = 0;
203. 203
204. 204                     for (CourseSelection cs : selected) {
205. 205                         cs.grade.getAllGrade();
206. 206                         allGradesSum += cs.grade.allGrade;
207. 207                         if (cs.grade instanceof GradeA) {
208. 208                             finalGradeSum += ((GradeA) cs.grade).getFinalGrade(); // Final grade for GradeA
209. 209                             usualGradeSum += ((GradeA) cs.grade).getUsualGrade(); // Usual grade for GradeA
210. 210                             usualGradesCount++;
211. 211                         } else if (cs.grade instanceof GradeB) {
212. 212                             finalGradeSum += ((GradeB) cs.grade).getFinalGrade(); // Final grade for GradeB
213. 213                         }
214. 214                         gradesCount++;
215. 215                     }
216. 216                     double average = gradesCount > 0 ? allGradesSum / gradesCount : 0;
217. 217                     double averageFinal = gradesCount > 0 ? finalGradeSum / gradesCount : 0;
218. 218                     double averageUsual = usualGradesCount > 0 ? usualGradeSum / usualGradesCount : 0;
219. 219                     String output;
220. 220                     if (course.getAssessmentMethodology() == 3) {
221. 221                         output = String.format("%s %d", course.getClassName(), (int) average);
222. 222                     } else if (usualGradesCount == 0) {
223. 223                         output = String.format("%s %d %d", course.getClassName(), (int) averageFinal, (int) average);
224. 224                     } else {
225. 225                         output = String.format("%s %d %d %d", course.getClassName(), (int) averageUsual, (int) averageFinal, (int) average);
226. 226                     }
227. 227                     System.out.println(output);
228. 228                 });
229. 229     }
230. 230     public void classPrint(HashMap<String, Class> classes, ArrayList<CourseSelection> courseSelections) {
231. 231         classes.keySet().stream().sorted().forEach(classKey -> {
232. 232             Class c = classes.get(classKey);
233. 233             double average = courseSelections.stream()
234. 234                     .filter(cs -> c.students.containsKey(cs.student.getStudentNum()))
235. 235                     .mapToInt(cs -> cs.grade.allGrade)
236. 236                     .average()
237. 237                     .orElse(-1);  // 使用 -1 来表示没有成绩的情况
238. 238
239. 239             String output = average == -1 ?
240. 240                     c.getClassNum() + " has no grades yet" :
241. 241                     c.getClassNum() + " " + (int) average;
242. 242
243. 243             System.out.println(output);
244. 244         });
245. 245     }
246. 246     public void wrongFormat() {
247. 247         System.out.println("wrong format");
248. 248     }
249. 249     public void course_not_Exist(String name) {
250. 250         System.out.println(name+" does not exist");
251. 251     }
252. 252     public void course_not_Match(String studentNum , String studentName) {
253. 253         System.out.println(studentNum+" "+studentName+" : access mode mismatch");
254. 254     }
255. 255     public void course_not_Match(String name) {
256. 256         System.out.println(name+" : course type & access mode mismatch");
257. 257     }
258. 258     static class SoftName implements Comparator<String> {
259. 259         private static final Comparator<Object> localeComparator = Collator.getInstance(Locale.CHINA);
260. 260         @Override
261. 261         public int compare(String name1 , String name2) {
262. 262             return localeComparator.compare(name1, name2);
263. 263         }
264. 264     }
265. 265 }
266. 266 class MessageGetAndPrint {
267. 267     Print print;
268. 268     HashMap<String , Class> classes = new HashMap<>();
269. 269     HashMap<String , Student> students = new HashMap<>();
270. 270     HashMap<String , Course> courses = new HashMap<>();
271. 271     ArrayList<CourseSelection> courseSelections = new ArrayList<>();
272. 272     public void getMessage(String getInput) {
273. 273         String[] input = getInput.split(" ");
274. 274         try {
275. 275             if (input.length == 2 && input[1].equals("必修")) {
276. 276                 String courseName = input[0];
277. 277                 if(!courses.containsKey(courseName)) {
278. 278                     int i = 1, j = 1; // 保留原代码中的变量和逻辑
279. 279                     Course course = new Course(courseName, i, j);
280. 280                     courses.put(courseName, course);
281. 281                 }
282. 282             }
283. 283         } catch (PatternSyntaxException e) {
284. 284             // 此处可以处理正则表达式的语法错误，但按照题设这里应该没有异常发生，
285. 285             // 所以可以忽略。
286. 286         }
287. 287         if(getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)$")) {
288. 288             String[] courseTypes = {"", "必修", "选修", "实验"};
289. 289             String[] examTypes = {"", "考试", "考察", "实验"};
290. 290             int courseTypeIndex = -1, examTypeIndex = -1;
291. 291             for (int k = 1; k <= 3; k++) {
292. 292                 if (input[1].equals(courseTypes[k])) {
293. 293                     courseTypeIndex = k;
294. 294                     break;
295. 295                 }
296. 296             }
297. 297             for (int k = 1; k <= 3; k++) {
298. 298                 if (input[2].equals(examTypes[k])) {
299. 299                     examTypeIndex = k;
300. 300                     break;
301. 301                 }
302. 302             }
303. 303             if (courseTypeIndex == -1 || examTypeIndex == -1) {
304. 304                 // 未知的课程类型或考试类型，抛出异常或者默认值
305. 305                 print.wrongFormat();
306. 306             }
307. 307             if (!((courseTypeIndex == 1 && examTypeIndex == 1)  // 必修+考试
308. 308                     || (courseTypeIndex == 2 && examTypeIndex == 2)  // 选修+考察
309. 309                     || (courseTypeIndex == 3 && examTypeIndex == 3))) {  // 实验+实验
310. 310                 print.course_not_Match(input[0]);
311. 311                 return;
312. 312             }
313. 313             if(courses.containsKey(input[0])) {
314. 314                 return;
315. 315             }
316. 316             Course course = new Course(input[0], courseTypeIndex, examTypeIndex);
317. 317             courses.put(input[0], course);
318. 318             return;
319. 319         }
320. 320
321. 321         if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)( )([0-9]|[1-9][0-9]|100)$")) {
322. 322             if (courseSelections.stream().anyMatch(cs -> cs.student.getStudentNum().equals(input[0])
323. 323                     && cs.student.getName().equals(input[1])
324. 324                     && cs.course.getClassName().equals(input[2])))
325. 325                 return;
326. 326
327. 327             Student student = new Student(input[1], input[0]);
328. 328             students.put(input[0], student);
329. 329
330. 330             String classNum = input[0].substring(0, 6);
331. 331             classes.computeIfAbsent(classNum, key -> {
332. 332                 Class aClass = new Class(key);
333. 333                 aClass.students = new HashMap<>();
334. 334                 return aClass;
335. 335             }).students.put(input[0], student);
336. 336
337. 337             if (!courses.containsKey(input[2])) {
338. 338                 print.course_not_Exist(input[2]);
339. 339                 return;
340. 340             }
341. 341
342. 342             if (courses.get(input[2]).getAssessmentMethodology() != 1) {
343. 343                 print.course_not_Match(input[0], input[1]);
344. 344                 return;
345. 345             }
346. 346
347. 347             Course course = courses.get(input[2]);
348. 348             CourseSelection courseSelection = new CourseSelection();
349. 349             courseSelection.student = student;
350. 350             courseSelection.course = course;
351. 351             courseSelection.grade = new GradeA(Integer.parseInt(input[4]), Integer.parseInt(input[3]));
352. 352             courseSelections.add(courseSelection);
353. 353             return;
354. 354         }
355. 355
356. 356         if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|10{2})$")) {
357. 357             if (courseSelections.stream().anyMatch(cs ->
358. 358                     cs.student.getStudentNum().equals(input[0]) &&
359. 359                             cs.student.getName().equals(input[1]) &&
360. 360                             cs.course.getClassName().equals(input[2])))
361. 361                 return;
362. 362
363. 363             Student student = new Student(input[1], input[0]);
364. 364             students.put(input[0], student);
365. 365
366. 366             String classNum = input[0].substring(0, 6);
367. 367             classes.computeIfAbsent(classNum, key -> {
368. 368                 Class aClass = new Class(key);
369. 369                 aClass.students = new HashMap<>();
370. 370                 return aClass;
371. 371             }).addStudent(student);
372. 372
373. 373             if (!courses.containsKey(input[2])) {
374. 374                 print.course_not_Exist(input[2]);
375. 375                 return;
376. 376             }
377. 377
378. 378             if (courses.get(input[2]).getAssessmentMethodology() != 2) {
379. 379                 print.course_not_Match(input[0], input[1]);
380. 380                 return;
381. 381             }
382. 382
383. 383             Course course = courses.get(input[2]);
384. 384             CourseSelection courseSelection = new CourseSelection();
385. 385             courseSelection.student = student;
386. 386             courseSelection.course = course;
387. 387             int finalGrade = Integer.parseInt(input[3]);
388. 388             courseSelection.grade = new GradeB(finalGrade);
389. 389             courseSelections.add(courseSelection);
390. 390             return;
391. 391         }
392. 392         if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([4-9])( )((([0-9]|[1-9][0-9]|100)( ))+)([0-9]|[1-9][0-9]|100)$")) {
393. 393             boolean selectionExists = courseSelections.stream().anyMatch(courseSelection ->
394. 394                     courseSelection.student.getStudentNum().equals(input[0]) &&
395. 395                             courseSelection.student.getName().equals(input[1]) &&
396. 396                             courseSelection.course.getClassName().equals(input[2])
397. 397             );
398. 398             if (selectionExists) {
399. 399                 return;
400. 400             }
401. 401
402. 402             Student student = students.computeIfAbsent(input[0], num -> new Student(input[1], num));
403. 403             String classNum = input[0].substring(0, 6);
404. 404             Class aClass = classes.computeIfAbsent(classNum, num -> {
405. 405                 Class newClass = new Class(num);
406. 406                 newClass.students = new HashMap<>();
407. 407                 return newClass;
408. 408             });
409. 409             aClass.addStudent(student);
410. 410
411. 411             Course course = courses.get(input[2]);
412. 412             if (course == null) {
413. 413                 print.course_not_Exist(input[2]);
414. 414                 return;
415. 415             }
416. 416
417. 417             if (course.getAssessmentMethodology() != 3) {
418. 418                 print.course_not_Match(input[0], input[1]);
419. 419                 return;
420. 420             }
421. 421
422. 422             int usualNum = Integer.parseInt(input[3]);
423. 423             if (input.length - 4 != usualNum) {
424. 424                 print.course_not_Match(input[0], input[1]);
425. 425                 return;
426. 426             }
427. 427             CourseSelection courseSelection = new CourseSelection();
428. 428             courseSelection.student = student;
429. 429             courseSelection.course = courses.get(input[2]);
430. 430
431. 431             ArrayList<Integer> usualGrades = IntStream.rangeClosed(1, usualNum)
432. 432                     .mapToObj(t -> Integer.parseInt(input[3 + t]))
433. 433                     .collect(Collectors.toCollection(ArrayList::new));
434. 434
435. 435             courseSelection.grade = new GradeC(usualGrades);
436. 436             courseSelections.add(courseSelection);
437. 437             return;
438. 438         }
439. 439         print.wrongFormat();
440. 440     }
441. 441 }

复制代码

View Code类图如下：
 

 设计思路：

• 创建必要的类（Course、Grade、Student、Class）来表示课程和成绩相关的信息，定义合适的属性和方法。
  
• 解析输入的课程信息和成绩信息：
  
  
  
  • 通过字符串分割和正则表达式等方式，将输入的信息解析为课程名称、课程性质、考核方式等课程信息。
    
  • 根据课程性质和考核方式，判断成绩信息应该属于哪种类型（考试、考察、实验）的成绩。
    
  • 将成绩信息解析为学号、姓名、课程名称、平时成绩、期末成绩等成绩信息。
    
  
  
• 根据课程信息和成绩信息的约束，进行合法性检查：
  
  
  
  • 检查课程信息中的课程性质和考核方式是否匹配。
    
  • 检查成绩是否超出范围，例如平时成绩和期末成绩的取值范围是[0,100]。
    
  • 检查学号、姓名等信息的合法性。
    
  
  
• 根据解析的数据构建对象并进行数据处理：
  
  
  
  • 创建Course对象，将课程信息存储到HashMap或ArrayList中，用于后续处理和输出。
    
  • 创建Grade对象，将成绩信息存储到HashMap或ArrayList中，用于后续处理和输出。
    
  • 创建Student对象，根据成绩信息计算总成绩平均分并存储到学生对象中。
    
  • 创建Class对象，根据学生信息计算班级总成绩平均分并存储到班级对象中。
    
  
  
• 处理数据并输出结果：
  
  
  
  • 遍历学生列表，按学号排序，并输出每个学生的学号、姓名、总成绩平均分。
    
  • 遍历课程列表，按课程名称排序，并输出每门课程的平时成绩平均分、期末考试平均分、总成绩平均分。
    
  • 遍历班级列表，按班级号排序，并输出每个班级的班级号、总成绩平均分。
    
  
  
• 处理异常情况：
  
  
  
  • 如果遇到格式错误、数据不合法或者其他异常情况，输出相应的错误提示信息。
    
  
  

第八次大作业：

课程成绩3：

1. import java.io.BufferedReader;
2. import java.io.IOException;
3. import java.io.InputStreamReader;
4. import java.util.*;
5. import java.util.stream.Collectors;
6. import java.util.stream.IntStream;
7. import java.util.concurrent.atomic.AtomicReference;
10. public class Main {
11.     public static void main(String[] args) throws IOException {
12.     BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
13.     MessageGetAndPrint messageGetAndPrint = new MessageGetAndPrint();
14.     messageGetAndPrint.print = new Print();
15.    
16.     while (true) {
17.         String message = in.readLine();
18.         if ("end".equals(message)) {
19.             messageGetAndPrint.print.personPrint(messageGetAndPrint.students, messageGetAndPrint.courseSelections);
20.             messageGetAndPrint.print.coursePrint(messageGetAndPrint.courses, messageGetAndPrint.courseSelections);
21.             messageGetAndPrint.print.classPrint(messageGetAndPrint.classes, messageGetAndPrint.courseSelections);
22.             break;
23.         }
24.         messageGetAndPrint.getMessage(message);
25.     }
26. }
27. }
28. class Class {
29.     private String classNum;
30.     HashMap<String , Student> students;
31.     Class(String classNum) {
32.         setClassNum(classNum);
33.     }
34.     public void setClassNum(String classNum) {
35.         this.classNum = classNum;
36.     }
37.     public String getClassNum() {
38.         return classNum;
39.     }
40.     public void addStudent(Student student) {
41.         students.put(student.getStudentNum() , student);
42.     }
43. }
44. class Student {
45.     private String name;
46.     private String studentNum;
47.     Student(String name , String studentNum) {
48.         setName(name);
49.         setStudentNum(studentNum);
50.     }
51.     public String getName() {
52.         return name;
53.     }
54.     public void setName(String name) {
55.         this.name = name;
56.     }
57.     public String getStudentNum() {
58.         return studentNum;
59.     }
60.     public void setStudentNum(String studentNum) {
61.         this.studentNum = studentNum;
62.     }
63. }
64. class Course {
65.     private String className;
66.     private int classQuality;
67.     private int assessmentMethodology;
68.     ArrayList<Float> weightFunction = new ArrayList<>();
69.     Course(String className , int classQuality , int assessmentMethodology) {
70.         setClassName(className);
71.         setClassQuality(classQuality);
72.         setAssessmentMethodology(assessmentMethodology);
73.     }
74.     public String getClassName() {
75.         return className;
76.     }
77.     public void setClassName(String className) {
78.         this.className = className;
79.     }
80.     public int getClassQuality() {
81.         return classQuality;
82.     }
83.     public void setClassQuality(int classQuality) {
84.         this.classQuality = classQuality;
85.     }
86.     public int getAssessmentMethodology() {
87.         return assessmentMethodology;
88.     }
89.     public void setAssessmentMethodology(int assessmentMethodology) {
90.         this.assessmentMethodology = assessmentMethodology;
91.     }
92. }
93. class CourseSelection {
94.     Student student;
95.     Course course;
96.     Grade grade;
97. }
99. class Grade {
100.     SubItemGrades subItemGrades = new SubItemGrades();
101.     public int getGrade() {
102.         AtomicReference<Float> allGrades = new AtomicReference<>(0.0f);
103.         IntStream.range(0, subItemGrades.subItem.size()).forEach(i -> allGrades.updateAndGet(v -> v + subItemGrades.subItem.get(i) * subItemGrades.grades.get(i)));
104.         return allGrades.get().intValue();
105.     }
106. }
107. class SubItemGrades {
108.     ArrayList<Integer> grades = new ArrayList<>();
109.     ArrayList<Float> subItem = new ArrayList<>();
110. }
111. class Print {
112.     public void personPrint(HashMap<String, Student> students, ArrayList<CourseSelection> courseSelections) {
113.         Map<String, List<CourseSelection>> courseSelectionsByStudent = courseSelections.stream()
114.                 .collect(Collectors.groupingBy(cs -> cs.student.getStudentNum()));
116.         List<String> sortedStudentKeys = new ArrayList<>(students.keySet());
117.         Collections.sort(sortedStudentKeys);
119.         sortedStudentKeys.forEach(key -> {
120.             StringBuilder output = new StringBuilder(students.get(key).getStudentNum() + " " + students.get(key).getName());
121.             List<CourseSelection> studentCourseSelections = courseSelectionsByStudent.get(key);
123.             if (studentCourseSelections == null || studentCourseSelections.isEmpty()) {
124.                 output.append(" did not take any exams");
125.             } else {
126.                 int averageGrade = studentCourseSelections.stream()
127.                         .mapToInt(cs -> cs.grade.getGrade())
128.                         .sum() / studentCourseSelections.size();
129.                 output.append(" ").append(averageGrade);
130.             }
132.             System.out.println(output);
133.         });
134.     }
135.     public void coursePrint(HashMap<String, Course> courses, ArrayList<CourseSelection> courseSelections) {
136.         Map<String, List<CourseSelection>> courseGrades = courseSelections.stream()
137.                 .collect(Collectors.groupingBy(cs -> cs.course.getClassName()));
139.         courses.values().stream()
140.                 .sorted(Comparator.comparing(Course::getClassName))
141.                 .map(Course::getClassName)
142.                 .forEach(key -> {
143.                     List<CourseSelection> gradeList = courseGrades.computeIfAbsent(key, k -> new ArrayList<>());
144.                     int averageGrade;
146.                     if (!gradeList.isEmpty()) {
147.                         averageGrade = gradeList.stream()
148.                                 .mapToInt(cs -> cs.grade.getGrade())
149.                                 .sum() / gradeList.size();
150.                         System.out.printf("%s %d%n", key, averageGrade);
151.                     } else {
152.                         System.out.printf("%s has no grades yet%n", key);
153.                     }
154.                 });
155.     }
156.     public void classPrint(HashMap<String, Class> classes, ArrayList<CourseSelection> courseSelections) {
157.         Map<String, List<CourseSelection>> classGrades = courseSelections.stream()
158.                 .filter(cs -> classes.values().stream()
159.                         .anyMatch(c -> c.students.containsKey(cs.student.getStudentNum())))
160.                 .collect(Collectors.groupingBy(cs -> classes.values().stream()
161.                         .filter(c -> c.students.containsKey(cs.student.getStudentNum()))
162.                         .findFirst().get().getClassNum()));
164.         classes.values().stream()
165.                 .sorted(Comparator.comparing(Class::getClassNum))
166.                 .map(Class::getClassNum)
167.                 .forEach(key -> {
168.                     List<CourseSelection> gradeList = classGrades.computeIfAbsent(key, k -> new ArrayList<>());
169.                     int averageGrade;
171.                     if (!gradeList.isEmpty()) {
172.                         averageGrade = gradeList.stream()
173.                                 .mapToInt(cs -> cs.grade.getGrade())
174.                                 .sum() / gradeList.size();
175.                         System.out.printf("%s %d%n", key, averageGrade);
176.                     } else {
177.                         System.out.printf("%s has no grades yet%n", key);
178.                     }
179.                 });
180.     }
181.     public void wrongFormat() {
182.         System.out.println("wrong format");
183.     }
184.     public void courseExist(String name) {
185.         System.out.println(name+" does not exist");
186.     }
187.     public void courseMatch(String studentNum , String studentName) {
188.         System.out.println(studentNum+" "+studentName+" : access mode mismatch");
189.     }
190.     public void courseMatch(String name) {
191.         System.out.println(name+" : course type & access mode mismatch");
192.     }
193.     public void numMatch(String name) {
194.         System.out.println(name+" : number of scores does not match");
195.     }
196.     public void weightValue(String name) {
197.         System.out.println(name+" : weight value error");
198.     }
199. }
200. class MessageGetAndPrint {
201.     Print print;
202.     HashMap<String , Class> classes = new HashMap<>();
203.     HashMap<String , Student> students = new HashMap<>();
204.     HashMap<String , Course> courses = new HashMap<>();
205.     ArrayList<CourseSelection> courseSelections = new ArrayList<>();
206.     public void getMessage(String getInput) {
207.         String[] message = getInput.split(" ");
208.         if(getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)$") ||
209.                 getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )((0.(0)+[1-9]|0.[1-9][0-9]*)( )(0.(0)+[1-9]|0.[1-9][0-9]*)$)") ||
210.                 getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )([4-9])((( )(0.(0)+[1-9]|0.[1-9][0-9]*|1))*)(( )(0.(0)+[1-9]|0.[1-9][0-9]*))$")
211.         ) {
212.             int i=0,j=0;
213.             if (!courses.containsKey(message[0])) {
214.                 switch (message[1]) {
215.                     case "必修" : i = 1;
216.                     case "选修" : i = 2;
217.                     case "实验" : i = 3;
218.                 }
219.                 switch (message[2]) {
220.                     case "考试":   j = 1;  break;
221.                     case "考察":   j = 2;  break;
222.                     case "实验":   j = 3;  break;
223.                 }
225.                 boolean mismatch = (i == 1 && j != 1) || (i == 3 && j != 3) || (i != 3 && j == 3);
226.                 boolean invalidLength = (j == 1 && message.length != 5) ||
227.                         (j == 2 && message.length != 3) ||
228.                         (j == 3 && message.length - 4 != Integer.parseInt(message[3]));
230.                 if (mismatch) {
231.                     print.courseMatch(message[0]);
232.                 } else if (invalidLength) {
233.                     print.numMatch(message[0]);
234.                 } else {
235.                     Course course = new Course(message[0], i, j);
236.                     float sumWeight = 0;
238.                     if (j == 1 || j == 3) {
239.                         for (int k = 0; k < (j == 1 ? 2 : Integer.parseInt(message[3])); k++) {
240.                             float weight = Float.parseFloat(message[4 + k]);
241.                             sumWeight += weight;
242.                             course.weightFunction.add(weight);
243.                         }
244.                     } else {
245.                         course.weightFunction.add(1F);
246.                         sumWeight = 1;
247.                     }
249.                     if (Math.abs(sumWeight - 1) > 0.001) {
250.                         print.weightValue(message[0]);
251.                     } else {
252.                         courses.put(message[0], course);
253.                     }
254.                 }
255.             }
256.         }
257.         else if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)$") ||
258.                 getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)( )([0-9]|[1-9][0-9]|100)$") ||
259.                 getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )((([0-9]|[1-9][0-9]|100)( ))*)([0-9]|[1-9][0-9]|100)$")
260.         ) {
261.             boolean courseSelectionExists = courseSelections.stream()
262.                     .anyMatch(courseSelection -> courseSelection.student.getStudentNum().equals(message[0])
263.                             && courseSelection.student.getName().equals(message[1])
264.                             && courseSelection.course.getClassName().equals(message[2]));
266.             if (courseSelectionExists) {
267.                 return;
268.             }
270.             Student student = new Student(message[1], message[0]);
271.             students.put(message[0] , student);
273.             String classNum = message[0].substring(0 , 6);
275.             if (!classes.containsKey(classNum)) {
276.                 Class aClass = new Class(classNum);
277.                 aClass.students = new HashMap<>();
278.                 classes.put(classNum , aClass);
279.             }
281.             classes.get(classNum).addStudent(student);
283.             if (!(courses.containsKey(message[2]))) {
284.                 print.courseExist(message[2]);
285.             } else {
286.                 if (message.length - 3 != courses.get(message[2]).weightFunction.size()) {
287.                     print.courseMatch(message[0], message[1]);
288.                     return;
289.                 }
291.                 CourseSelection courseSelection = new CourseSelection();
292.                 courseSelection.student = student;
293.                 courseSelection.course = courses.get(message[2]);
295.                 Grade grade = new Grade();
296.                 IntStream.range(0, message.length - 3)
297.                         .forEach(i -> grade.subItemGrades.grades.add(Integer.parseInt(message[3 + i])));
299.                 grade.subItemGrades.subItem = courses.get(message[2]).weightFunction;
300.                 courseSelection.grade = grade;
302.                 courseSelections.add(courseSelection);
303.             }
304.         }
305.         else
306.             print.wrongFormat();
307.     }
308. }

复制代码

View Code类图如下：

 我并没有通过所有的测试点，以下测试点并没有通过：

题目的分析如下：
这道题目要求修改成绩类的继承关系为组合关系，使用组合关系将课程成绩类和分项成绩类组合起来。还新增了分项成绩的权重属性，并根据权重计算每个分项成绩的总成绩。
首先，需修改类结构如下：

• 定义一个"Course"类，包含课程名称、课程性质、考核方式和分项成绩数量等属性，并提供相应的构造方法和访问方法。
  
• 定义一个"GradeComponent"类，包含分项成绩的分值和权重属性，并提供相应的构造方法和访问方法。
  
• 定义一个"CourseGrade"类，包含该门课程的所有分项成绩和所属的课程对象，通过组合关系与"Course"和"GradeComponent"类建立关联。
  
• 定义一个"Grade"类，包含学号、姓名、成绩列表（包含"CourseGrade"对象）等属性，并提供相应的构造方法和访问方法。
  
• 定义一个"Student"类，包含学号、姓名、成绩列表（包含"CourseGrade"对象）等属性，并提供添加成绩、计算总成绩平均分等方法。
  
• 定义一个"Class"类，包含班级号、学生列表等属性，并提供按学号排序、计算班级总成绩平均分等方法。
  

其次，修改计算总成绩的方式：

• 考试课总成绩的计算方法不变，仍然为将平时成绩乘以平时成绩的权重再加上期末成绩乘以期末成绩的权重。
  
• 实验课总成绩的计算方法变为将每个实验成绩乘以实验成绩的权重，并累加所有分项成绩的总和。
  

期末考试：

 7-3 魔方排序问题

1.   1 import java.util.Scanner;
2.   2 import java.util.ArrayList;
3.   3 import java.util.Comparator;
4.   4 import java.math.BigDecimal;
5.   5 import java.math.RoundingMode;
6.   6
7.   7 abstract class RubikCube implements Comparable<RubikCube>{
8.   8     protected String Color;
9.   9     protected int layer;
10. 10     Solid solid;
11. 11     @Override
12. 12     public int compareTo(RubikCube other) {
13. 13         return this.getVolume().compareTo(other.getVolume());
14. 14     }
15. 15     public RubikCube() {
16. 16     }
17. 17     public RubikCube(String Color,int layer,Solid solid){
18. 18         this.Color = Color;
19. 19         this.layer = layer;
20. 20         this.solid = solid;
21. 21     }
22. 22
23. 23     public void setColor(String color) {
24. 24         Color = color;
25. 25     }
26. 26
27. 27     public String getColor() {
28. 28         return Color;
29. 29     }
30. 30
31. 31     public void setLayer(int layer) {
32. 32         this.layer = layer;
33. 33     }
34. 34
35. 35     public int getLayer() {
36. 36         return layer;
37. 37     }
38. 38
39. 39     public void setSolid(Solid solid) {
40. 40         this.solid = solid;
41. 41     }
42. 42
43. 43     public Solid getSolid() {
44. 44         return solid;
45. 45     }
46. 46     public abstract double getArea();
47. 47     public abstract BigDecimal getVolume();
48. 48
49. 49 }
50. 50
51. 51 class SquareCube extends RubikCube {
52. 52
53. 53     public SquareCube(String color, int layer, Solid solid) {
54. 54         super(color, layer, solid);
55. 55     }
56. 56
57. 57     @Override
58. 58     public double getArea() {
59. 59         double unitArea = solid.getArea();
60. 60         return unitArea *  Math.pow(getLayer(), 2);  // Total surface area
61. 61     }
62. 62
63. 63     @Override
64. 64     public BigDecimal getVolume() {
65. 65         double unitVolume = solid.getVolume();
66. 66         BigDecimal value = new BigDecimal(unitVolume * Math.pow(getLayer(), 3));
67. 67         BigDecimal rounded = value.setScale(2, RoundingMode.HALF_UP);
68. 68         return rounded;  // Total volume
69. 69     }
70. 70 }
71. 71
72. 72 class RegularPyramidCube extends RubikCube {
73. 73
74. 74     public RegularPyramidCube(String color, int layer, Solid solid) {
75. 75         super(color, layer, solid);
76. 76     }
77. 77
78. 78     @Override
79. 79     public double getArea() {
80. 80         double unitArea = solid.getArea();
81. 81         return unitArea *  getLayer() * getLayer();
82. 82     }
83. 83
84. 84     @Override
85. 85     public BigDecimal getVolume() {
86. 86         double unitVolume = solid.getVolume();
87. 87         return BigDecimal.valueOf(unitVolume * getLayer() * getLayer()*getLayer());
88. 88     }
89. 89 }
90. 90 abstract class Solid {
91. 91     protected double side;
92. 92     public Solid(){
93. 93     }
94. 94
95. 95     public void setSide(double side) {
96. 96         this.side = side;
97. 97     }
98. 98
99. 99     public double getSide() {
100. 100         return side;
101. 101     }
102. 102     public Solid(double side) {
103. 103         this.side = side;
104. 104     }
105. 105
106. 106     public abstract double getArea();
107. 107
108. 108     public abstract double getVolume();
109. 109 }
110. 110
111. 111 class Cube extends Solid {
112. 112     public Cube(){
113. 113     }
114. 114     public Cube(double side) {
115. 115         super(side);
116. 116     }
117. 117
118. 118     @Override
119. 119     public double getArea() {
120. 120         return 6 * side * side;
121. 121     }
122. 122
123. 123     @Override
124. 124     public double getVolume() {
125. 125         return side * side * side;
126. 126     }
127. 127 }
128. 128
129. 129 class RegularPyramid extends Solid {
130. 130     public RegularPyramid(double side) {
131. 131         super(side);
132. 132     }
133. 133
134. 134     public RegularPyramid(){
135. 135     }
136. 136     private double getHeight() {
137. 137         return Math.sqrt(side * side - (side / 2) * (side / 2));
138. 138     }
139. 139     @Override
140. 140     public double getArea() {
141. 141         return (0.5 * side * side * Math.sin(Math.PI / 3) + (3 * side * getHeight() / 2));
142. 142     }
143. 143
144. 144     @Override
145. 145     public double getVolume() {
146. 146         return (Math.pow(side, 3) * Math.sqrt(2)) / 12;
147. 147     }
148. 148 }
149. 149
150. 150 public class Main {
151. 151     public static void main(String[] args) {
152. 152         // TODO Auto-generated method stub
153. 153         Scanner input = new Scanner(System.in);
154. 154
155. 155         String color;
156. 156         int layer;
157. 157         double side;
158. 158         RubikCube cube;
159. 159
160. 160         ArrayList<RubikCube> list = new ArrayList<>();
161. 161
162. 162         int choice = input.nextInt();
163. 163
164. 164         while(choice != 0) {
165. 165             switch(choice) {
166. 166                 case 1://SquareCube
167. 167                     color = input.next();
168. 168                     layer = input.nextInt();
169. 169                     side = input.nextDouble();
170. 170                     cube = new SquareCube(color, layer,new Cube(side));
171. 171                     list.add(cube);
172. 172                     break;
173. 173                 case 2://RegularPyramidCube
174. 174                     color = input.next();
175. 175                     layer = input.nextInt();
176. 176                     side = input.nextDouble();
177. 177                     cube = new RegularPyramidCube(color, layer,new RegularPyramid(side));
178. 178                     list.add(cube);
179. 179                     break;
180. 180             }
181. 181             choice = input.nextInt();
182. 182         }
183. 183
184. 184         list.sort(Comparator.naturalOrder());//正向排序
185. 185
186. 186         for(int i = 0; i < list.size(); i++) {
187. 187             System.out.print(list.get(i).getColor() + " " +
188. 188                     String.format("%.2f", list.get(i).getArea()) + " " +
189. 189                     String.format("%.2f", list.get(i).getVolume()) );
190. 190             System.out.println("");
191. 191         }
192. 192     }
193. 193 }

复制代码

View Code

这题我并没有拿到满分，后来与同学交流发现可能是因为数据用的double类型，如果将所有的数据类型改变为BigDecimal，就能过了测试点。
​ Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。
​ BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。
7-4 销售步枪问题（附加题）

[code]  1 import java.util.Scanner;  2   3 public class Main {  4     public static void main(String[] args) {  5         Scanner in = new Scanner(System.in);  6         int lockQuantity = in.nextInt();  7         int stockQuantity = in.nextInt();  8         int barrelQuantity = in.nextInt();  9  10         try { 11             SalesOrder order = new SalesOrder(lockQuantity, stockQuantity, barrelQuantity); 12             System.out.printf("%.2f %.2f\n", order.calculateTotalSales(), order.calculateCommission()); 13         } catch (IllegalArgumentException e) { 14             System.out.println(e.getMessage()); 15         } 16     } 17 } 18 class Barrel { 19     static  double UNIT_PRICE = 25; 20     public Barrel(){ 21     } 22     public Barrel(double UNIT_PRICE){ 23         this.UNIT_PRICE = UNIT_PRICE; 24     } 25  26     public static double getUnitPrice() { 27         return UNIT_PRICE; 28     } 29  30     public static void setUnitPrice(double unitPrice) { 31         UNIT_PRICE = unitPrice; 32     } 33  34     static boolean checkOrder(int quantity) { 35         return quantity >= 0 && quantity = 0 && quantity = 0 && quantity