PTA7、8、期末考试总结

//package pta7_4;

//动物发生模拟器.  请在下面的【】处添加代码。
public class Main {

    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
        Goat goat = new Goat();
        speak(cat);
        speak(dog);
        speak(goat);
    }
    //定义静态方法speak()
    public static void speak(Animal animal){
        System.out.println(animal.getName()+"的叫声："+animal.out());
    }
}

//定义抽象类Animal
abstract class Animal{
     abstract String getName();
     abstract String out();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
    String getName(){
        return "猫";
    }
    String out(){
        return "喵喵";
    }
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal {
    String getName(){
        return "狗";
    }
    String out(){
        return "汪汪";
    }
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{
    String getName(){
        return "山羊";
    }
    String out(){
        return "咩咩";
    }
}

//package pta7_3;
import java.text.Collator;
import java.util.*;

public class Main {
    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        HashMap<String,Course> courses = new HashMap<>();//课程
        HashMap<String,Classroom> classes = new HashMap<>();//班级
        HashMap<String,Student> students = new HashMap<>();//学生
        ArrayList<ChoseCourse> chooseCourses = new ArrayList<>();//选课
        String str = input.nextLine();//定义一个字符串str用来接收
       while(!str.equals("end")){
            if(str.matches("^\\S{1,10} (必修|选修|实验) (考试|考察|实验)$")){////前面的判断无所谓，后面跟着“必修”、“选修”或“实验”中的一个，再后面跟着一个空格，再跟着“必修”、“选修”或“实验”中的一个。
                String []arr = str.split(" ");//new String[100];//将上述str分割
                //条件一 必修+考试
                //选修 + （考试或者考察）
                //条件三 实验+实验
                if(((arr[1].equals("必修") && arr[2].equals("考试"))
                        || (arr[1].equals("选修") && (arr[2].equals("考试") || arr[2].equals("考察")))
                        || (arr[1].equals("实验") && arr[2].equals("实验")))){
                    if(!courses.containsKey(arr[0])){//课程的导入
                        Course course1 = new Course(arr[0],arr[1],arr[2]);
                        courses.put(arr[0],course1);//课程名做键值，保存一个课程类
                    }
                }
                else{
                    System.out.println(arr[0] + " : course type & access mode mismatch");
                }
            }
            else if(str.matches("[0-9]{8} \\S{1,10} \\S{1,10} ([0-9]|[1-9][0-9]|100)")){
                //首先判断是选修方式的成绩输入  学号 姓名 课程 成绩
                String []arr = str.split(" ");
                //当出现重复课程需要忽略
                for(int i=0;i<chooseCourses.size();i++){
                    if(chooseCourses.get(i).student.id.equals(arr[0])
                            && chooseCourses.get(i).student.name.equals(arr[1])
                            && chooseCourses.get(i).course.name.equals(arr[2])){
                        break;
                    }
                }
                //实例化student，储存信息
                Student student = new Student(arr[0],arr[1]);//创建一个学生类
                students.put(arr[0],student);//把student储存到hashmap里面//学号做键值，保存学生类
                String classID = arr[0].substring(0,6);
                if(!classes.containsKey(classID)){
                    Classroom aClass = new Classroom(classID);
                    classes.put(classID,aClass);//班号做键值，保存班级类
                    classes.get(classID).student = new HashMap<>();
                }
                classes.get(classID).student.put(arr[0],student);
                //接下来判断课是不是存在
                if(!courses.containsKey(arr[2])){//判断课程是否存在
                    System.out.println(arr[2] + " does not exist");
                    //如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出 课程名称+英文空格+"does not exist"
                    break;
                }
                else if(!courses.get(arr[2]).method.equals("考察")){//判断考察方式是否相同
                    System.out.println(arr[0] +" "+ arr[1] + " : access mode mismatch");
                    //如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
                    break;
                }
                else {
                    ReviewResults reviewResults = new ReviewResults(Integer.parseInt(arr[3]));//kao cha lei
                    ChoseCourse chooseCourse = new ChoseCourse(reviewResults,courses.get(arr[2]),student);//选课类
                    chooseCourses.add(chooseCourse);//动态数组
                }
            }
            else if(str.matches("[0-9]{8} \\S{1,10} \\S{1,10} ([0-9]|[1-9][0-9]|100) ([0-9]|[1-9][0-9]|100)")){
                //首先判断是必修方式的成绩输入  学号 姓名 课程 成绩 成绩
                String []arr = str.split(" ");
                //当出现重复课程需要忽略
                for(int i=0;i<chooseCourses.size();i++){
                    if(chooseCourses.get(i).student.id.equals(arr[0])
                            && chooseCourses.get(i).student.name.equals(arr[1])
                            && chooseCourses.get(i).course.name.equals(arr[2])){
                        break;
                    }
                }
                //实例化student，储存信息
                Student student = new Student(arr[0],arr[1]);//创建一个学生类
                String classID = arr[0].substring(0,6);//班级班号
                if(!classes.containsKey(classID)){
                    Classroom aClass = new Classroom(classID);
                    classes.put(classID,aClass);//班号做键值，保存班级类
                    classes.get(classID).student = new HashMap<>();
                }
                classes.get(classID).student.put(arr[0],student);
                students.put(arr[0],student);//把student储存到hashmap里面
                if(!courses.containsKey(arr[2])){//判断课程是否存在
                    System.out.println(arr[2] + " does not exist");
                    break;
                }
                else if(!courses.get(arr[2]).method.equals("考试")){//判断考察方式是否相同
                    System.out.println(arr[0] +" "+ arr[1] + " : access mode mismatch");
                    break;
                }
                else {
                    ExaminationResult examinationResult = new ExaminationResult(Integer.parseInt(arr[3]),Integer.parseInt(arr[4]));//kao shi  lei
                    ChoseCourse chooseCourse = new ChoseCourse(examinationResult,courses.get(arr[2]),student);//选课类
                    chooseCourses.add(chooseCourse);//动态数组加入
                }
            }
            //判断实验
            else if(str.matches("([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([4-9])( )((([0-9]|[1-9][0-9]|100)( ))+)([0-9]|[1-9][0-9]|100)")){
                //学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
                String []arr = str.split(" ");
                //当出现重复课程需要忽略
                for(int i=0;i<chooseCourses.size();i++){
                    if(chooseCourses.get(i).student.id.equals(arr[0])
                            && chooseCourses.get(i).student.name.equals(arr[1])
                            && chooseCourses.get(i).course.name.equals(arr[2])){
                        break;
                    }
                }
                //实例化student，储存信息
                Student student = new Student(arr[0],arr[1]);
                students.put(arr[0],student);//把student储存到hashmap里面//学号做键值，保存学生类
                String classID= arr[0].substring(0,6);//班级班号
                if(!classes.containsKey(classID)){
                    Classroom aClass = new Classroom(classID);
                    classes.put(classID,aClass);
                    classes.get(classID).student = new HashMap<>();
                }
                classes.get(classID).student.put(arr[0],student);
                if(!courses.containsKey(arr[2])){//判断课程是否存在
                    //如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：课程名称+英文空格+"does not exist"
                    System.out.println(arr[2] + " does not exist");
                    break;
                }
                else if(!courses.get(arr[2]).method.equals("实验")){//判断考察方式是否相同
                    //如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
                    System.out.println(arr[0] + " "+arr[1] + " : access mode mismatch");
                    break;
                }
                else if(arr.length-4!=Integer.parseInt(arr[3])){
                    System.out.println(arr[0] + " "+arr[1] + " : access mode mismatch");
                    break;
                }
                else {
                    ExperimentResults experimentResults = new ExperimentResults();//创建成绩类
                    for(int i = 4;i < arr.length;i++){
                        experimentResults.grade.add(Integer.valueOf(arr[i]));
                    }
                    ChoseCourse chooseCourse = new ChoseCourse(experimentResults,courses.get(arr[2]),student);//选课类
                    chooseCourses.add(chooseCourse);//动态数组
                }
            }

            else
                System.out.println("wrong format");
            str = input.nextLine();
        }
        //按照学号排序，并输出成绩
        TreeMap<String, Student> sortedMap = new TreeMap<>(students);
        //这行代码创建了一个名为sortedMap的TreeMap对象，并使用students作为参数进行初始化。
        // 在这里，假设students是一个实现了Map接口的集合，其中键是String类型，值是Student类型。
        //
        //在这行代码中，TreeMap会根据键的自然顺序进行排序，
        // 或者如果在创建TreeMap时提供了Comparator的话，
        // 会使用指定的Comparator进行排序。
        // 因此，这行代码将会把students集合中的元素按照键的顺序进行排序，
        // 并放入sortedMap中。
        // 值得注意的是，如果Student类没有实现Comparable接口或者在创建TreeMap时没有提供Comparator，
        // 那么在放入sortedMap时可能会抛出ClassCastException异常。
        List<String> keys = new ArrayList<String>(sortedMap.keySet());
        for(int i = 0;i < sortedMap.size();i++){
            String stu_id = keys.get(i);
            Student student = sortedMap.get(stu_id);
            int SumGrade = 0;
            int KeMu = 0;
            for(int j = 0;j<chooseCourses.size();j++){
                if(stu_id.equals(chooseCourses.get(j).student.id)){
                    SumGrade = SumGrade + chooseCourses.get(j).score.getGrade();
                    KeMu++;
                }
            }
            if(KeMu == 0){
                System.out.println(student.id+" "+student.name+" did not take any exams");
                break;
            }
            int averageGrade = SumGrade/KeMu;
            //学生课程总成绩平均分按学号由低到高排序输出
            //
            //格式：学号+英文空格+姓名+英文空格+总成绩平均分
            System.out.println(stu_id + " " + student.name + " " + averageGrade);
        }
        // 创建中文比较器
        //这段代码定义了一个用于比较字符串的中文比较器（chineseComparator）。它实现了Comparator接口，并重写了compare方法。
        //
        //在compare方法中，使用了Collator类来进行字符串的比较。Collator类是一个用于执行字符串排序和比较的工具类。通过调用Collator.getInstance(Locale.CHINA)方法，获取一个针对中文环境的Collator实例。
        //
        //然后，调用collator的compare方法，将两个字符串o1和o2进行比较，返回一个整数值。如果o1排在o2之前，则返回负数；如果o1排在o2之后，则返回正数；如果o1和o2相等，则返回0。
        //
        //这样，通过使用这个中文比较器，可以实现对字符串进行中文排序。
        Comparator<String> chineseComparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                Collator collator = Collator.getInstance(Locale.CHINA);
                return collator.compare(o1, o2);
            }
        };
        // 将哈希映射中的所有键存储到列表中并按照中文比较器排序
        List<String> sortedKeys = new ArrayList<>(courses.keySet());
        Collections.sort(sortedKeys, chineseComparator);
        // 创建新的有序哈希映射
        Map<String, Course> resultMap = new LinkedHashMap<>();
        // 将排序后的键值对存储到新映射中
        for (String key : sortedKeys) {
            Course value = courses.get(key);
            resultMap.put(key, value);
        }
        // 输出新映射中的所有键值对
        for (String key : resultMap.keySet()) {
            Course course = resultMap.get(key);
            int count = 0 ,count1 = 0,SumGrade = 0, FinalGrade = 0, DailyGrade = 0;
            int Flag = -1;//判断是考试还是考察
            for(int i = 0;i < chooseCourses.size();i++){
                if(key.equals(chooseCourses.get(i).course.name)){
                    if(course.character.equals("必修")){
                        Flag = 0;//表示为考试
                        SumGrade = SumGrade + chooseCourses.get(i).score.getGrade();
                        if(chooseCourses.get(i).score instanceof ExaminationResult){
                            FinalGrade = FinalGrade + ((ExaminationResult) chooseCourses.get(i).score).FinalGrade;
                            DailyGrade = DailyGrade +((ExaminationResult) chooseCourses.get(i).score).DailyGrade;
                            count++;
                            count1++;
                        }
                    }
                    if(chooseCourses.get(i).course.character.equals("选修")){
                        SumGrade = SumGrade + chooseCourses.get(i).score.getGrade();
                        if(chooseCourses.get(i).course.method.equals("考试")) {
                            Flag = 0;//表示为考试
                            if (chooseCourses.get(i).score instanceof ExaminationResult) {
                                FinalGrade = FinalGrade + ((ExaminationResult) chooseCourses.get(i).score).FinalGrade;
                                DailyGrade = DailyGrade + ((ExaminationResult) chooseCourses.get(i).score).DailyGrade;
                                count++;
                                count1++;
                            }
                        }

                        if(chooseCourses.get(i).course.method.equals("考察")){
                            //x的值没有变，表示为考察
                            Flag = 2;
                            FinalGrade = FinalGrade + chooseCourses.get(i).score.getGrade();
                            count++;
                        }
                    }

                    //实验
                    if(chooseCourses.get(i).course.method.equals("实验")){
                        Flag = 1;//表示为实验
                        SumGrade = SumGrade + chooseCourses.get(i).score.getGrade();
                        count++;
                    }
                }
            }
            if(Flag == -1){
                System.out.println(course.name+" has no grades yet");
            }
            if(Flag == 0){//考试
                System.out.println(key + " " + DailyGrade/count1 +" " + FinalGrade/count + " " + SumGrade/count);
            }
            if(Flag == 1){//实验
                System.out.println(key + " " + SumGrade/count);
            }
            if(Flag == 2){
                System.out.println(key + " " + FinalGrade/count + " " + SumGrade/count);
            }
        }
        //给班级排序
        TreeMap<String, Classroom> classMap = new TreeMap<>(classes);
        List<String> classNums = new ArrayList<String>(classMap.keySet());
        for(int i = 0;i < classMap.size();i++){
            String num = classNums.get(i);
            Classroom classs = classMap.get(num);
            int SumGrade = 0;
            int count = 0;
            for(int j = 0;j<chooseCourses.size();j++){
                if(num.equals(chooseCourses.get(j).student.id.substring(0,6))){
                    SumGrade = SumGrade + chooseCourses.get(j).score.getGrade();
                    count++;
                }
            }
            if(count == 0){
                System.out.println(classs.classID+" has no grades yet");
                break;
            }
            int averageGrade = SumGrade/count;
            System.out.println(num + " " + averageGrade);
        }

    }
}
class ChoseCourse{//选课类
    ChoseCourse(Score score,Course course,Student student){
        this.score = score;
        this.course = course;
        this.student = student;
    }
    Score score;
    Course course;
    Student student;
}
abstract class Score{//成绩抽象类
    abstract int getGrade();//计算成绩/*舍弃小数*/
}
class ExaminationResult extends Score {//考试成绩
    ExaminationResult(int DailyGrade,int FinalGrade){
        this.DailyGrade = DailyGrade;
        this.FinalGrade = FinalGrade;
    }
    int DailyGrade;//平时成绩
    int FinalGrade;//期末成绩

    int getGrade(){//重写方法
        return(int) (FinalGrade*0.7 + DailyGrade*0.3);
    }
}
class ReviewResults extends Score{//考察成绩
    ReviewResults(int FinalGrade){
        this.FinalGrade = FinalGrade;
    }
    int FinalGrade;//期末成绩
    int getGrade(){
        return FinalGrade;//期末成绩
    }
}
class ExperimentResults extends Score{//实验成绩
    ArrayList<Integer> grade = new ArrayList<>();//实验成绩

    int getGrade(){
        int SumGrade = 0;//实验总成绩
        int count = 0;
        for (int i = 0 ;i<grade.size() ;i++){
            SumGrade = SumGrade+grade.get(i);
            count++;
        }
        return (int)(SumGrade / count*1.0);//求平均成绩
    }
}
class Course{
    Course(String name, String character,String method){
        this.name = name;
        this.character = character;
        this.method = method;
    }
    String name;//课程名
    String character;//必修选修实验
    String method;//考试考察实验
}

class Student{
    Student(String id, String name){
        this.id = id;
        this.name = name;
    }
    String id;//学号
    String name;//学生姓名
}

class Classroom{
    Classroom(String classID){
        this.classID =  classID;
    }
    String classID;
    HashMap<String,Student>student;
}