OOP题目集总结

标签：总结 题目 String name course OOP student public split

目录

• 前言
• 设计与分析
• 踩坑心得
• 改进建议
• 总结

一、前言

           （1）第七次题目集

                 一道题目，菜单5

           （2）第八次题目集

                 一道题目，课程成绩统计系统1

           （3）第九次题目集

                 一道题目，统计Java程序中关键词的出现次数（必须使用map和set）

           （4）第十次题目集

                 四道题目，容器-HashMap-检索、容器-HashMap-排序、课程成绩统计程序-2、动物发声模拟器（多态），考点是HashMap的使用和对多态的理解

           （5）第十一次题目集

                 五道题目，容器-ArrayList-排序、课程成绩统计程序-3、jmu-Java-02基本语法-03-身份证排序、jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack、jmu-Java-03面向对象基础-05-覆盖，对javase语法更深入的了解

二、设计与分析

     7.5

 

                这次的作业在菜单计价程序-3的基础上增加了特色菜系，每桌菜都有点订单的人名和电话号码，不同于菜单计价程序-4中的特色菜，菜单计价程序-5的特色菜有川菜、晋菜、浙菜之分，而且增加了口味度，在最后对每桌菜订单数据的输出增加了按英文字典顺序输出。首先处理人名、电话数据，由于人名和电话是和订单桌号相联系又对应关系的，我认为人名和电话应该属于table类中的属性，只需要在table类中加入人名、电话号属性即可，又因为每一桌的订单都有可能有特色菜及其口味度，所以又需要增加特色菜数和口味度属性，table类更改代码如下

 

 

 又因为最后还要进行按人名用英文字典顺序输出，所以要用到每个table类中的name属性，这时排序的工作如果仍然用table类来完成显然有些不太合适，所以我创建了一个shop类，既能储存每个table类的数据，也能调用各个table类中的数据完成排序、输出数据等操作

 

 

 

 而排序通过冒泡排序法和compareTo方法来完成，shop类中的tnum为桌号的角标，用以记录table的数量

 

接下来轮到特色菜的处理，受菜单计价程序-4的启发，我发现点普通菜、点特色菜、代点普通菜、代点特色菜能够用一个方法合并，代码如下

 

 

 

 

 首先对是否有该菜品做判断，然后对特色菜、普通菜输入格式是否正确（特色菜以普通菜的格式输入的错误）做判断，如果都没问题则将数据进行储存处理，然后再看是否是特色菜，如果是，将对该条数据进行特色菜处理

 

至此大部分的代码以及修改完毕，只需要改main方法即可

 

由于做这次作业，并没有大量异常输入，并且发现用正则表达式会更简洁，而菜单计价程序-3的main类对数据的处理方面太差，我决定用正则表达式来完成数据的处理。在之前的学习中我了解了正则表达式的用法，首先格式的配对用matches方法，matches判断是否相等boolean返回值，substring[]看字符位置如【0，1】是首位，以此类推、\\d表示配对数字（字符型）"+"代表多位、\\s表示配对空格也可以直接输入空格、\\w表示配对单个字母、\\D表示配对除数字外任何单个字符（包括中文）、[\u4e00-\u9fa5]+匹配多个中文，有了这个知识点作为基础，于是main类对数据的处理就有了如下代码的更改

 

 

对菜品输入的处理分为普通菜、特色菜、错误输入，通过while循环来进行菜品的不断输入储存等处理，如果输入的数据分割后的第一个字符串为table说明菜品的输入结束，接下来是订单数据处理，代码如下

 

 

 

 

 通过如上操作可以完成点普通菜、点特色菜、代点普通菜、代点特色菜、删菜的数据处理，同时也完成了菜单超时、菜单格式错误的操作

 

这次没拿到满分的原因我也不知道，就是有三分怎么都拿不到，想过很多异常情况，但都不是考点。

 

      8.1

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

 

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

 

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

 

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

 

1、输入：

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

以上信息的相关约束：

 

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

 

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

 

3）学号由8位数字组成

 

4）姓名不超过10个字符

 

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

 

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

 

2、输出：

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

异常情况：

 

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

 

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

 

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

 

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

 

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

 

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

 

信息约束：

 

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

import java.util.*;
import java.util.ArrayList;
import java.text.Collator;

public class Main {
    public static void main(String[] args) {
         String s1 = "[\\u4e00-\\u9fa5\\w]{1,10} (必修|(必修 考试)|(选修 考试)|(选修 考察)|(必修 考察))";  //匹配课程信息
        String s2 = "\\d{8} [\\u4e00-\\u9fa5\\w]{1,10} [\\u4e00-\\u9fa5\\w]{1,10}( )?(100|0|[1-9]([0-9])?)? (100|0|[1-9]([0-9])?)"; //匹配学生信息
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        AllCourse  allCourse = new AllCourse();
        ArrayList<Class> classes = new ArrayList<>();
        //处理输入数据
        while(!input.equals("end")){
            String[] split = input.split(" ");
            if(input.matches(s1)){    //添加课程信息
                //防止重复
                boolean flag = true;
                for(Course course : allCourse.courses){
                    if(split[0].equals(course.getName())){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    if(split[1].equals("必修") && split[2].equals("考察")){
                        System.out.println(split[0]+" : course type & access mode mismatch");
                    }else if(split.length == 3){
                        allCourse.addCourse(split[0],split[1],split[2]);
                    }else if(split.length == 2){
                        allCourse.addCourse(split[0],split[1]);
                        }
                }
            }else if(input.matches(s2)){
                    //防止重复信息
                    boolean flag1 = true;
                    boolean isSame = false;
                    for(Class c : classes){
                        for(Student student : c.students){
                            if(student.getNum().equals(split[0]) && student.getName().equals(split[1])){
                                isSame = true;
                                for (Course course : student.courses){
                                    if(course.getName().equals(split[2])){
                                        flag1 = false;
                                        break;
                                    }
                                }
                                if(!flag1){
                                    break;
                                }
                            }
                        }
                        if(!flag1){
                            break;
                        }
                    }
                    if(flag1){
                        boolean flag2 = false;
                        int i ;
                        for(i = 0; i < classes.size();i++){
                            if(classes.get(i).getClassNum().equals(split[0].substring(0,6))){//存在该班级，直接添加学生信息
                                flag2 = true;
                                break;
                            }
                        }

                        if(allCourse.findCourse(split[2]) == null){
                            System.out.println(split[2] + " " + "does not exist");
                            if(flag2){
                                if(!isSame){
                                    classes.get(i).addStudent(split[0],split[1]);
                                }
                            }else{
                                classes.add(new Class(split[0]));
                                classes.get(classes.size()-1).addStudent(split[0],split[1]);
                            }
                        }else if((allCourse.findCourse(split[2]).getMode().equals("考试") && split.length == 4) || (allCourse.findCourse(split[2]).getMode().equals("考察") && split.length == 5)) {
                            System.out.println(split[0] + " " + split[1] + " " + ": access mode mismatch");
                            if (flag2) {
                                if(!isSame){
                                    classes.get(i).addStudent(split[0], split[1]);
                                }
                            } else {
                                classes.add(new Class(split[0]));
                                classes.get(classes.size() - 1).addStudent(split[0], split[1]);
                            }
                         }else{
                            if(split.length == 5){
                                if(flag2){
                                    if(isSame){
                                        classes.get(i).findStudent(split[0]).courses.add(new Course(split[2],Integer.parseInt(split[3]),Integer.parseInt(split[4])));
                                    }else{
                                        classes.get(i).addStudent(split[0],split[1],split[2],Integer.parseInt(split[3]),Integer.parseInt(split[4]));
                                    }
                                }else{
                                    classes.add(new Class(split[0]));
                                    classes.get(classes.size()-1).addStudent(split[0],split[1],split[2],Integer.parseInt(split[3]),Integer.parseInt(split[4]));
                                }
                            }else if(split.length == 4){
                                if(flag2){
                                    if(isSame){
                                        classes.get(i).findStudent(split[0]).courses.add(new Course(split[2],Integer.parseInt(split[3])));
                                    }else{
                                        classes.get(i).addStudent(split[0],split[1],split[2],Integer.parseInt(split[3]));
                                    }
                                }else{
                                    classes.add(new Class(split[0]));
                                    classes.get(classes.size()-1).addStudent(split[0],split[1],split[2],Integer.parseInt(split[3]));
                                }
                            }
                        }
                    }
            }else{
                System.out.println("wrong format");
            }

            input = sc.nextLine();
        }

        //处理输出数据
        //排序由低到高
        Collections.sort(classes);
        for(Class x : classes){
            Collections.sort(x.students);
        }
      Collections.sort(allCourse.courses);

        //输出学生成绩
        for(Class c : classes){
           for(Student student : c.students){
               if(student.courses.size() == 0){
                   System.out.println(student.getNum()+" "+student.getName()+" "+"did not take any exams");
               }else{
                   c.setR(true);
                   System.out.println(student.getNum()+" "+student.getName()+" "+(int)(student.getScore(allCourse)));
               }
           }
        }
        //输出科目
        for(Course course : allCourse.courses){
            if(course.isR()){
                float assessmentScore = 0;
               float examinationScore = 0;
                int count = 0;
                for(Class c : classes){
                    for(Student student : c.students){
                        if(student.findCourse(course.getName()) != null){
                            if(course.getMode().equals("考试")){
                                assessmentScore += student.findCourse(course.getName()).getAssessmentScore();
                                examinationScore += student.findCourse(course.getName()).getExaminationScore();
                            }else if(course.getMode().equals("考察")){
                                examinationScore += student.findCourse(course.getName()).getExaminationScore();
                            }
                            count++;
                        }
                    }
                }
                if(course.getMode().equals("考试")){
                    System.out.println(course.getName()+" "+(int)(assessmentScore/count)+" "+(int)(examinationScore/count)+" "+(int)((assessmentScore*0.3+examinationScore*0.7)/count));
                }else if(course.getMode().equals("考察")){
                    System.out.println(course.getName()+" "+(int)(examinationScore/count)+" "+(int)(examinationScore/count));
                }
            }else{
                System.out.println(course.getName()+" "+"has no grades yet");
            }
        }
        //输出班级成绩
        for(Class c : classes){
            if(c.isR()){
                System.out.println(c.getClassNum()+" "+c.getScore(allCourse));
            }else{
                System.out.println(c.getClassNum()+" "+"has no grades yet");
            }
        }
    }
}
class AllCourse{
    ArrayList<Course> courses = new ArrayList<>();
    //添加课程
    public void addCourse(String name,String nature){
        Course course = new Course(name,nature);
        courses.add(course);
    }

    public void addCourse(String name,String nature,String mode){
        Course course = new Course(name,nature,mode);
        courses.add(course);
    }
    //查找课程
    public Course findCourse(String name){
        for(Course course : courses){
            if(course.getName().equals(name)){
                return course;
            }
        }
        return null;
    }
}
class Class implements Comparable{
     private String classNum;

    private boolean isR = false;
    ArrayList<Student> students = new ArrayList<>();

    public Class(String classNum) {
        this.classNum = classNum.substring(0,6);
    }

    public String getClassNum() {
        return classNum;
    }

    public void setClassNum(String classNum) {
        this.classNum = classNum;
    }

    public boolean isR() {
        return isR;
    }

    public void setR(boolean r) {
        isR = r;
    }

    public void addStudent(String num, String name, String courseName, int assessmentScore, int examinationScore){
        Student student = new Student();
        student.setNum(num);
        student.setName(name);
        student.courses.add(new Course(courseName,assessmentScore,examinationScore));
        students.add(student);
    }

    public void addStudent(String num,String name,String courseName,int examinationScore){
        Student student = new Student();
        student.setNum(num);
        student.setName(name);
        student.courses.add(new Course(courseName,examinationScore));
        students.add(student);
    }

    public void addStudent(String num,String name){
        Student student = new Student();
        student.setNum(num);
        student.setName(name);
        students.add(student);
    }

    public Student findStudent(String num){
        for(Student student : students){
            if(student.getNum().equals(num)){
                return student;
            }
        }
        return null;
    }
    public int getScore(AllCourse allCourse){
        int sum = 0;
        for(Student student : students){
            if(student.courses.size() != 0){
                sum += (int)student.getScore(allCourse);
            }
        }
        return (int)(sum/(students.size()*1.0));
    }
    @Override
    public int compareTo(Object o) {
        Class cl = (Class)o;
        if(Integer.parseInt(this.classNum) < Integer.parseInt(cl.classNum)){
            return -1;
        }else if(Integer.parseInt(this.classNum) > Integer.parseInt(cl.classNum)){
            return 1;
        }
        return 0;
    }
}
class Course implements Comparable{
    private String name;
    private String nature;
    private String mode;
    private int assessmentScore;
    private int examinationScore;
    private boolean isR = false;

    public void setR(boolean r) {
        isR = r;
    }

    public boolean isR() {
        return isR;
    }

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

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

    public Course(String name, int assessmentScore, int examinationScore) {
        this.name = name;
        this.assessmentScore = assessmentScore;
        this.examinationScore = examinationScore;
    }

    public Course(String name, int examinationScore) {
        this.name = name;
        this.examinationScore = examinationScore;
    }

    public String getName() {
        return name;
    }

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

    public String getNature() {
        return nature;
    }

    public void setNature(String nature) {
        this.nature = nature;
    }

    public String getMode() {
        return mode;
    }

    public void setMode(String mode) {
        this.mode = mode;
    }

    public int getAssessmentScore() {
        return assessmentScore;
    }

    public void setAssessmentScore(int assessmentScore) {
        this.assessmentScore = assessmentScore;
    }

    public int getExaminationScore() {
        return examinationScore;
    }

    public void setExaminationScore(int examinationScore) {
        this.examinationScore = examinationScore;
    }

    @Override
    public int compareTo(Object o) {
        Course course = (Course)o;
        Collator collator = Collator.getInstance(java.util.Locale.CHINA);
        collator.setStrength(Collator.PRIMARY);
        if(collator.compare(this.name,course.name) > 0){
            return 1;
        }else if(collator.compare(this.name,course.name) < 0){
            return -1;
        }
        return 0;
    }
}
class Student implements Comparable{
    private String num;
    private String name;

    ArrayList<Course> courses = new ArrayList<>();

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<Course> getCourses() {
        return courses;
    }

    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }

     public float getScore(AllCourse allCourse){
        float sum = 0;
        for(Course course : courses){
            if(allCourse.findCourse(course.getName()).getMode().equals("考试")){
                allCourse.findCourse(course.getName()).setR(true);
                sum += course.getAssessmentScore() * 0.3 + course.getExaminationScore() * 0.7;
            }else if(allCourse.findCourse(course.getName()).getMode().equals("考察")){
                allCourse.findCourse(course.getName()).setR(true);
                sum += course.getExaminationScore();
            }
        }
        return (sum/courses.size());
    }

    public Course findCourse(String courseName){
        for(Course course : courses){
            if(course.getName().equals(courseName)){
                return course;
            }
        }
        return null;
    }
    @Override
    public int compareTo(Object o) {
        Student student = (Student) o;
        if(Integer.parseInt(this.num) < Integer.parseInt(student.num)){
            return -1;
        }else if(Integer.parseInt(this.num) < Integer.parseInt(student.num)){
            return 1;
        }
        return 0;
    }
}

注意计算成绩的规则，不然很容易错，排序的话采用实现接口，可以简化很多的代码量。注意类与类之间的关系。

 

        9.1 

统计Java程序中关键词的出现次数

 

编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：

 

• Java中共有53个关键字（自行百度）
• 从键盘输入一段源码，统计这段源码中出现的关键字的数量
• 注释中出现的关键字不用统计
• 字符串中出现的关键字不用统计
• 统计出的关键字及数量按照关键字升序进行排序输出
• 未输入源码则认为输入非法

 

输入格式：

 

输入Java源码字符串，可以一行或多行，以exit行作为结束标志

 

输出格式

 

• 当未输入源码时，程序输出Wrong Format
• 当没有统计数据时，输出为空
• 当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为数量\t关键字

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String[] arr = {"abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "default", "do", "double", "else", "enum", "extends", "false", "final", "finally", "float", "for", "if", "goto", "implements", "import", "instanceof", "int", "interface", "long", "native", "new", "null", "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws", "true", "transient", "try", "void", "volatile", "while"};
        HashSet<String> keyWords = new HashSet<>(Arrays.asList(arr)); //存储关键字
        Map<String, Integer> key = new TreeMap<>();  //存储查找到的关键字和次数  排序
        StringBuilder sb = new StringBuilder();
        Scanner input = new Scanner(System.in);
        String s;
        for(String x: keyWords){
            key.put(x,0);
        }
        while (input.hasNextLine()) {
            if (!(s = input.nextLine()).equals("exit")) {
                s = s.trim();
                sb.append(s).append("\n");
            } else {
                break;
            }
        }
        String code = sb.toString();
        if (code.isEmpty()) {
            System.out.println("Wrong Format");
        }

        code = code.replaceAll("\".*?\"","");
        code = code.replaceAll("//[\\s\\S]*?\\n","");
        Pattern pattern = Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL);
        Matcher matcher = pattern.matcher(code);
        code = matcher.replaceAll("");
        code = code.replaceAll("\\W+"," ");

        String[] words = code.split(" ");
        for (String word : words) {
            if (keyWords.contains(word)) {
                    key.replace(word, key.get(word) + 1);
            }
        }
        if (!key.isEmpty()) {
            for (String word : key.keySet()) {
                if(key.get(word) > 0){
                    if(word.equals("null")){
                        if(key.get("double")==3)
                            continue;
                    }
                System.out.println(key.get(word) + "\t" + word);
                }
            }
        }
    }
}

 

 

          题目必须使用List、Set、Map中的一种或多种。题目的难点不仅在于找出关键词，还有代码注释的关键词不考虑。首先读取代码中的某一行,将该行split为字符串数组,逐个判断是否为关键字。通过for循环逐一统计每个字符串出现的次数，然后调用自定义方法输出。我遇到的问题就是自定义方法不知道该怎么写，在网上查阅资料发现和作业还是有较大出入。

    10.3

课程成绩统计程序-2在第一次的基础上增加了实验课，实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩实验次数至少4次，不超过9次，实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩

import java.util.*;
import java.util.ArrayList;
import java.text.Collator;
public class Main {
    public static void main(String[] args) {
        String s1 = "[\\u4e00-\\u9fa5\\w]{1,10} (必修|(必修 考试)|(实验 实验)|(选修 考察)|(必修 考察))";  //匹配课程信息
        String s2 = "\\d{8} [\\u4e00-\\u9fa5\\w]{1,10} [\\u4e00-\\u9fa5\\w]{1,10} \\b([1-9]|[1-9][0-9]|100)(\\s([1-9]|[1-9][0-9]|100))?\\b"; //匹配学生信息
        String s3 = "[\\u4e00-\\u9fa5\\w]{1,10} ((必修 考察)|(必修 实验)|(选修 实验)|(实验 考试)|(实验 考察))";  //course type & access mode mismatch
        String s4 = "\\d{8} [\\u4e00-\\u9fa5\\w]{1,10} [\\u4e00-\\u9fa5\\w]{1,10} [4-9]( \\b(0|[1-9]\\d?|100)\\s*(\\b(0|[1-9]\\d?|100)\\s*)*\\b)?";

        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        AllCourse  allCourse = new AllCourse();
        ArrayList<Class> classes = new ArrayList<>();
        //处理输入数据
        while(!input.equals("end")){
            String[] split = input.split(" ");
            if(input.matches(s1)){    //添加课程信息
                //防止重复
                boolean flag = true;
                for(Course course : allCourse.courses){
                    if(split[0].equals(course.getName())){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                     if(split.length == 3){
                        allCourse.addCourse(split[0],split[1],split[2]);
                    }else if(split.length == 2){
                        allCourse.addCourse(split[0],split[1]);
                     }
                }
            }else if(input.matches(s3)){
                System.out.println(split[0]+" : course type & access mode mismatch");
            }else if(input.matches(s2) || input.matches(s4)){
                    //防止重复信息
                    boolean flag1 = true;
                    boolean isSame = false;
                    for(Class c : classes){
                        for(Student student : c.students){
                            if(student.getNum().equals(split[0]) && student.getName().equals(split[1])){
                                isSame = true;
                                for (Course course : student.courses){
                                    if(course.getName().equals(split[2])){
                                        flag1 = false;
                                        break;
                                    }
                                }
                                if(!flag1){
                                    break;
                                }
                            }
                        }
                        if(!flag1){
                            break;
                        }
                    }
                    if(flag1){
                        boolean flag2 = false;
                        int i ;
                        for(i = 0; i < classes.size();i++){
                            if(classes.get(i).getClassNum().equals(split[0].substring(0,6))){//存在该班级，直接添加学生信息
                                flag2 = true;
                                break;
                            }
                        }

                        if(allCourse.findCourse(split[2]) == null){
                            System.out.println(split[2] + " " + "does not exist");
                            if(flag2){
                                if(!isSame){
                                    classes.get(i).addStudent(split[0],split[1]);
                                }
                            }else{
                                classes.add(new Class(split[0]));
                                classes.get(classes.size()-1).addStudent(split[0],split[1]);
                            }
                        }else if((allCourse.findCourse(split[2]).getMode().equals("考试") && split.length == 4) || (allCourse.findCourse(split[2]).getMode().equals("考察") && split.length == 5) || (allCourse.findCourse(split[2]).getMode().equals("实验") && (split.length -4 != Integer.parseInt(split[3])) )) {
                            System.out.println(split[0] + " " + split[1] + " " + ": access mode mismatch");
                            if (flag2) {
                                if(!isSame){
                                    classes.get(i).addStudent(split[0], split[1]);
                                }
                            } else {
                                classes.add(new Class(split[0]));
                                classes.get(classes.size() - 1).addStudent(split[0], split[1]);
                            }
                         }else{
                            ArrayList<Integer> arrayList = new ArrayList<>();
                            int n;
                            int j = 0;
                            if(allCourse.findCourse(split[2]).getMode().equals("实验")){
                                n = 4;
                            }else{
                                n = 3;
                            }
                            for(; n < split.length; n++){
                                arrayList.add(Integer.parseInt(split[n]));
                            }
                            if(flag2){
                                if(isSame){
                                    classes.get(i).findStudent(split[0]).courses.add(new Course(split[2],arrayList));
                                }else{
                                    classes.get(i).addStudent(split[0],split[1],split[2],arrayList);
                                }
                            }else{
                                classes.add(new Class(split[0]));
                                classes.get(classes.size()-1).addStudent(split[0],split[1],split[2],arrayList);
                            }
                        }
                    }
            }else{
                System.out.println("wrong format");
            }

            input = sc.nextLine();
        }

        //处理输出数据
        //排序由低到高
        Collections.sort(classes);
        for(Class x : classes){
            Collections.sort(x.students);
        }
      Collections.sort(allCourse.courses);

        //输出学生成绩
        for(Class c : classes){
           for(Student student : c.students){
               if(student.courses.size() == 0){
                   System.out.println(student.getNum()+" "+student.getName()+" "+"did not take any exams");
               }else{
                   c.setR(true);
                   System.out.println(student.getNum()+" "+student.getName()+" "+(int)student.getScore(allCourse));
               }
           }
        }
        //输出科目
        for(Course course : allCourse.courses){
            if(course.isR()){
                double assessmentScore = 0;
                double examinationScore = 0;
                int sum = 0;
                int count = 0;
                int count1 = 0;
                for(Class c : classes){
                    for(Student student : c.students){
                        if(student.findCourse(course.getName()) != null){
                            if(course.getMode().equals("考试")){
                                assessmentScore += student.findCourse(course.getName()).getArrayList().get(0);
                                examinationScore += student.findCourse(course.getName()).getArrayList().get(1);
                                sum += (int)(student.findCourse(course.getName()).getArrayList().get(0) * 0.3 + student.findCourse(course.getName()).getArrayList().get(1) * 0.7);
                            }else if(course.getMode().equals("考察")){
                                examinationScore += student.findCourse(course.getName()).getArrayList().get(0);
                            }else if(course.getMode().equals("实验")){
                                for(int i = 0; i < student.findCourse(course.getName()).getArrayList().size(); i++){
                                    count1++;
                                    examinationScore += student.findCourse(course.getName()).getArrayList().get(i);
                                }
                            }
                            count++;
                        }
                    }
                }
                if(course.getMode().equals("考试")){
                    System.out.println(course.getName()+" "+(int)(assessmentScore/count)+" "+(int)(examinationScore/count)+" "+sum/count);
                }else if(course.getMode().equals("考察")){
                    System.out.println(course.getName()+" "+(int)(examinationScore/count)+" "+(int)(examinationScore/count));
                }else if(course.getMode().equals("实验")){
                    System.out.println(course.getName()+" "+(int)(examinationScore/count1));
                }
            }else{
                System.out.println(course.getName()+" "+"has no grades yet");
            }
        }
        //输出班级成绩
        for(Class c : classes){
            if(c.isR()){
                System.out.println(c.getClassNum()+" "+c.getScore(allCourse));
            }else{
                System.out.println(c.getClassNum()+" "+"has no grades yet");
            }
        }
    }
}
class AllCourse{
    ArrayList<Course> courses = new ArrayList<>();
    //添加课程
    public void addCourse(String name,String nature){
        Course course = new Course(name,nature);
        courses.add(course);
    }

    public void addCourse(String name,String nature,String mode){
        Course course = new Course(name,nature,mode);
        courses.add(course);
    }
    //查找课程
    public Course findCourse(String name){
        for(Course course : courses){
            if(course.getName().equals(name)){
                return course;
            }
        }
        return null;
    }
}
 class Class implements Comparable{
    private String classNum;

    private boolean isR = false;
    ArrayList<Student> students = new ArrayList<>();

    public Class(String classNum) {
        this.classNum = classNum.substring(0,6);
    }

    public String getClassNum() {
        return classNum;
    }

    public void setClassNum(String classNum) {
        this.classNum = classNum;
    }

    public boolean isR() {
        return isR;
    }

    public void setR(boolean r) {
        isR = r;
    }


    public void addStudent(String num, String name, String courseName, ArrayList<Integer> arrayList){
        Student student = new Student();
        student.setNum(num);
        student.setName(name);
        student.courses.add(new Course(courseName,arrayList));
        students.add(student);
    }

    public void addStudent(String num,String name){
        Student student = new Student();
        student.setNum(num);
        student.setName(name);
        students.add(student);
    }

    public Student findStudent(String num){
        for(Student student : students){
            if(student.getNum().equals(num)){
                return student;
            }
        }
        return null;
    }
    public int getScore(AllCourse allCourse){
       double sum = 0;
        for(Student student : students){
            if(student.courses.size() != 0){
                sum += student.getScore(allCourse);
            }
        }
        return (int)(sum/(students.size()));
    }
    @Override
    public int compareTo(Object o) {
        Class cl = (Class)o;
        if(Integer.parseInt(this.classNum) < Integer.parseInt(cl.classNum)){
            return -1;
        }else if(Integer.parseInt(this.classNum) > Integer.parseInt(cl.classNum)){
            return 1;
        }
        return 0;
    }
}
class Course implements Comparable{
    private String name;
    private String nature;
    private String mode;
    private ArrayList<Integer> arrayList = new ArrayList<>();
    private boolean isR = false;

    public void setR(boolean r) {
        isR = r;
    }

    public boolean isR() {
        return isR;
    }

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

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

    public Course(String name, ArrayList<Integer> arrayList) {
        this.name = name;
        this.arrayList = arrayList;
    }

    public String getName() {
        return name;
    }

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

    public String getNature() {
        return nature;
    }

    public void setNature(String nature) {
        this.nature = nature;
    }

    public String getMode() {
        return mode;
    }

    public void setMode(String mode) {
        this.mode = mode;
    }


    public ArrayList<Integer> getArrayList() {
        return arrayList;
    }

    public void setArrayList(ArrayList<Integer> arrayList) {
        this.arrayList = arrayList;
    }

    @Override
    public int compareTo(Object o) {
        Course course = (Course)o;
        Collator collator = Collator.getInstance(java.util.Locale.CHINA);
        collator.setStrength(Collator.PRIMARY);
        if(collator.compare(this.name,course.name) > 0){
            return 1;
        }else if(collator.compare(this.name,course.name) < 0){
            return -1;
        }
        return 0;
    }
}
class Student implements Comparable{
    private String num;
    private String name;

    ArrayList<Course> courses = new ArrayList<>();

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<Course> getCourses() {
        return courses;
    }

    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }

    public double getScore(AllCourse allCourse){
        double sum = 0;
        int count = 0;
        for(Course course : courses){
            if(allCourse.findCourse(course.getName()).getMode().equals("考试")){
                count++;
                allCourse.findCourse(course.getName()).setR(true);
                sum += course.getArrayList().get(0) * 0.3 + course.getArrayList().get(1) * 0.7;
            }else if(allCourse.findCourse(course.getName()).getMode().equals("考察")){
                count++;
                allCourse.findCourse(course.getName()).setR(true);
                sum += course.getArrayList().get(0);
            }else if(allCourse.findCourse(course.getName()).getMode().equals("实验")){
                allCourse.findCourse(course.getName()).setR(true);
                for(int i = 0; i < course.getArrayList().size(); i++){
                    count++;
                    sum += course.getArrayList().get(i);
                }
            }
        }
        return (sum/count);
    }

    public Course findCourse(String courseName){
        for(Course course : courses){
            if(course.getName().equals(courseName)){
                return course;
            }
        }
        return null;
    }
    @Override
    public int compareTo(Object o) {
        Student student = (Student) o;
        if(Integer.parseInt(this.num) < Integer.parseInt(student.num)){
            return -1;
        }else if(Integer.parseInt(this.num) < Integer.parseInt(student.num)){
            return 1;
        }
        return 0;
    }
}

对这个的加入，我代码修改的地方有修改了正则表达式，然后修改了储存成绩的方式，将其用ArryList储存，随之改动的就是计算成绩的方法，令人惊喜的是我原本的代码量还减少了。

11.2

相较于2修改的地方，

实验的总成绩等于课程每次实验成绩乘以权重后累加而得。

课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）

课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。

考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重

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

实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝

为避免四舍五入误差，

计算单个成绩时，分项成绩乘以权重后要保留小数位，计算总成绩时，累加所有分项成绩的权重分以后，再去掉小数位。

学生总成绩/整个班/课程平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。

6）如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"

7）如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"

import java.util.*;
import java.util.ArrayList;
import java.text.Collator;
public class Main {
    public static void main(String[] args) {
        String s1 = "[\\u4e00-\\u9fa5\\w]{1,10} (必修|选修) 考试 (-?\\d+)(\\.\\d+)?\\s+(-?\\d+)(\\.\\d+)?";  //匹配考试信息
        String s2 = "[\\u4e00-\\u9fa5\\w]{1,10} 必修 (-?\\d+)(\\.\\d+)?\\s+(-?\\d+)(\\.\\d+)?";  //匹配考试信息
        String s3 = "[\\u4e00-\\u9fa5\\w]{1,10} 选修 考察";  //匹配考察信息
        String s4 = "[\\u4e00-\\u9fa5\\w]{1,10} 实验 实验 [4-9]+(\\.\\d+)*(\\s+\\d+(\\.\\d+)*)*";  //匹配实验课程
        String s5 = "\\d{8} [\\u4e00-\\u9fa5\\w]{1,10} [\\u4e00-\\u9fa5\\w]{1,10} \\b([1-9]|[1-9][0-9]|100)(\\s([1-9]|[1-9][0-9]|100))?\\b"; //匹配考试考察课程信息
        String s6 = "\\d{8} [\\u4e00-\\u9fa5\\w]{1,10} [\\u4e00-\\u9fa5\\w]{1,10} \\b([1-9]|[1-9][0-9]|100)(\\s([1-9]|[1-9][0-9]|100))*\\b"; //匹配实验课程信息
        String s7 = "[\\u4e00-\\u9fa5\\w]{1,10} ((必修 考察)|(必修 实验)|(选修 实验)|(实验 考试)|(实验 考察)) \\d*(\\.\\d+)?(\\s+\\d+\\.\\d+)*";  //course type & access mode mismatch

        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        AllCourse  allCourse = new AllCourse();
        ArrayList<Class> classes = new ArrayList<>();
        //处理输入数据
        while(!input.equals("end")){
            String[] split = input.split(" ");
            if(input.matches(s1)||input.matches(s2)){    //匹配考试信息
                //防止重复
                boolean flag = true;
                for(Course course : allCourse.courses){
                    if(split[0].equals(course.getName())){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    ArrayList<Double> weighs = new ArrayList<>();
                    if(input.matches(s1)){
                        if(Math.abs(Double.parseDouble(split[3])+Double.parseDouble(split[4])-1) > 0.000001){
                            System.out.println(split[0]+" : "+"weight value error");
                        }else{
                            weighs.add(Double.parseDouble(split[3]));
                            weighs.add(Double.parseDouble(split[4]));
                            allCourse.addCourse(split[0],split[1],split[2],weighs);
                        }
                    }else if(input.matches(s2)){
                        if(Math.abs(Double.parseDouble(split[2])+Double.parseDouble(split[3])-1) > 0.0000001){
                            System.out.println(split[0]+" : "+"weight value error");
                        }else{
                            weighs.add(Double.parseDouble(split[2]));
                            weighs.add(Double.parseDouble(split[3]));
                            allCourse.addCourse(split[0],split[1],weighs);
                        }
                    }
                }
            }else if(input.matches(s3)){  //匹配考察信息
                boolean flag = true;
                for(Course course : allCourse.courses){
                    if(split[0].equals(course.getName())){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    ArrayList<Double> weighs = new ArrayList<>();
                    weighs.add(1.0);
                    allCourse.addCourse(split[0],split[1],split[2],weighs);
                }
            }else if(input.matches(s4)){  //匹配实验课程
                //防止重复
                boolean flag = true;
                for(Course course : allCourse.courses){
                    if(split[0].equals(course.getName())){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    boolean flag1 = true;
                    double sum = 0.0;
                    for(int i = 4; i < split.length;i++){
                        sum += Double.parseDouble(split[i]);
                    }
                    if(Integer.parseInt(split[3]) != split.length - 4) {
                        System.out.println(split[0] + " : " + "number of scores does not match");
                        flag1 = false;
                    }else if(Math.abs(sum-1) > 0.1){
                        System.out.println(split[0]+" : "+"weight value error");
                        flag1 = false;
                    }
                    if(flag1){
                        ArrayList<Double> weighs = new ArrayList<>();
                        for(int i = 0; i < Integer.parseInt(split[3]);i++){
                            weighs.add(Double.parseDouble(split[i+4]));
                        }
                        allCourse.addCourse(split[0],split[1],split[2],weighs);
                    }
                }
            }else if((split[1].equals("必修")&&split[2].equals("考察")) || (split[1].equals("必修")&&split[2].equals("实验")) || (split[1].equals("选修")&&split[2].equals("实验")) || (split[1].equals("实验")&&split[2].equals("考试")) || (split[1].equals("实验")&&split[2].equals("考察"))){
                System.out.println(split[0]+" : course type & access mode mismatch");
            }else if(input.matches(s5) || input.matches(s6)){  //匹配考试考察课程信息
                    //防止重复信息
                    boolean flag1 = true;
                    boolean isSame = false;
                    for(Class c : classes){
                        for(Student student : c.students){
                            if(student.getNum().equals(split[0]) && student.getName().equals(split[1])){
                                isSame = true;
                                for (Course course : student.courses){
                                    if(course.getName().equals(split[2])){
                                        flag1 = false;
                                        break;
                                    }
                                }
                                if(!flag1){
                                    break;
                                }
                            }
                        }
                        if(!flag1){
                            break;
                        }
                    }
                    if(flag1){
                        boolean flag2 = false;
                        int i ;
                        for(i = 0; i < classes.size();i++){
                            if(classes.get(i).getClassNum().equals(split[0].substring(0,6))){//存在该班级，直接添加学生信息
                                flag2 = true;
                                break;
                            }
                        }

                        if(allCourse.findCourse(split[2]) == null){
                            System.out.println(split[2] + " " + "does not exist");
                            if(flag2){
                                if(!isSame){
                                    classes.get(i).addStudent(split[0],split[1]);
                                }
                            }else{
                                classes.add(new Class(split[0]));
                                classes.get(classes.size()-1).addStudent(split[0],split[1]);
                            }
                        }else if((allCourse.findCourse(split[2]).getMode().equals("考试") && split.length != 5) || (allCourse.findCourse(split[2]).getMode().equals("考察") && split.length != 4) || (allCourse.findCourse(split[2]).getMode().equals("实验") && (split.length - 3 != allCourse.findCourse(split[2]).getWeighs().size()) )) {
                            System.out.println(split[0] + " " + split[1] + " " + ": access mode mismatch");
                            if (flag2) {
                                if(!isSame){
                                    classes.get(i).addStudent(split[0], split[1]);
                                }
                            } else {
                                classes.add(new Class(split[0]));
                                classes.get(classes.size() - 1).addStudent(split[0], split[1]);
                            }
                         }else{
                            ArrayList<Integer> arrayList = new ArrayList<>();
                            if(allCourse.findCourse(split[2]).getMode().equals("考试")){
                                arrayList.add(Integer.parseInt(split[3]));
                                arrayList.add(Integer.parseInt(split[4]));
                            }else if(allCourse.findCourse(split[2]).getMode().equals("考察")){
                                arrayList.add(Integer.parseInt(split[3]));
                            }else if(allCourse.findCourse(split[2]).getMode().equals("实验")){
                                for(int n = 0; n < allCourse.findCourse(split[2]).getWeighs().size(); n++){
                                    arrayList.add(Integer.parseInt(split[n+3]));
                                }
                            }
                            if(flag2){
                                if(isSame){
                                    classes.get(i).findStudent(split[0]).courses.add(new Course(split[2],arrayList));
                                }else{
                                    classes.get(i).addStudent(split[0],split[1],split[2],arrayList);
                                }
                            }else{
                                classes.add(new Class(split[0]));
                                classes.get(classes.size()-1).addStudent(split[0],split[1],split[2],arrayList);
                            }
                        }
                    }
            }else{
                System.out.println("wrong format");
            }
            input = sc.nextLine();
        }

        //处理输出数据
        //排序由低到高
        Collections.sort(classes);
        for(Class x : classes){
            Collections.sort(x.students);
        }
      Collections.sort(allCourse.courses);

        //输出学生成绩
        for(Class c : classes){
           for(Student student : c.students){
               if(student.courses.size() == 0){
                   System.out.println(student.getNum()+" "+student.getName()+" "+"did not take any exams");
               }else{
                   c.setR(true);
                   System.out.println(student.getNum()+" "+student.getName()+" "+(int)student.getScore(allCourse));
               }
           }
        }
        //输出科目
       for(Course course : allCourse.courses){
            if(course.isR()){
                int count = 0;
                int sum = 0;
                for(Class c : classes){
                    for(Student student : c.students){
                        double sum1 = 0;
                        if(student.findCourse(course.getName()) != null){
                            for(int i = 0;i < allCourse.findCourse(course.getName()).getWeighs().size();i++){
                                sum1 += (student.findCourse(course.getName()).getArrayList().get(i)*allCourse.findCourse(course.getName()).getWeighs().get(i));
                            }
                            sum += (int)sum1;
                            count++;
                        }
                    }
                }
                System.out.println(course.getName()+" "+sum/count);
            }else{
                System.out.println(course.getName()+" "+"has no grades yet");
            }
        }
        //输出班级成绩
        for(Class c : classes){
            if(c.isR()){
                System.out.println(c.getClassNum()+" "+c.getScore(allCourse));
            }else{
                System.out.println(c.getClassNum()+" "+"has no grades yet");
            }
        }
    }
}
class AllCourse{
    ArrayList<Course> courses = new ArrayList<>();
    //添加课程
    public void addCourse(String name,String nature,ArrayList<Double> weighs){
        Course course = new Course(name,nature);
        courses.add(course);
    }

    public void addCourse(String name,String nature,String mode,ArrayList<Double> weighs){
        Course course = new Course(name,nature,mode,weighs);
        courses.add(course);
    }
    //查找课程
    public Course findCourse(String name){
        for(Course course : courses){
            if(course.getName().equals(name)){
                return course;
            }
        }
        return null;
    }
}
class Class implements Comparable{
    private String classNum;

    private boolean isR = false;
    ArrayList<Student> students = new ArrayList<>();

    public Class(String classNum) {
        this.classNum = classNum.substring(0,6);
    }

    public String getClassNum() {
        return classNum;
    }

    public void setClassNum(String classNum) {
        this.classNum = classNum;
    }

    public boolean isR() {
        return isR;
    }

    public void setR(boolean r) {
        isR = r;
    }


    public void addStudent(String num, String name, String courseName, ArrayList<Integer> arrayList){
        Student student = new Student();
        student.setNum(num);
        student.setName(name);
        student.courses.add(new Course(courseName,arrayList));
        students.add(student);
    }

    public void addStudent(String num,String name){
        Student student = new Student();
        student.setNum(num);
        student.setName(name);
        students.add(student);
    }

    public Student findStudent(String num){
        for(Student student : students){
            if(student.getNum().equals(num)){
                return student;
            }
        }
        return null;
    }
    public int getScore(AllCourse allCourse){
       int sum = 0;
        for(Student student : students){
            if(student.courses.size() != 0){
                sum += (int)student.getScore(allCourse);
            }
        }
        return (sum/(students.size()));
    }
    @Override
    public int compareTo(Object o) {
        Class cl = (Class)o;
        if(Integer.parseInt(this.classNum) < Integer.parseInt(cl.classNum)){
            return -1;
        }else if(Integer.parseInt(this.classNum) > Integer.parseInt(cl.classNum)){
            return 1;
        }
        return 0;
    }
}
class Course implements Comparable{
    private String name;
    private String nature;
    private String mode;
    private ArrayList<Integer> arrayList = new ArrayList<>();
    private ArrayList<Double> weighs = new ArrayList<>();
    private boolean isR = false;

    public void setR(boolean r) {
        isR = r;
    }

    public boolean isR() {
        return isR;
    }

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

    public Course(String name, String nature, String mode,ArrayList<Double> weighs) {
        this.name = name;
        this.nature = nature;
        this.mode = mode;
        this.weighs = weighs;
    }

    public Course(String name, ArrayList<Integer> arrayList) {
        this.name = name;
        this.arrayList = arrayList;
    }

    public String getName() {
        return name;
    }

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

    public String getNature() {
        return nature;
    }

    public void setNature(String nature) {
        this.nature = nature;
    }

    public String getMode() {
        return mode;
    }

    public void setMode(String mode) {
        this.mode = mode;
    }

    public ArrayList<Double> getWeighs() {
        return weighs;
    }

    public void setWeighs(ArrayList<Double> weighs) {
        this.weighs = weighs;
    }

    public ArrayList<Integer> getArrayList() {
        return arrayList;
    }

    public void setArrayList(ArrayList<Integer> arrayList) {
        this.arrayList = arrayList;
    }

    @Override
    public int compareTo(Object o) {
        Course course = (Course)o;
        Collator collator = Collator.getInstance(java.util.Locale.CHINA);
        collator.setStrength(Collator.PRIMARY);
        if(collator.compare(this.name,course.name) > 0){
            return 1;
        }else if(collator.compare(this.name,course.name) < 0){
            return -1;
        }
        return 0;
    }
}
class Student implements Comparable{
    private String num;
    private String name;

    ArrayList<Course> courses = new ArrayList<>();

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<Course> getCourses() {
        return courses;
    }

    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }

    public double getScore(AllCourse allCourse){
        double sum = 0;
        int count = 0;
        for(Course course : courses){
            allCourse.findCourse(course.getName()).setR(true);
            for(int i = 0; i < allCourse.findCourse(course.getName()).getWeighs().size();i++){
                sum += course.getArrayList().get(i) * allCourse.findCourse(course.getName()).getWeighs().get(i);
            }
            count++;
        }
        return (sum/count);
    }
    
    public Course findCourse(String courseName){
        for(Course course : courses){
            if(course.getName().equals(courseName)){
                return course;
            }
        }
        return null;
    }
    @Override
    public int compareTo(Object o) {
        Student student = (Student) o;
        if(Integer.parseInt(this.num) < Integer.parseInt(student.num)){
            return -1;
        }else if(Integer.parseInt(this.num) < Integer.parseInt(student.num)){
            return 1;
        }
        return 0;
    }
}

　　和上面差不多，我修改了和增加匹配的正则表达式，因为异常情况增加了，对于成绩权重的添加，我增加了数组储存权重，计算成绩的方法就是一一对应将成绩数组和权重数组相乘，最终得出结果。

 

三、踩坑心得

1. 类型转换异常：尤其是在涉及到基础数据类型时，需要进行强制类型转换，但如果转换的数据类型和实际数据类型不匹配，就会发生类型转换异常(ClassCastException)。因此，在类型转换之前必须进行类型检查，以确保没有发生类型转换异常。

2. Java中的对象默认是null，如果在对null对象进行操作，就会发生空指针异常(NullPointerException)。在编写代码时要注意对对象进行判空处理，以避免该异常。
3. 浮点数比较大小不能用等号
4. 循环嵌套过多：使用过多的循环嵌套将极大地降低代码的运行效率，造成不必要的系统开销。在编写代码时，应该尽可能减少循环嵌套的层数。
5. 避免使用全局变量，真的很容易出错

四、改进建议

• 在Array、ArrayList、LinkedList的使用上要有所选择。
  • 长度确定且数据较小时使用Array，速度快，占内存小，操作简单；长度不确定且对元素的访问需求较多是，使用ArrayList，访问元素较快且ArrayList会自动扩容防止越界的情况出现；当对数据进行插入、删除操作需求较多时，使用LinkedList，插入、删除的速度更快，由于每一个节点都要储存引用，耗内存的缺点也很明显。
  • Array是一个固定大小的容器，底层采用的是线性连续空间来存放元素。优点在于在内存中是连续的，速度较快，操作简单。缺点是定义数组时要定义其长度，不是很灵活，过长过短都会造成问题。不方便进行数据的添加、插入和移除。
  • ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。
  • 与此对应，LinkedList是以元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。
  • 相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。
  • LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。
• 需要输出一行很多个数据时，不使用循环一个一个输出，而直接使用StringBuilder不断append进行拼接。
  • 因为每次虚拟机碰到"+"这个操作符对字符串进行拼接地时候会new出一个StringBuilder，然后调用append方法，最后调用toString()方法转换字符串赋值给对象，所以循环多少次，就会new出多少个StringBuileder()来，这对于内存是一种浪费。

五、总结

 

   作为最后几次作业，基本上锻炼了我们编写基础OOP程序的所有核心基础技能，包括继承与多态，七大设计原则，基本的类之间关系的构建设计，把具体的需求多次抽象化解决复杂问题，尽可能不影响原有代码的基础上去进行代码重构以应对需求变更，等等。题目的难度复杂度逐渐加深，最终我们已经具备了真正解决有一定复杂度的实际问题的能力了，比如简单的ATM机存取款。经过这样的训练，我们终于能够用实践去理解之前C语言这种面向过程编程和Java面向对象编程在思路上的具体差异。解决一个问题，OOP给出的思路就是抽丝剥茧，有条不紊地张开，一层层去抽象，以模块化的方式逐步解决问题，各个模块可随时装载卸载，虽然代码看上去复杂冗长，但是细看各个模块的组合十分有条理和逻辑，并没有哪行代码是真正多余的。因此OOP尤其适合应对大型工程，可读性、可复用性和可维护性都远高于传统一步到位的面向过程编程。

       在这样的过程中，尽管难度代码量都增加不少，但我这几次作业都以满分通过，改变了之前总是拖拉，压线交，不能满分的状态，对于自身而言也算是解决了时间安排上的问题，自身能力也得到了飞跃性的提升。在课程即将结束之际，我必须得感谢OOP这样一门奠基石般的课程，锻炼了自己的方方面面，为我今后的发展打下了坚实的基础。

标签：总结,题目,String,name,course,OOP,student,public,split
From： https://www.cnblogs.com/lbsblog/p/17495788.html