BLOG-3(软件学院）

  1 import java.text.CollationKey;
  2 import java.text.Collator;
  3 import java.util.*;
  4 import java.util.stream.Collectors;
  5 
  6 public class Main {
  7     public static void main(String[] args) {
  8     @SuppressWarnings("unchecked")
  9         ArrayList<Course> courses = new ArrayList<>();
 10         ArrayList<StudentScore> studentScores = new ArrayList<>();
 11         Scanner scanner = new Scanner(System.in);
 12         String content = "";
 13         while (!"end".equals(content)) {
 14             content = scanner.nextLine();
 15             if (!"end".equals(content)) {
 16                 String[] strings = content.split(" ");
 17                 int length = strings.length;
 18                 //课程信息
 19                 if (length == 3 || length == 2) {
 20                     Course course = new Course(0, strings[0], strings[1], length == 3 ? strings[2] : "");
 21                     courses.add(course);
 22                 } else {
 23                     StudentScore studentScore = new StudentScore(strings[0], strings[1], strings[2], length == 5 ? Integer.valueOf(strings[3]) : null, Integer.valueOf(length == 4 ? strings[3] : strings[4]));
 24                     studentScores.add(studentScore);
 25                 }
 26             }
 27         }
 28 
 29         boolean hasWrong = false;
 30         // 解析课程  考察只有三个成绩
 31         @SuppressWarnings("unchecked")
 32         ArrayList<Course> courseList = new ArrayList<>();
 33         for (Course course : courses) {
 34             boolean match = courseList.stream().anyMatch(s -> course.getName().equals(s.getName()));
 35             if (!match) {
 36                 String quality = course.getQuality();
 37                 String type = course.getType();
 38                 if ("必修".equals(quality) && (null == type || "考试".equals(type))) {
 39                     course.setType("考试");
 40                     courseList.add(course);
 41                 } else if ("选修".equals(quality) && (null != type && ("考试".equals(type) || "考察".equals(type)))) {
 42                     course.setType("选修");
 43                     courseList.add(course);
 44                 } else {
 45                    System.out.println(course.getName() + " : course type & access mode mismatch");
 46              }
 47             }
 48         }
 49         //解析成绩
 50         @SuppressWarnings("unchecked")
 51         ArrayList<StudentScore> studentScoreList = new ArrayList<>();
 52         for (StudentScore studentScore : studentScores) {
 53             boolean match = studentScoreList.stream().anyMatch(s -> s.getCourseName().equals(studentScore.getCourseName()) && s.getNumber().equals(studentScore.getNumber()));
 54             if (!match) {
 55                 if ((null != studentScore.getUsualGrades() && (studentScore.getUsualGrades() > 100 || 0 > studentScore.getUsualGrades()))
 56                         || (null == studentScore.getFinalGrades() || (studentScore.getFinalGrades() > 100 || 0 > studentScore.getFinalGrades()))
 57                 ) {
 58                     System.out.println("wrong format");
 59                     hasWrong = true;
 60                 } else {
 61                     studentScoreList.add(studentScore);
 62                 }
 63             }
 64         }
 65         //班级成绩+有效的成绩
 66         @SuppressWarnings("unchecked")
 67         Map<String, List<StudentScore>> classesScores = new HashMap<>();
 68         for (StudentScore studentScore : studentScoreList) {
 69             Course course = courseList.stream().filter(s -> s.getName().equals(studentScore.getCourseName())).findAny().orElse(null);
 70             if (null == course) {
 71                 System.out.println(studentScore.getCourseName() + " does not exist");
 72             } else {
 73                 String type = course.getType();
 74                 if ("考试".equals(type) && (null == studentScore.getUsualGrades() || null == studentScore.getFinalGrades())) {
 75                     System.out.println(studentScore.getNumber() + " " + studentScore.getName() + " : access mode mismatch");
 76                 } else if ("考察".equals(type) && (null != studentScore.getUsualGrades())) {
 77                     System.out.println(studentScore.getNumber() + " " + studentScore.getName() + " : access mode mismatch");
 78                 } else {
 79                     List<StudentScore> scoreList = classesScores.get(studentScore.getNumber().substring(0,6));
 80                     if (null == scoreList) scoreList = new ArrayList<>();
 81                     scoreList.add(studentScore);
 82                     classesScores.put(studentScore.getNumber().substring(0,6), scoreList);
 83                 }
 84             }
 85         }
 86 
 87 
 88         ArrayList<StudentScore> allStudentScores = new ArrayList<>();
 89         classesScores.forEach((K, V) -> {
 90             allStudentScores.addAll(V);
 91         });
 92 
 93         // 学生平均成绩
 94         @SuppressWarnings("unchecked")
 95         ArrayList<TempAvg> tempAvgsses = new ArrayList<>();
 96         Map<String, List<StudentScore>> collect = allStudentScores.stream().collect(Collectors.groupingBy(StudentScore::getNumber));
 97         collect.forEach((s, sv) -> {
 98             OptionalDouble average = sv.stream().mapToInt(StudentScore::getGrades).average();
 99             TempAvg tempAvg = new TempAvg(s, (int) average.orElseGet(() -> 0.0));
100             tempAvgsses.add(tempAvg);
101         });
102         tempAvgsses.sort(Comparator.comparing(TempAvg::getNumber));
103         tempAvgsses.forEach(s -> {
104             StudentScore studentScore = studentScores.stream().filter(ss -> ss.getNumber().equals(s.getNumber())).findAny().get();
105             System.out.println(studentScore.getNumber() + " " + studentScore.getName() + " " + s.getAvg());
106         });
107         studentScoreList.forEach(s -> {
108             if (!collect.containsKey(s.getNumber())) {
109                 System.out.println(s.getNumber() + " " + s.getName() + " did not take any exams");
110             }
111         });
112 
113         // 单门成绩
114         @SuppressWarnings("unchecked")
115         Map<String, List<StudentScore>> collectCourseName = allStudentScores.stream().collect(Collectors.groupingBy(StudentScore::getCourseName));
116         List<TempAvg> temps= new ArrayList<>();
117         TreeMap<String,String> map=new TreeMap(new CollatorComparator());
118         collectCourseName.forEach((s, sv) -> {
119             // 平时
120             OptionalDouble averageUsu = sv.stream().mapToInt(d->d.getUsualGrades()!=null?d.getUsualGrades():0).average();
121             // 期末
122             OptionalDouble averageFinal = sv.stream().mapToInt(StudentScore::getFinalGrades).average();
123             // 总的
124             OptionalDouble average = sv.stream().mapToInt(StudentScore::getGrades).average();
125             int i = (int) averageUsu.orElseGet(() -> 0.0);
126             String result="";
127             if(i==0)
128              result=s + " "+ (int) averageFinal.orElseGet(() -> 0.0)+" "+ (int) average.orElseGet(() -> 0.0);
129             else  result=s + " " + (int) averageUsu.orElseGet(() -> 0.0) + " " + (int) averageFinal.orElseGet(() -> 0.0) + " " + (int) average.orElseGet(() -> 0.0);
130             TempAvg tempAvg = new TempAvg(s, 0);
131             map.put(s,result);
132             tempAvg.setMessage(result);
133             temps.add(tempAvg);
134         });
135         Collections.sort(temps,Comparator.comparing(TempAvg::getNumber));
136         map.forEach((k,v)->System.out.println(v));
137         courseList.forEach(s -> {
138             if (!collectCourseName.containsKey(s.getName())) {
139                 System.out.println(s.getName() + " has no grades yet");
140             }
141         });
142 
143 
144         // 班级成绩
145         @SuppressWarnings("unchecked")
146        List<TempAvg> tempAvgs = new ArrayList<>();
147         classesScores.forEach((K, V) -> {
148             OptionalDouble average = V.stream().mapToInt(StudentScore::getGrades).average();
149             tempAvgs.add(new TempAvg(K, (int) average.orElseGet(() -> 0.0)));
150         });
151         tempAvgs.sort(Comparator.comparing(TempAvg::getNumber));
152 
153         tempAvgs.forEach(s -> {
154             System.out.println(s.getNumber() + " " + s.getAvg());
155         });
156         studentScoreList.forEach(s -> {
157             if (!classesScores.containsKey(s.getNumber().substring(0,6))) {
158                 System.out.println(s.getNumber().substring(0,6) + " has no grades yet");
159             }
160         });
161 
162     }
163 
164 
165     public static class TempAvg {
166         private String number;
167         private Integer avg;
168 
169         private String message;
170 
171         public TempAvg(String number, Integer avg) {
172             this.number = number;
173             this.avg = avg;
174         }
175 
176         public String getNumber() {
177             return number;
178         }
179 
180         public void setNumber(String number) {
181             this.number = number;
182         }
183 
184         public Integer getAvg() {
185             return avg;
186         }
187 
188         public void setAvg(Integer avg) {
189             this.avg = avg;
190         }
191 
192         public String getMessage() {
193             return message;
194         }
195 
196         public void setMessage(String message) {
197             this.message = message;
198         }
199     }
200 
201 
202     public static class CollatorComparator implements Comparator {
203         Collator collator = Collator.getInstance();
204         public int compare(Object element1, Object element2) {
205             CollationKey key1 = collator.getCollationKey(element1.toString());
206             CollationKey key2 = collator.getCollationKey(element2.toString());
207             return key1.compareTo(key2);
208         }
209     }
210 
211 }
212 
213 class Course {
214     private int id;
215     private String name;
216     private String quality;
217     private String type;
218 
219 
220     public Course() {
221     }
222 
223     public Course(int id, String name, String quality, String type) {
224         this.id = id;
225         this.name = name;
226         this.quality = quality;
227         this.type = type;
228     }
229 
230     public int getId() {
231         return id;
232     }
233 
234     public void setId(int id) {
235         this.id = id;
236     }
237 
238     public String getName() {
239         return name;
240     }
241 
242     public void setName(String name) {
243         this.name = name;
244     }
245 
246     public String getQuality() {
247         return quality;
248     }
249 
250     public void setQuality(String quality) {
251         this.quality = quality;
252     }
253 
254     public String getType() {
255         return type;
256     }
257 
258     public void setType(String type) {
259         this.type = type;
260     }
261 }
262 
263 
264 class StudentScore {
265 
266     private String number;
267     private String name;
268     private String courseName;
269 
270     private Integer grades;
271     private Integer usualGrades;
272     private Integer finalGrades;
273 
274     public String getNumber() {
275         return number;
276     }
277 
278     public void setNumber(String number) {
279         this.number = number;
280     }
281 
282     public String getName() {
283         return name;
284     }
285 
286     public void setName(String name) {
287         this.name = name;
288     }
289 
290     public Integer getUsualGrades() {
291         return usualGrades;
292     }
293 
294     public void setUsualGrades(Integer usualGrades) {
295         this.usualGrades = usualGrades;
296     }
297 
298     public Integer getFinalGrades() {
299         return finalGrades;
300     }
301 
302     public void setFinalGrades(Integer finalGrades) {
303         this.finalGrades = finalGrades;
304     }
305 
306     public String getCourseName() {
307         return courseName;
308     }
309 
310     public void setCourseName(String courseName) {
311         this.courseName = courseName;
312     }
313 
314     public Integer getGrades() {
315         return grades;
316     }
317 
318     public void setGrades(Integer grades) {
319         this.grades = grades;
320     }
321 
322     public StudentScore(String number, String name, String courseName, Integer usualGrades, Integer finalGrades) {
323         this.number = number;
324         this.name = name;
325         this.courseName = courseName;
326         this.usualGrades = usualGrades;
327         this.finalGrades = finalGrades;
328         if (usualGrades != null && finalGrades != null){
329             grades = (int) (usualGrades * 0.3 + finalGrades * 0.7);
330         }else {
331             grades = finalGrades;
332         }
333     }
334 
335 
336 }

  1 import java.text.Collator;
  2 import java.util.*;
  3 import java.io.Serializable;
  4 public class Main {
  5     public static void main(String[] args) {
  6 
  7         Scanner sc = new Scanner(System.in);
  8         // 获取课程信息
  9         List<Course> courses = new ArrayList<>();
 10         // 获取选课信息
 11         List<CurriculaVariable> curriculaVariables = new ArrayList<>();
 12         // 获取学生信息
 13 //        List<Student> students = new ArrayList<>();
 14         Map<Integer, String> students = new HashMap<>();
 15 
 16         // 输入的成绩数量和课程的考核方式不匹配
 17         Map<String, Integer> scoreNumMatchExamType = new HashMap<>();
 18 
 19 
 20         // 平时总成绩
 21         Map<String, Integer> normalPerformance = new HashMap<>();
 22         // 期末总成绩
 23         Map<String, Integer> finalGrade = new HashMap<>();
 24         // 总成绩
 25         Map<String, Integer> totalScore = new HashMap<>();
 26         // 实验成绩
 27         Map<String, Integer> experimentalScore = new HashMap<>();
 28 
 29 
 30         // 课程人数
 31         Map<String, Integer> numberCourses = new HashMap<>();
 32 
 33         // 当前课程是否匹配(根据人名)
 34         Map<String, Boolean> courseTrueOrFalse = new HashMap<>();
 35         // 当前课程是否匹配(根据课名)
 36         Map<String, Boolean> courseTrueOrFalse2 = new HashMap<>();
 37         // 当前课程是否匹配(根据班级名)
 38         Map<String, Boolean> courseTrueOrFalse3 = new HashMap<>();
 39 
 40         // 当期前课程类型和考核类型不匹配
 41         List<String> courseTypeTrueOrFalse = new ArrayList<>();
 42         // 课程成绩不符合
 43         List<String> courseFormat = new ArrayList<>();
 44 
 45         // 信息不符合
 46         Boolean info = false;
 47 
 48         // 创建一个 TreeSet 对象，并传入比较器对象
 49         Set<String> classSet = new TreeSet<>();
 50 
 51         // 班级总成绩
 52         Map<String, Integer> classGrade = new HashMap<>();
 53         // 班级总人数
 54         Map<String, Integer> classStudentNum = new HashMap<>();
 55 
 56 
 57 
 58         String content = "";
 59         //主界面编
 60         while (!"end".equals(content)) {
 61             content = sc.nextLine();
 62             if (!"end".equals(content)) {
 63 
 64                 // 根据" "进行分割
 65                 String[] input = content.split(" ");
 66 
 67                 // 说明传入的是 课程信息格式
 68                 // 课程名称,课程性质,考核方式
 69                 if (input.length <= 3) {
 70                     Course course = new Course();
 71                     // 性质是必须课,可以没有考核方式
 72                     if (input.length == 2) {
 73                         // 获取课程名称
 74                         course.setName(input[0]);
 75                         // 获取课程性质
 76                         course.setQuality(input[1]);
 77                     }else {
 78                         // 获取课程名称
 79                         course.setName(input[0]);
 80                         // 获取课程性质
 81                         course.setQuality(input[1]);
 82                         // 获取考核方式
 83                         course.setType(input[2]);
 84                         if ("必修".equals(course.getQuality()) && "考察".equals(course.getType())) {
 85                             courseTypeTrueOrFalse.add(course.getName());
 86                         }
 87                         if ("必修".equals(course.getQuality()) && "实验".equals(course.getType())) {
 88                             courseTypeTrueOrFalse.add(course.getName());
 89                         }
 90                         if ("选修".equals(course.getQuality()) && "实验".equals(course.getType())) {
 91                             courseTypeTrueOrFalse.add(course.getName());
 92                         }
 93                         if ("实验".equals(course.getQuality()) && "考试".equals(course.getType())) {
 94                             courseTypeTrueOrFalse.add(course.getName());
 95                         }
 96 
 97                     }
 98 
 99 
100                     //添加到课程队列中
101                     courses.add(course);
102 
103 //                System.out.println(input[0] + input[1] + input[2]);
104                 }
105 
106                 // 学号, 姓名, 课程名称, 期末成绩
107                 if(input.length == 4) {
108                     Student student = new Student();
109                     CurriculaVariable curriculaVariable = new CurriculaVariable();
110                     TestScore testScore = new TestScore();
111                     Course course = new Course();
112                     Score score = new Score();
113                     // 获取学号
114                     student.setId(Integer.valueOf(input[0]));
115 
116                     // 截取学号前六位为班级
117                     String idStr = String.valueOf(student.getId());
118                     String classNum = idStr.substring(0, 6);
119 
120                     // 获取姓名
121                     student.setStudentName(input[1]);
122                     // 获取课程名称
123                     course.setName(input[2]);
124                     // 获取期末成绩
125                     testScore.setNumber(Integer.valueOf(input[3]));
126                     // 计算总成绩
127                     score.setNumber(testScore.getNumber());
128 
129                     curriculaVariable.setStudent(student);
130                     curriculaVariable.setCourse(course);
131                     curriculaVariable.setScore(score);
132 
133                     if (testScore.getNumber()>100 || testScore.getNumber()<0) {
134                         courseFormat.add(course.getName());
135                         info = true;
136                     }
137 
138                     for (Course course1 : courses) {
139                         if (course1.getName().equals(course.getName()) && "必修".equals(course1.getQuality())) {
140                             courseTrueOrFalse.put(student.getStudentName(), false);
141                             courseTrueOrFalse2.put(course1.getName(), false);
142                             courseTrueOrFalse3.put(classNum, false);
143                         } else {
144                             courseTrueOrFalse.put(student.getStudentName(), true);
145                             courseTrueOrFalse2.put(course1.getName(), true);
146                             courseTrueOrFalse3.put(classNum, true);
147                         }
148                     }
149 
150 
151 //                System.out.println(input[0] + input[1] + input[2] + input[3]);
152 
153 
154                     // 平时总成绩
155                     normalPerformance.put(course.getName(), null);
156                     // 期末总成绩
157                     finalGrade.put(course.getName(), finalGrade.getOrDefault(course.getName(), 0) + testScore.getNumber());
158                     //总成绩
159                     totalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());
160                     // 课程人数
161                     numberCourses.put(course.getName(), numberCourses.getOrDefault(course.getName(), 0)+1);
162                     // 添加学生队列中
163                     students.put(student.getId(), student.getStudentName());
164 
165                     classSet.add(classNum);
166                     // 添加班级总成绩
167                     classGrade.put(classNum, classGrade.getOrDefault(classNum, 0) + score.getNumber());
168                     // 添加班级总人数
169                     classStudentNum.put(classNum, classStudentNum.getOrDefault(classNum, 0) + 1);
170 
171                     // 添加到选修队列中
172                     curriculaVariables.add(curriculaVariable);
173                 }
174 
175                 // 学号, 姓名, 课程名称, 平时成绩, 期末成绩
176                 if(input.length == 5) {
177                     Student student = new Student();
178                     CurriculaVariable curriculaVariable = new CurriculaVariable();
179                     TestScore testScore = new TestScore();
180                     ReviewScore reviewScore = new ReviewScore();
181                     Course course = new Course();
182                     Score score = new Score();
183                     // 获取学号
184                     student.setId(Integer.valueOf(input[0]));
185 
186                     // 截取学号前六位为班级
187                     String idStr = String.valueOf(student.getId());
188                     String classNum = idStr.substring(0, 6);
189 
190                     // 获取姓名
191                     student.setStudentName(input[1]);
192                     // 获取课程名称
193                     course.setName(input[2]);
194                     // 获取平时成绩
195                     reviewScore.setNumber(Integer.valueOf(input[3]));
196                     // 获取期末成绩
197                     testScore.setNumber(Integer.valueOf(input[4]));
198                     // 计算总成绩
199                     int tmp = (int) (reviewScore.getNumber()*0.3 + testScore.getNumber()*0.7);
200                     score.setNumber(tmp);
201 
202                     curriculaVariable.setStudent(student);
203                     curriculaVariable.setCourse(course);
204                     curriculaVariable.setScore(score);
205 
206                     if (testScore.getNumber()>100 || testScore.getNumber()<0 || reviewScore.getNumber()>100 || reviewScore.getNumber()<0) {
207                         info = true;
208                         courseFormat.add(course.getName());
209                     }
210 
211 //                System.out.println(input[0] + input[1] + input[2] + input[3] + input[4] + " 总成绩为: " + tmp);
212 
213                     // 平时成绩
214                     normalPerformance.put(course.getName(), normalPerformance.getOrDefault(course.getName(), 0) + reviewScore.getNumber());
215                     // 期末总成绩
216                     finalGrade.put(course.getName(), finalGrade.getOrDefault(course.getName(), 0) + testScore.getNumber());
217                     //总成绩
218                     totalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());
219                     // 课程人数
220                     numberCourses.put(course.getName(), numberCourses.getOrDefault(course.getName(), 0)+1);
221 
222                     // 添加班级总成绩
223                     classGrade.put(classNum, classGrade.getOrDefault(classNum, 0) + score.getNumber());
224                     // 添加班级总人数
225                     classStudentNum.put(classNum, classStudentNum.getOrDefault(classNum, 0) + 1);
226 
227                     classSet.add(classNum);
228 
229                     // 添加学生队列中
230                     students.put(student.getId(), student.getStudentName());
231                     // 添加到选修队列中
232                     curriculaVariables.add(curriculaVariable);
233                 }
234 
235                 if (input.length<8 && input.length >=6) {
236                     Student student = new Student();
237                     CurriculaVariable curriculaVariable = new CurriculaVariable();
238 
239                     Course course = new Course();
240                     Score score = new Score();
241                     // 获取学号
242                     student.setId(Integer.valueOf(input[0]));
243 
244                     // 截取学号前六位为班级
245                     String idStr = String.valueOf(student.getId());
246                     String classNum = idStr.substring(0, 6);
247 
248                     // 获取姓名
249                     student.setStudentName(input[1]);
250                     // 获取课程名称
251                     course.setName(input[2]);
252                     // input[3] 为实验次数
253                     int num = 0;
254                     for (int i = 4; i < input.length; i++) {
255                         num += Integer.valueOf(input[i]);
256                         if (Integer.valueOf(input[i]) > 100 || Integer.valueOf(input[i]) < 0) {
257                             info = true;
258                         }
259                     }
260 
261                     if (Integer.valueOf(input[3]) < 4 || Integer.valueOf(input[3]) > 9) {
262                         info = true;
263                     }
264 
265                     // 添加选修课程数量不一致情况
266                     if (Integer.valueOf(input[3]) != input.length-4) {
267                         scoreNumMatchExamType.put(student.getStudentName(), scoreNumMatchExamType.getOrDefault(student.getStudentName(), 0) + 1);
268                     }
269 
270                     courseTrueOrFalse.put(student.getStudentName(), false);
271 
272                     // 计算总成绩
273                     int tmp = (int) (num / Integer.valueOf(input[3]));
274                     score.setNumber(tmp);
275 
276                     curriculaVariable.setStudent(student);
277                     curriculaVariable.setCourse(course);
278                     curriculaVariable.setScore(score);
279 
280 
281 //                System.out.println(input[0] + input[1] + input[2] + input[3] + input[4] + " 总成绩为: " + tmp);
282 
283                     //总成绩
284                     totalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());
285                     //实验成绩
286                     experimentalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());
287 
288                     // 课程人数
289                     numberCourses.put(course.getName(), numberCourses.getOrDefault(course.getName(), 0)+1);
290 
291                     // 添加班级总成绩
292                     classGrade.put(classNum, classGrade.getOrDefault(classNum, 0) + score.getNumber());
293                     // 添加班级总人数
294                     classStudentNum.put(classNum, classStudentNum.getOrDefault(classNum, 0) + 1);
295 
296                     classSet.add(classNum);
297 
298 
299 
300 
301                     // 平时成绩
302                     normalPerformance.put(course.getName(), null);
303                     // 期末总成绩
304                     finalGrade.put(course.getName(), null);
305                     //总成绩
306                     totalScore.put(course.getName(), null);
307 
308                     // 添加学生队列中
309                     students.put(student.getId(), student.getStudentName());
310                     // 添加到选修队列中
311                     curriculaVariables.add(curriculaVariable);
312                     if (Integer.valueOf(input[3]) < 4) {
313                         info = true;
314                     }
315 
316                     courseTrueOrFalse3.put(classNum, false);
317 
318                 }
319 
320 
321                 // 学号 姓名 课程名称 实验次数 第一次实验成绩+...+英文空格+最后一次实验成绩
322                 if(input.length >=8 && input.length <= 13) {
323                     Student student = new Student();
324                     CurriculaVariable curriculaVariable = new CurriculaVariable();
325 
326                     Course course = new Course();
327                     Score score = new Score();
328                     // 获取学号
329                     student.setId(Integer.valueOf(input[0]));
330 
331                     // 截取学号前六位为班级
332                     String idStr = String.valueOf(student.getId());
333                     String classNum = idStr.substring(0, 6);
334 
335                     // 获取姓名
336                     student.setStudentName(input[1]);
337                     // 获取课程名称
338                     course.setName(input[2]);
339                     // input[3] 为实验次数
340                     int num = 0;
341                     for (int i = 4; i < input.length; i++) {
342                         num += Integer.valueOf(input[i]);
343                         if (Integer.valueOf(input[i]) > 100 || Integer.valueOf(input[i]) < 0) {
344                             info = true;
345                         }
346                     }
347 
348                     if (Integer.valueOf(input[3]) < 4 || Integer.valueOf(input[3]) > 9) {
349                         info = true;
350                     }
351 
352                     // 添加选修课程数量不一致情况
353                     if (Integer.valueOf(input[3]) != input.length-4) {
354                         scoreNumMatchExamType.put(student.getStudentName(), scoreNumMatchExamType.getOrDefault(student.getStudentName(), 0) + 1);
355                     }
356 
357                     // 计算总成绩
358                     int tmp = (int) (num / Integer.valueOf(input[3]));
359                     score.setNumber(tmp);
360 
361                     curriculaVariable.setStudent(student);
362                     curriculaVariable.setCourse(course);
363                     curriculaVariable.setScore(score);
364 
365 
366 //                System.out.println(input[0] + input[1] + input[2] + input[3] + input[4] + " 总成绩为: " + tmp);
367 
368                     //总成绩
369                     totalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());
370                     //实验成绩
371                     experimentalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());
372 
373                     // 课程人数
374                     numberCourses.put(course.getName(), numberCourses.getOrDefault(course.getName(), 0)+1);
375 
376                     // 添加班级总成绩
377                     classGrade.put(classNum, classGrade.getOrDefault(classNum, 0) + score.getNumber());
378                     // 添加班级总人数
379                     classStudentNum.put(classNum, classStudentNum.getOrDefault(classNum, 0) + 1);
380 
381                     classSet.add(classNum);
382 
383                     // 添加学生队列中
384                     students.put(student.getId(), student.getStudentName());
385                     // 添加到选修队列中
386                     curriculaVariables.add(curriculaVariable);
387 
388 
389                 }
390 
391                 if(input.length > 13) {
392                     info = true;
393                 }
394 
395             }
396 
397 
398         }
399 
400 
401         Map<Student, Integer> map1 = new HashMap<>();
402         for (Map.Entry<Integer, String> entry : students.entrySet()) {
403             // 成绩和
404             int score = 0;
405             // 科目
406             int num = 0;
407             for (CurriculaVariable curriculaVariable : curriculaVariables) {
408                 // id 一致说明是一个人
409                 if (curriculaVariable.getStudent().getId().equals(entry.getKey()) ) {
410                     score += curriculaVariable.getScore().getNumber();
411                     num ++;
412                 }
413             }
414             Student s = new Student();
415             s.setStudentName(entry.getValue());
416             s.setId(entry.getKey());
417             map1.put(s, (int)score/num);
418         }
419         // 将 Map 转换为 List
420         List<Map.Entry<Student, Integer>> list = new ArrayList<>(map1.entrySet());
421 
422         // 使用 Collections.sort() 方法对 List 进行排序
423         Collections.sort(list, new Comparator<Map.Entry<Student, Integer>>() {
424             @Override
425             public int compare(Map.Entry<Student, Integer> o1, Map.Entry<Student, Integer> o2) {
426                 return o1.getKey().getId().compareTo(o2.getKey().getId());
427             }
428         });
429 
430 
431         boolean gradeIsNull = false;
432 
433         for (Map.Entry<Student, Integer> entry : list) {
434 //            Map<String, Boolean> courseTrueOrFalse = new HashMap<>();
435 
436             if (!courseFormat.isEmpty()) {
437                 System.out.println("wrong format");
438             }
439             else if (!courseTypeTrueOrFalse.isEmpty() && info) {
440                 for (String str : courseTypeTrueOrFalse) {
441                     System.out.println(str + " : course type & access mode mismatch");
442                 }
443             } else if(!courseTypeTrueOrFalse.isEmpty() && !info) {
444                 for (String str : courseTypeTrueOrFalse) {
445                     System.out.println(str + " : course type & access mode mismatch");
446                     System.out.println(str+ " does not exist");
447                     System.out.println(entry.getKey().getId() + " " + entry.getKey().getStudentName() + " " + "did not take any exams");
448                     gradeIsNull = true;
449                 }
450             } else if(scoreNumMatchExamType.getOrDefault(entry.getKey().getStudentName(), 0) > 0) {
451                 System.out.println(entry.getKey().getId() + " " + entry.getKey().getStudentName() + " " + ": access mode mismatch");
452             }  else if (info) {
453 
454             }else {
455                 if (entry.getValue() == 0 || entry.getValue() == null) {
456                     System.out.println(entry.getKey().getId() + " " + entry.getKey().getStudentName() + " " + "did not take any exams");
457                 } else {
458                     System.out.println(entry.getKey().getId() + " " + entry.getKey().getStudentName() + " " + entry.getValue());
459                 }
460             }
461 
462              if (courseTrueOrFalse.getOrDefault(entry.getKey().getStudentName(), true) != true && !info) {
463 
464                 System.out.println(entry.getKey().getId() + " " + entry.getKey().getStudentName() + " " + "did not take any exams");
465 
466             }
467 
468         }
469 
470         if(info) {
471             System.out.println("wrong format");
472         }
473 
474         Collator collator = Collator.getInstance(Locale.CHINA); // 创建一个中文排序器
475         Collections.sort(courses, new Comparator<Course>() {
476             @Override
477             public int compare(Course c1, Course c2) {
478                 return collator.compare(c1.getName(), c2.getName());
479             }
480         });
481 
482 
483             for (Course course : courses) {
484             // 总人数
485             Integer num = numberCourses.get(course.getName());
486 
487             if (!courseFormat.isEmpty()) {
488                 for (String tmp : courseFormat) {
489                     System.out.println(tmp + " has no grades yet");
490                 }
491             } else if (!courseTypeTrueOrFalse.isEmpty()) {  // 如果某门课程没有任何成绩信息，输出: 课程名称+英文空格+"has no grades yet"
492 
493             } else if (normalPerformance.get(course.getName()) == null && finalGrade.get(course.getName()) == null && totalScore.get(course.getName()) == null) {
494                 System.out.println(course.getName() + " " + "has no grades yet");
495             } else if (courseTrueOrFalse2.getOrDefault(course.getName(), true) != true) {
496                 System.out.println(course.getName() + " " + "has no grades yet");
497             }else {
498 
499                 Integer normalPerformance1 = null;
500 
501                 // 期末成绩
502                 int finalGrade1;
503                 // 总成绩
504                 int numberCourses1;
505 
506                 if (normalPerformance.get(course.getName()) == null && experimentalScore.get(course.getName()) == null) {
507                     // 期末成绩
508                     finalGrade1 = (int)finalGrade.get(course.getName())/num;
509                     // 总成绩
510                     numberCourses1 = (int) totalScore.get(course.getName())/num;
511 
512                     System.out.println(course.getName() + " " + finalGrade1 + " " + numberCourses1);
513                 } else if (experimentalScore.get(course.getName()) != null) { // 是实验课
514                     numberCourses1 = (int) totalScore.get(course.getName())/num;
515                     System.out.println(course.getName() + " " + numberCourses1);
516 
517                 } else {
518                     // 期末成绩
519                     finalGrade1 = (int)finalGrade.get(course.getName())/num;
520                     // 总成绩
521                     numberCourses1 = (int) totalScore.get(course.getName())/num;
522 
523                     // 平时成绩
524                     normalPerformance1 = (int)normalPerformance.get(course.getName())/num;
525                     System.out.println(course.getName() + " " + normalPerformance1 + " " + finalGrade1 + " " + numberCourses1);
526                 }
527 
528             }
529 
530         }
531 
532 
533 
534 
535         if (!info) {
536             for (String className : classSet) {
537                 if (!courseFormat.isEmpty()) {
538 
539                 } else if (!courseTypeTrueOrFalse.isEmpty()) {
540                     System.out.println(className + " " + "has no grades yet");
541                 } else if (classGrade.get(className) != null && courseTrueOrFalse3.getOrDefault(className, true) == true) {
542                     int classScore = (int)classGrade.get(className)/classStudentNum.get(className);
543                     System.out.println(className + " " + classScore);
544                 }else {
545                     System.out.println(className + " " + "has no grades yet");
546 
547                 }
548 
549             }
550         }
551 
552 
553 
554     }
555 }
556 class Class implements Serializable {
557     private Integer id;
558     private String className;
559 
560     public Class() {
561     }
562 
563     public Class(Integer id, String className) {
564         this.id = id;
565         this.className = className;
566     }
567 
568     public Integer getId() {
569         return id;
570     }
571 
572     public void setId(Integer id) {
573         this.id = id;
574     }
575 
576     public String getClassName() {
577         return className;
578     }
579 
580     public void setClassName(String className) {
581         this.className = className;
582     }
583 }
584 class Course implements Serializable {
585     // ID
586     private Integer id;
587     private String name;
588     // 课程性质
589     private String quality;
590     // 考核方式
591     private String type;
592 
593     public Course() {
594     }
595 
596     public Course(Integer id, String name, String quality, String type) {
597         this.id = id;
598         this.name = name;
599         this.quality = quality;
600         this.type = type;
601     }
602 
603     public Integer getId() {
604         return id;
605     }
606 
607     public void setId(Integer id) {
608         this.id = id;
609     }
610 
611     public String getName() {
612         return name;
613     }
614 
615     public void setName(String name) {
616         this.name = name;
617     }
618 
619     public String getQuality() {
620         return quality;
621     }
622 
623     public void setQuality(String quality) {
624         this.quality = quality;
625     }
626 
627     public String getType() {
628         return type;
629     }
630 
631     public void setType(String type) {
632         this.type = type;
633     }
634 }
635 class CurriculaVariable {
636     // 课程
637     private Course course;
638     // 学生
639     private Student student;
640     // 成绩
641     private Score score;
642 
643     public CurriculaVariable() {
644     }
645 
646     public CurriculaVariable(Course course, Student student, Score score) {
647         this.course = course;
648         this.student = student;
649         this.score = score;
650     }
651 
652     public Course getCourse() {
653         return course;
654     }
655 
656     public void setCourse(Course course) {
657         this.course = course;
658     }
659 
660     public Student getStudent() {
661         return student;
662     }
663 
664     public void setStudent(Student student) {
665         this.student = student;
666     }
667 
668     public Score getScore() {
669         return score;
670     }
671 
672     public void setScore(Score score) {
673         this.score = score;
674     }
675 }
676 class ReviewScore extends Score{
677 }
678 class Score implements Serializable {
679     private Integer number;
680 
681     public Score(Integer number) {
682         this.number = number;
683     }
684 
685     public Score() {
686     }
687 
688     public Integer getNumber() {
689         return number;
690     }
691 
692     public void setNumber(Integer number) {
693         this.number = number;
694     }
695 }
696 class Student implements Serializable {
697     // 学号
698     private Integer id;
699     // 姓名
700     private String studentName;
701     // 学生专业
702     private String major;
703     // 学生班级
704     private Class aClass;
705 
706     public Student() {
707     }
708 
709     public Student(Integer id, String studentName, String major, Class aClass) {
710         this.id = id;
711         this.studentName = studentName;
712         this.major = major;
713         this.aClass = aClass;
714     }
715 
716     public Integer getId() {
717         return id;
718     }
719 
720     public void setId(Integer id) {
721         this.id = id;
722     }
723 
724     public String getStudentName() {
725         return studentName;
726     }
727 
728     public void setStudentName(String studentName) {
729         this.studentName = studentName;
730     }
731 
732     public String getMajor() {
733         return major;
734     }
735 
736     public void setMajor(String major) {
737         this.major = major;
738     }
739 
740     public Class getaClass() {
741         return aClass;
742     }
743 
744     public void setaClass(Class aClass) {
745         this.aClass = aClass;
746     }
747 }
748 class TestScore extends Score{
749 }

  1 import java.io.Serializable;
  2 import java.math.BigDecimal;
  3 import java.util.*;
  4 import java.util.regex.Pattern;
  5 import java.util.stream.Collectors;
  6 
  7 class Class implements Serializable , Comparable<Class>{
  8     private Integer id;
  9     private String className;
 10 
 11 
 12     private int avgScope;
 13 
 14     public Class() {
 15     }
 16 
 17     public Class(Integer id, String className) {
 18         this.id = id;
 19         this.className = className;
 20     }
 21 
 22     public Integer getId() {
 23         return id;
 24     }
 25 
 26     public void setId(Integer id) {
 27         this.id = id;
 28     }
 29 
 30     public String getClassName() {
 31         return className;
 32     }
 33 
 34     public void setClassName(String className) {
 35         this.className = className;
 36     }
 37 
 38     public int getAvgScope() {
 39         return avgScope;
 40     }
 41 
 42     public void setAvgScope(int avgScope) {
 43         this.avgScope = avgScope;
 44     }
 45 
 46     @Override
 47     public int compareTo(Class o) {
 48         return Integer.valueOf(id).compareTo(Integer.valueOf(o.id));
 49     }
 50 }
 51 class Course implements Serializable , Comparable<Course>{
 52     // ID
 53     private String name;
 54     // 课程性质
 55     private String quality;
 56     // 考核方式
 57     private String type;
 58 
 59     public Course() {
 60     }
 61 
 62     public Course(String name, String quality, String type) {
 63         this.name = name;
 64         this.quality = quality;
 65         this.type = type;
 66     }
 67 
 68 
 69     public String getName() {
 70         return name;
 71     }
 72 
 73     public void setName(String name) {
 74         this.name = name;
 75     }
 76 
 77     public String getQuality() {
 78         return quality;
 79     }
 80 
 81     public void setQuality(String quality) {
 82         this.quality = quality;
 83     }
 84 
 85     public String getType() {
 86         return type;
 87     }
 88 
 89     public void setType(String type) {
 90         this.type = type;
 91     }
 92 
 93     @Override
 94     public int compareTo(Course o) {
 95         return name.compareTo(o.getName());
 96     }
 97 }
 98 
 99 /**
100  课程成绩
101  */
102 class CourseScore implements Cloneable{
103 
104 
105     // 组合分项成绩
106     private List<SubItemScope> subItemScopeList;
107 
108     public List<SubItemScope> getSubItemScopeList() {
109         return subItemScopeList;
110     }
111 
112     public void setSubItemScopeList(List<SubItemScope> subItemScopeList) {
113         this.subItemScopeList = subItemScopeList;
114     }
115 
116     @Override
117     public CourseScore clone() {
118         CourseScore courseScore = new CourseScore();
119         List<SubItemScope> l = new ArrayList<>(subItemScopeList.size());
120         courseScore.setSubItemScopeList(l);
121 
122         for (int i = 0; i < subItemScopeList.size(); i++) {
123             SubItemScope subItemScope = new SubItemScope();
124             subItemScope.setId(subItemScopeList.get(i).getId());
125             subItemScope.setWeight(subItemScopeList.get(i).getWeight());
126             l.add(subItemScope);
127         }
128 
129         return courseScore;
130     }
131 
132     public int getScope() {
133         if(subItemScopeList == null){
134             return 0;
135         }else {
136             BigDecimal res = BigDecimal.ZERO;
137             for (int i = 0; i < subItemScopeList.size(); i++) {
138                 SubItemScope subItemScope = subItemScopeList.get(i);
139                 res = res.add(subItemScope.getScope().multiply(subItemScope.getWeight()));
140             }
141             return res.intValue();
142         }
143     }
144 }
145 class CurriculaVariable {
146     // 课程
147     private Course course;
148     // 学生
149     private Student student;
150     //成绩
151     private CourseScore score;
152 
153     public CurriculaVariable() {
154     }
155 
156     public CurriculaVariable(Course course, Student student, CourseScore score) {
157         this.course = course;
158         this.student = student;
159         this.score = score;
160     }
161 
162     public Course getCourse() {
163         return course;
164     }
165 
166     public void setCourse(Course course) {
167         this.course = course;
168     }
169 
170     public Student getStudent() {
171         return student;
172     }
173 
174     public void setStudent(Student student) {
175         this.student = student;
176     }
177 
178     public CourseScore getScore() {
179         return score;
180     }
181 
182     public void setScore(CourseScore score) {
183         this.score = score;
184     }
185 }
186 class Student implements Serializable, Comparable<Student>{
187     // 学号
188     private Integer id;
189     // 姓名
190     private String studentName;
191     // 学生专业
192     private String major;
193     // 学生班级
194     private Class aClass;
195 
196     private int  avgScope;
197 
198     public Student() {
199     }
200 
201     public Student(Integer id, String studentName, String major, Class aClass) {
202         this.id = id;
203         this.studentName = studentName;
204         this.major = major;
205         this.aClass = aClass;
206     }
207 
208     public Integer getId() {
209         return id;
210     }
211 
212     public void setId(Integer id) {
213         this.id = id;
214     }
215 
216     public String getStudentName() {
217         return studentName;
218     }
219 
220     public void setStudentName(String studentName) {
221         this.studentName = studentName;
222     }
223 
224     public String getMajor() {
225         return major;
226     }
227 
228     public void setMajor(String major) {
229         this.major = major;
230     }
231 
232     public Class getaClass() {
233         return aClass;
234     }
235 
236     public void setaClass(Class aClass) {
237         this.aClass = aClass;
238     }
239 
240     public int getAvgScope() {
241         return avgScope;
242     }
243 
244     public void setAvgScope(int avgScope) {
245         this.avgScope = avgScope;
246     }
247 
248     @Override
249     public int compareTo(Student o) {
250         if(id > o.getId()) {
251             return 1;
252         }else if (id.equals(o.getId())){
253             return 0;
254         }else {
255             return -1;
256         }
257     }
258 }
259 class SubItemScope {
260 
261     private Integer id;
262 
263     // 分值
264     private  BigDecimal scope;
265 
266 
267     // 权重
268     private BigDecimal weight;
269 
270 
271     public Integer getId() {
272         return id;
273     }
274 
275     public void setId(Integer id) {
276         this.id = id;
277     }
278 
279     public BigDecimal getScope() {
280         return scope;
281     }
282 
283     public void setScope(BigDecimal scope) {
284         this.scope = scope;
285     }
286 
287     public BigDecimal getWeight() {
288         return weight;
289     }
290 
291     public void setWeight(BigDecimal weight) {
292         this.weight = weight;
293     }
294 }
295 
296 class Main {
297 
298 
299     // 课程信息
300     private static Map<String , Course> courseMap = new HashMap<>();
301 
302     // 成绩信息
303     private static Map<String , CourseScore> scoreMap = new HashMap<>();
304 
305     // 学生信息
306     private static Map<String, Student> studentMap = new HashMap<>();
307 
308     // 班级信息
309     private static Map<String, Class> classMap = new HashMap<>();
310 
311     // 课程学生成绩信息
312     private static List<CurriculaVariable> curriculaVariables = new ArrayList<>();
313 
314 
315     private static String[] qualitys = {"必修","选修","实验"};
316     private static String[] types = {"考试","考察","实验"};
317 
318 
319     private static Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
320 
321 
322     // 信息不符合
323     Boolean info = false;
324 
325     public static void main(String[] args) {
326 
327         Scanner sc = new Scanner(System.in);
328         String content = "";
329         //主界面编
330         int a = 0;
331         while (!"end".equals(content)) {
332             content = sc.nextLine();
333             if (!"end".equals(content)) {
334 //                a++;
335 //                if(a > 10) {
336 //                    showWarn();
337 //                    return;
338 //                }
339                 // 根据" "进行分割
340                 String[] input = content.split(" ");
341 
342                 if(input.length > 1) {
343                     if(pattern.matcher(input[0]).matches()){
344                         // 输入的是学号
345                         addStudent(input);
346                     }else {
347                         // 输入的是课程
348                         addCourse(input);
349                         //
350                     }
351 
352                 }else {
353                     showWarn();
354                 }
355 
356             }
357         }
358 
359 
360 //         1）学生课程总成绩平均分按学号由低到高排序输出
361 //        格式：学号+英文空格+姓名+英文空格+总成绩平均分
362 //        如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
363         List<Student> studentList = studentMap.values().stream().sorted().collect(Collectors.toList());
364         for (int i = 0; i < studentList.size(); i++) {
365             Student student = studentList.get(i);
366 
367             List<CourseScore> stuScore = curriculaVariables.stream().filter(item -> item.getStudent().getId().equals(student.getId())).map(CurriculaVariable::getScore).collect(Collectors.toList());
368             if(stuScore == null || stuScore.size() == 0) {
369                 System.out.println(student.getId() + " " + student.getStudentName() +  " " + "did not take any exams");
370             }else {
371                 int score = 0;
372                 for (int i1 = 0; i1 < stuScore.size(); i1++) {
373                     score += stuScore.get(i1).getScope();
374                 }
375                 student.setAvgScope(score / stuScore.size());
376                // System.out.println(student.getId() + " " + student.getStudentName() + " " + student.getAvgScope());
377                 System.out.println(student.getId() + " " + student.getStudentName() + " " + student.getAvgScope());
378             }
379         }
380 //        2）单门课程成绩按课程名称的字符顺序输出
381 //        课程成绩输出格式：课程名称+英文空格+总成绩平均分
382 //        如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
383         List<Course> courseList = courseMap.values().stream().sorted().collect(Collectors.toList());
384         for (int i = 0; i < courseList.size(); i++) {
385             Course course = courseList.get(i);
386             List<CourseScore> courseScoreList = curriculaVariables.stream().filter(item -> item.getCourse().getName().equals(course.getName())).map(CurriculaVariable::getScore).collect(Collectors.toList());
387 
388             if(courseScoreList == null || courseScoreList.size() == 0) {
389                 System.out.println(course.getName() + " " + "has no grades yet");
390             }else {
391                 int score = 0;
392                 for (int i1 = 0; i1 < courseScoreList.size(); i1++) {
393                     score += courseScoreList.get(i1).getScope();
394                 }
395                // System.out.println(course.getName() + " " + Math.round(score / courseScoreList.size()));
396                 System.out.println(course.getName() + " " + score / courseScoreList.size());
397             }
398         }
399 //        3）班级所有课程总成绩平均分按班级由低到高排序输出
400 //        格式：班级号+英文空格+总成绩平均分
401 //        如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
402         Collection<Class> classList = classMap.values();
403 
404         for (Class aClass : classList) {
405             List<CourseScore> stuScore = curriculaVariables.stream().filter(item -> item.getStudent().getId().toString().startsWith(aClass.getClassName())).map(CurriculaVariable::getScore).collect(Collectors.toList());
406             if(stuScore == null || stuScore.size() == 0) {
407                 aClass.setAvgScope(-1);
408             }else {
409                 int score = 0;
410                 for (int i1 = 0; i1 < stuScore.size(); i1++) {
411                     score += stuScore.get(i1).getScope();
412                 }
413            //     aClass.setAvgScope(Integer.valueOf(Math.round(score / stuScore.size())+""));
414                 aClass.setAvgScope(score / stuScore.size());
415 
416             }
417         }
418         classList.stream().sorted().forEach(aClass -> {
419             if(aClass.getAvgScope() == -1) {
420                 System.out.println(aClass.getClassName() + " " + "has no grades yet");
421             }else {
422                 System.out.println(aClass.getClassName() + " " + aClass.getAvgScope());
423             }
424         });
425     }
426 
427     /**
428      *
429      * 考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
430      *
431      * 考试/考查课程成绩信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
432      *
433      * 实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝
434      *
435      * 实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
436      *
437      *
438      * 1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
439      *
440      * 2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
441      *
442      * 以上两种情况如果同时出现，按第一种情况输出结果。
443      */
444     private static void addStudent(String[] input) {
445         if(input.length < 3) {
446             showWarn();
447         }
448         Student student = new Student();
449         // 获取学号
450         student.setId(Integer.valueOf(input[0]));
451         student.setStudentName(input[1]);
452 
453         if(!checkStudent(student)) {
454             return;
455         }
456         CurriculaVariable curriculaVariable = new CurriculaVariable();
457 
458         Course course = courseMap.get(input[2]);
459 
460         String idStr = String.valueOf(student.getId());
461         String classNum = idStr.substring(0, 6);
462         if(!classMap.containsKey(classNum)) {
463             classMap.put(classNum,new Class(Integer.valueOf(classNum) , classNum));
464         }
465 
466         if(course == null) {
467           //  System.out.println(student.getId() + " " + student.getStudentName() + " " + input[2] + " " + "does not exist");
468             System.out.println(input[2] + " " + "does not exist");
469             course = new Course();
470         }
471         curriculaVariable.setStudent(student);
472         curriculaVariable.setCourse(course);
473 
474 
475 
476         if(studentMap.containsKey(student.getStudentName()+ course.getName() == null ? "" : course.getName())){
477             return;
478         }
479         studentMap.put(student.getStudentName()+ course.getName() , student);
480 
481         if(course.getType() == null) return;
482 
483         switch (course.getType()){
484             case  "考试": {
485                 // 学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
486                 if(input.length < 5) {
487                     System.out.println(student.getId() + " " + student.getStudentName() + ": access mode mismatch");
488                     return;
489                 }
490                 BigDecimal aDouble = new  BigDecimal(input[3]);
491                 BigDecimal bDouble = new  BigDecimal(input[4]);
492                 CourseScore courseScore = scoreMap.get(course.getName()).clone();
493                 curriculaVariable.setScore(courseScore);
494                 List<SubItemScope> subItemScopeList = courseScore.getSubItemScopeList();
495                 subItemScopeList.get(0).setScope(aDouble);
496                 subItemScopeList.get(1).setScope(bDouble);
497                 break;
498             }
499             case  "考察": {
500 
501                 // 学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
502                 if(input.length < 4) {
503                     System.out.println(student.getId() + " " + student.getStudentName() + " : access mode mismatch");
504                     return;
505                 }
506                 BigDecimal bDouble =  new BigDecimal(input[3]);
507                 CourseScore courseScore = scoreMap.get(course.getName()).clone();
508                 curriculaVariable.setScore(courseScore);
509                 List<SubItemScope> subItemScopeList = courseScore.getSubItemScopeList();
510                 subItemScopeList.get(0).setScope(bDouble);
511                 break;
512             }
513             case  "实验": {
514                 CourseScore courseScore = scoreMap.get(course.getName()).clone();
515                 curriculaVariable.setScore(courseScore);
516                 List<SubItemScope> subItemScopeList = courseScore.getSubItemScopeList();
517 
518                 List<BigDecimal> scopes = Arrays.asList(input).subList(3, input.length).stream().map(item -> new BigDecimal(item)).collect(Collectors.toList());
519                 if(subItemScopeList.size() != scopes.size()) {
520                     System.out.println(student.getId() + " " + student.getStudentName() + " : access mode mismatch");
521                     return;
522                 }
523                 for (int i = 0; i < subItemScopeList.size(); i++) {
524                     subItemScopeList.get(i).setScope(scopes.get(i));
525                 }
526                 break;
527             }
528             default:
529                 break;
530         }
531 
532         curriculaVariables.add(curriculaVariable);
533         // 截取学号前六位为班级
534     }
535 
536     private static boolean checkStudent(Student student) {
537         if(student.getStudentName().length() > 10) {
538             showWarn();
539             return false;
540         }
541 
542         if(student.getId().toString().length() != 8) {
543             showWarn();
544             return false;
545         }
546 
547         return true;
548     }
549 
550     // 增加课程
551     private static String addCourse(String[] input) {
552         if(input.length < 3) {
553             showWarn();
554         }
555         Course course = new Course();
556 
557         // 获取课程名称
558         course.setName(input[0]);
559         // 获取课程性质
560         course.setQuality(input[1]);
561         // 获取考核方式
562         course.setType(input[2]);
563 
564         if(courseMap.containsKey(course.getName())) {
565 return "";        }
566 
567         if(!checkCourse(course,input)) {
568             return course.getName();
569         }
570 
571 //        if(course.getQuality().equals(qualitys[0]) && input.length == 5) {
572 //            if(pattern.matcher(input[2]).matches()) {
573 //                String[] input2 = new String[input.length+1];
574 //                input2[0] = input[0];
575 //                input2[1] = input[1];
576 //                input2[2] = "考试";
577 //                input2[3] = input[2];
578 //                input2[4] = input[3];
579 //                input2[5] = input[4];
580 //                input = input2;
581 //                course.setType(input2[2]);
582 //            }
583 //        }
584 
585         switch (course.getType()){
586             case  "考试": {
587                 // 考试 平时成绩的权重+英文空格+期末成绩的权重
588                 CourseScore courseScore = new CourseScore();
589 
590                 SubItemScope subItemScope1 = new SubItemScope();
591                 SubItemScope subItemScope2 = new SubItemScope();
592                 courseScore.setSubItemScopeList(Arrays.asList(subItemScope1, subItemScope2));
593                 if (input.length < 5) {
594                     showWarn();
595                 }
596                 BigDecimal aDouble = new BigDecimal(input[3]);
597                 BigDecimal bDouble = new BigDecimal(input[4]);
598                 // 如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"
599                 if ((aDouble.add(bDouble).compareTo(BigDecimal.ONE)) != 0) {
600                     System.out.println(course.getName() + " : weight value error");
601                     return course.getName();
602                 }
603                 subItemScope1.setId(1);
604                 subItemScope1.setWeight(aDouble);
605 
606                 subItemScope2.setId(2);
607                 subItemScope2.setWeight(bDouble);
608 
609                 addScope(course , courseScore);
610                 break;
611             }
612             case  "考察": {
613 
614                 // 考察只有期末成绩
615                 CourseScore courseScore = new CourseScore();
616                 SubItemScope subItemScope1 = new SubItemScope();
617                 courseScore.setSubItemScopeList(Arrays.asList(subItemScope1));
618                 subItemScope1.setId(2);
619                 subItemScope1.setWeight(BigDecimal.ONE);
620                 addScope(course , courseScore);
621 
622                 break;
623             }
624             case  "实验": {
625                 if (input.length < 5) {
626                     showWarn();
627                 }
628 
629                 CourseScore courseScore = new CourseScore();
630                 List<SubItemScope> subItemScopeList = new ArrayList<>();
631                 courseScore.setSubItemScopeList(subItemScopeList);
632                 // 分数项
633                 Integer count = Integer.valueOf(input[3]);
634 
635                 if( count < 4 || count > 9) {
636                     showWarn();
637                     return "";
638                 }
639                 // 如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"
640                 if(count != input.length - 4) {
641                     System.out.println(course.getName() + " : number of scores does not match");
642                     return course.getName();
643                 }
644                 List<BigDecimal> weights = Arrays.asList(input).subList(4, input.length).stream().map(item -> new BigDecimal(item)).collect(Collectors.toList());
645                 BigDecimal aDouble = weights.stream().reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
646                 // 如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"
647                 if(aDouble.compareTo(BigDecimal.ONE) != 0) {
648                     System.out.println(course.getName() + " : weight value error");
649                     return course.getName();
650                 }
651                 for (int i = 0; i < weights.size(); i++) {
652                     SubItemScope subItemScope = new SubItemScope();
653                     subItemScope.setId(i+1);
654                     subItemScope.setWeight(weights.get(i));
655 
656                     subItemScopeList.add(subItemScope);
657                 }
658                 addScope(course , courseScore);
659                 break;
660             }
661             default:
662                 return course.getName();
663         }
664         if(!courseMap.containsKey(course.getName())) {
665             courseMap.put(course.getName() , course);
666         }
667         return course.getName();
668     }
669 
670     private static void addScope(Course course, CourseScore courseScore) {
671         if(!courseMap.containsKey(course.getName())) {
672             scoreMap.put(course.getName(),courseScore);
673         }
674     }
675 
676     private static boolean checkCourse(Course course, String[] input) {
677 
678         if(course.getName().length() > 10) {
679             showWarn();
680             return false;
681         }
682 
683 //        if(course.getQuality().equals(qualitys[0]) && input[2].equals("2")){
684 //            return true;
685 //        }
686 
687         long count = Arrays.stream(qualitys).filter(item -> course.getQuality().equals(item)).count();
688         if(count < 1) {
689             showWarn();
690             return false;
691         }
692 
693         long count2 = Arrays.stream(types).filter(item -> course.getType().equals(item)).count();
694 
695         if(count < 1) {
696             showWarn();
697             return false;
698         }
699 
700             if(course.getQuality().equals(qualitys[0]) && !course.getType().equals(types[0])) {
701                 System.out.println(course.getName() + " : course type & access mode mismatch");
702 
703                 return false;
704             }
705 
706         if(course.getQuality().equals(qualitys[1]) && course.getType().equals(types[2])) {
707             System.out.println(course.getName() + " : course type & access mode mismatch");
708 
709             return false;
710         }
711 
712         if(course.getQuality().equals(qualitys[2]) && !course.getType().equals(types[2])) {
713             System.out.println(course.getName() + " : course type & access mode mismatch");
714 
715             return false;
716         }
717 
718 
719         return true;
720     }
721 
722     private static void showWarn() {
723         System.out.println("wrong format");
724     }
725 }