第三次blog-7-8次PTA题目集及期末考试总结

import java.util.*;

public class Main {
    public static void main(String[] args) {
        InputClass inputClass = new InputClass();
        inputClass.input();
        Output output = new Output(inputClass.getCourseSelections(),inputClass.getClassrooms());
        output.studentSumAverage();
        output.courseSumAverage(inputClass);
        output.classroomSumAverage(inputClass);
    }
}

//***输入类****//
class InputClass {
    //输入类包含选课和班级的动态数组
    ArrayList<CourseSelection> courseSelections;
    ArrayList<Classroom> classrooms;

    public InputClass() {
        this.courseSelections = new ArrayList<>(); // 初始化courseSelections
        this.classrooms = new ArrayList<>();
    }

    public void input() {
        int sum = 0;
        Scanner scanner = new Scanner(System.in);
        Course t1 = new Course("null","null","null");
        O:
        while (true) {
            String inputLine = scanner.nextLine();
            String[] inputs = inputLine.split(" ");
            if (inputLine.equals("end")){
                break O;
            } else if (inputLine.matches("^\\p{L}+\\s{1}\\p{L}+\\s{1}\\p{L}+$")) {
                //如果输入符合课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
                if(inputs[1].equals("必修")&&inputs[2].equals("考察")){
                    //如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配
                    System.out.println(inputs[0]+" : course type & access mode mismatch");
                } else if (inputs[1].equals("实验")&&!inputs[2].equals("实验")) {
                    System.out.println(inputs[0]+" : course type & access mode mismatch");
                } else if (!inputs[1].equals("实验")&&inputs[2].equals("实验")) {
                    System.out.println(inputs[0]+" : course type & access mode mismatch");
                } else{
                    Course newcourse = new Course(inputs[0], inputs[1], inputs[2]);
                    Score newscore = new ExperientScore(0,0);

                    CourseSelection courseSelection = new CourseSelection();
                    //输入的课程名称、课程性质和考核方式赋给courseSelection对象的course属性
                    courseSelection.setCourse(newcourse);
                    courseSelection.setScore(newscore);
                    this.courseSelections.add(courseSelection);//将该courseSelection对象添加进动态数组courseSelections中
                }
            } else if (inputLine.matches("^\\d+\\s{1}\\p{L}+\\s{1}\\p{L}+\\s{1}\\d+\\s{1}\\d+$")) {
                //如果输入符合课程信息格式：学号0+英文空格+姓名1+英文空格+课程名称2+英文空格+平时成绩3+英文空格+期末成绩4
                if(findcourseByCourseName(inputs[2]).equals("null")){
                    System.out.println(inputs[0]+" "+inputs[1]+" "+" :"+inputs[2]+" does not exist");
                }else{
                    Student newstudent = new Student(inputs[0],inputs[1]);
                    Course newcourse = new Course(inputs[2],findpropertyByCourseName(inputs[2]),findevaluationMethodByCourseName(inputs[2]));
                    String classNumber = newstudent.getStudentId().substring(0, 6);
                    Classroom classroom = findClassroom(classNumber);CourseSelection courseSelection = new CourseSelection();

                    courseSelection.setStudent(newstudent);
                    //先默认为考察方式
                    Score newscore = new AssessmentScore(Double.parseDouble(inputs[3]),Double.parseDouble(inputs[4]));
                    //如果为考试方式，更改
                    if(findevaluationMethodByCourseName(inputs[2]).equals("考试")){
                        Score newscore0 = new ExamScore(Double.parseDouble(inputs[3]),Double.parseDouble(inputs[4]));
                        newscore = newscore0;
                    }
                    courseSelection.setCourse(newcourse);
                    courseSelection.setScore(newscore);
                    this.courseSelections.add(courseSelection);
                    if (classroom != null) {
                        classroom.addStudent(newstudent);
                    } else {
                        Classroom newClassroom = new Classroom(classNumber);
                        classrooms.add(newClassroom);
                        newClassroom.addStudent(newstudent);
                    }
                }
            }
            else if (inputLine.matches("^\\d+\\s{1}\\p{L}+\\s{1}\\p{L}+\\s{1}\\d+$")) {
                //如果输入符合课程信息格式：学号0+英文空格+姓名1+英文空格+课程名称2+英文空格+期末成绩3
                if(findcourseByCourseName(inputs[2]).equals("null")){
                    System.out.println(inputs[0]+" "+inputs[1]+" "+" :"+inputs[2]+" does not exist");
                }else{
                    Student newstudent = new Student(inputs[0],inputs[1]);
                    Course newcourse = new Course(inputs[2],findpropertyByCourseName(inputs[2]),findevaluationMethodByCourseName(inputs[2]));
                    String classNumber = newstudent.getStudentId().substring(0, 6);
                    Classroom classroom = findClassroom(classNumber);CourseSelection courseSelection = new CourseSelection();

                    courseSelection.setStudent(newstudent);
                    //先默认为考察方式
                    Score newscore = new AssessmentScore(0.0,Double.parseDouble(inputs[3]));
                    //如果为考试方式，更改
                    if(findevaluationMethodByCourseName(inputs[2]).equals("考试")){
                        Score newscore0 = new ExamScore(0.0,Double.parseDouble(inputs[3]));
                        newscore = newscore0;
                    }
                    courseSelection.setCourse(newcourse);
                    courseSelection.setScore(newscore);
                    this.courseSelections.add(courseSelection);
                    if (classroom != null) {
                        classroom.addStudent(newstudent);
                    } else {
                        Classroom newClassroom = new Classroom(classNumber);
                        classrooms.add(newClassroom);
                        newClassroom.addStudent(newstudent);
                    }
                }
            }else if (findpropertyByCourseName(inputs[2]).equals("实验") && Integer.parseInt(inputs[3])>=4 && Integer.parseInt(inputs[3])<= 9) {
                if(findcourseByCourseName(inputs[2]).equals("null")){
                    System.out.println(inputs[0]+" "+inputs[1]+" "+" :"+inputs[2]+" does not exist");
                }else{
                    Student newstudent = new Student(inputs[0], inputs[1]);
                    Course newcourse = new Course(inputs[2], findpropertyByCourseName(inputs[2]), findevaluationMethodByCourseName(inputs[2]));
                    String classNumber = newstudent.getStudentId().substring(0, 6);
                    Classroom classroom = findClassroom(classNumber);
                    CourseSelection courseSelection = new CourseSelection();
                    courseSelection.setStudent(newstudent);
                    Score newscore = new ExperientScore(0, 0);
                    if( inputs.length == 4+Integer.parseInt(inputs[3])) {
                        //实验课程成绩信息包括：学号0、姓名1、课程名称2、实验次数3、每次成绩实验次数至少4次，不超过9次
                        //存储实验次数
                        int counttimes = Integer.parseInt(inputs[3]);
                        double sum0 = 0;
                        for (int i = 1; i <= counttimes; i++) {
                            sum0 += Integer.parseInt(inputs[i + 3]);
                        }//求实验总成绩
                        sum = (int) Math.floor(sum0 / counttimes);
                        newscore = new ExperientScore(0, sum);
                        courseSelection.setCourse(newcourse);
                        courseSelection.setScore(newscore);
                        this.courseSelections.add(courseSelection);
                        if (classroom != null) {
                            classroom.addStudent(newstudent);
                        } else {
                            Classroom newClassroom = new Classroom(classNumber);
                            classrooms.add(newClassroom);
                            newClassroom.addStudent(newstudent);
                        }
                    }else{
                        System.out.println(inputs[0]+" "+inputs[1]+" : access mode mismatch");
                        courseSelection.setCourse(newcourse);
                        courseSelection.setScore(newscore);
                        this.courseSelections.add(courseSelection);
                        if (classroom != null) {
                            classroom.addStudent(newstudent);
                        } else {
                            Classroom newClassroom = new Classroom(classNumber);
                            classrooms.add(newClassroom);
                            newClassroom.addStudent(newstudent);
                        }
                    }
                }
            } else{
                System.out.println("wrong format");
            }
        }
    }
    //以下可以根据遍历选课数组,找到指定课程所含的课程性质（选修/必修）
    public String findcourseByCourseName(String courseName) {
        for (CourseSelection courseSelection : courseSelections) {
            if (courseSelection.getCourse().getName().equals(courseName)) {
                return courseSelection.getCourse().getName();
            }
        }
        return "null";//未找到该课程，返回空值
    }
    public Course findcourseByCourseName0(String courseName) {
        for (CourseSelection courseSelection : courseSelections) {
            if (courseSelection.getCourse().getName().equals(courseName)) {
                return courseSelection.getCourse();
            }
        }
        return null;//未找到该课程，返回空值
    }
    //以下可以根据遍历选课数组,找到指定课程所含的课程性质（选修/必修）
    public String findpropertyByCourseName(String courseName) {
        for (CourseSelection courseSelection : courseSelections) {
            if (courseSelection.getCourse().getName().equals(courseName)) {
                return courseSelection.getCourse().getProperty();
            }
        }
        return "null";//未找到该课程，返回空值
    }
    //以下可以根据遍历选课数组,找到指定课程所含的考试方式（考试/考察）
    public String findevaluationMethodByCourseName(String courseName) {
        for (CourseSelection courseSelection : courseSelections) {
            if (courseSelection.getCourse().getName().equals(courseName)) {
                return courseSelection.getCourse().getEvaluationMethod();
            }
        }
        return null;//未找到该课程，返回空值
    }
    public Classroom findClassroom(String classNumber) {
        for (Classroom classroom : classrooms) {
            if (classroom.getClassNumber().equals(classNumber)) {
                return classroom;
            }
        }
        return null;
    }
    //以下可以根据遍历选课数组，找到指定id学生此时的总成绩
    public Double findScoreByStudentName(String StudentId) {
        for (CourseSelection courseSelection : courseSelections) {
            if(courseSelection.getStudent()!=null)
                if (courseSelection.getStudent().getStudentId().equals(StudentId)) {
                    return courseSelection.getScore().calculateTotalGrade();
                }
        }return 0.0;
    }
    public ArrayList<CourseSelection> getCourseSelections() {
        return courseSelections;
    }

    public ArrayList<Classroom> getClassrooms() {
        return classrooms;
    }
}

class Output{
    ArrayList<CourseSelection> courseSelections;
    ArrayList<Classroom> classrooms;
    public Output(ArrayList<CourseSelection> courseSelections,ArrayList<Classroom> classrooms){
        this.courseSelections = courseSelections;
        this.classrooms = classrooms;
    }
    public void output(){

    }
    InputClass t = new InputClass();
    //****计算并输出每个学生所有课程总成绩的平均分****//
    public void studentSumAverage() {
        HashMap<String, Double> studentGrades = new HashMap<>();
        HashMap<String, String> studentNames = new HashMap<>();

        for (CourseSelection courseSelection : courseSelections) {
            Student student = courseSelection.getStudent();
            if (student != null) {
                Score score = courseSelection.getScore();
                if (score != null) {
                    double totalGrade = score.calculateTotalGrade();
                    String studentId = student.getStudentId();
                    String name = student.getName();

                    if (studentGrades.containsKey(studentId)) {
                        double sum = studentGrades.get(studentId) + totalGrade;
                        studentGrades.put(studentId, sum);
                    } else {
                        studentGrades.put(studentId, totalGrade);
                        studentNames.put(studentId, name);
                    }
                }
            }
        }
        TreeMap<String, Double> sortedGrades = new TreeMap<>(studentGrades);
        for (String studentId : sortedGrades.keySet()) {
            double grade = sortedGrades.get(studentId);
            double average = grade / courseCountForStudent(studentId);  // 计算平均成绩
            String name = studentNames.get(studentId);
            if ((int) Math.floor(average) == 0)
                System.out.println(studentId + " " + name + " did not take any exams");
            else
                System.out.println(studentId + " " + name + " " + (int) Math.floor(average));
        }
        /*//System.out.println(studentGrades.get("20201103"));
        for (String studentId : studentGrades.keySet()) {//

            double grade = studentGrades.get(studentId);
            double average = grade / courseCountForStudent(studentId);  // 计算平均成绩
            String name = studentNames.get(studentId);
            if((int)Math.floor(average) == 0)
                System.out.println(studentId + " " + name + " did not take any exams");
            else
            System.out.println(studentId + " " + name + " " + (int)Math.floor(average));
        }*/
    }
    // 辅助方法，用于计算学生选课数目
    private int courseCountForStudent(String studentId) {
        int count = 0;
        for (CourseSelection courseSelection : courseSelections) {
            Student student = courseSelection.getStudent();
            if (student != null && student.getStudentId().equals(studentId)) {
                count++;
            }
        }
        return count;
    }
    //****计算并输出每个课程总成绩的平均分****//
    public void courseSumAverage(InputClass t) {
        HashMap<String, List<Double>> courseScoresMap = new HashMap<>(); // 存放每门课程的成绩列表

        // 遍历 courseSelections
        for (CourseSelection selection : courseSelections) {
            Course course = selection.getCourse();
            if (selection.getCourse() != null) {
                String courseName = selection.getCourse().getName(); // 获取课程名
                double regularScore = (int)Math.floor(selection.getScore().getRegularScore()); // 获取平时成绩
                double finalScore = (int)Math.floor(selection.getScore().getFinalScore()); // 获取期末成绩
                double totalGrade = (int)Math.floor(selection.getScore().calculateTotalGrade()); // 获取总成绩
                //System.out.println(courseName+totalGrade);
                if(totalGrade == 0)
                    continue;
                List<Double> scores = new ArrayList<>();
                //System.out.println(courseName+":"+totalGrade);
                scores.add(regularScore);
                scores.add(finalScore);
                scores.add(totalGrade);

                if (selection.getStudent() == null && selection.getScore().calculateTotalGrade() == 0) {
                    //courseScoresMap.put(courseName, scores);
                    //System.out.println(courseName+"?");
                } else {
                    if (courseScoresMap.containsKey(courseName)) {
                        List<Double> existingScores = courseScoresMap.get(courseName);
                        // 累加新的平时成绩、期末成绩和总成绩
                        existingScores.set(0, existingScores.get(0) + regularScore); // 平时成绩
                        existingScores.set(1, existingScores.get(1) + finalScore); // 期末成绩
                        existingScores.set(2, existingScores.get(2) + totalGrade); // 总成绩
                        //System.out.println(courseName+":::"+existingScores.get(2)+":;"+totalGrade);
                        t.findcourseByCourseName0(courseName).setCount(1);
                    } else {
                        courseScoresMap.put(courseName, scores);
                    }
                }
            }
        }

        TreeMap<String, List<Double>> sortedCourseScoresMap = new TreeMap<>(new Comparator<String>() {
            @Override
            public int compare(String courseName1, String courseName2) {
                return courseName1.compareTo(courseName2);
            }
        });
        sortedCourseScoresMap.putAll(courseScoresMap);

        for (Map.Entry<String, List<Double>> entry : sortedCourseScoresMap.entrySet()) {
            String courseName = entry.getKey();
            List<Double> scores = entry.getValue();
            int count = t.findcourseByCourseName0(courseName).getCount();
            double regularScoreSum = scores.get(0);
            double finalScoreSum = scores.get(1);
            double totalGradeSum = scores.get(2);
            double regularScoreAvg = regularScoreSum / (count+1);
            double finalScoreAvg = finalScoreSum / (count+1);
            double totalGradeAvg = totalGradeSum / (count+1);
            //System.out.println(courseName+entry.getValue()+"!");

            if (regularScoreSum > 0 || finalScoreSum > 0 || totalGradeSum > 0) {
                if (t.findevaluationMethodByCourseName(courseName).equals("考试"))
                    System.out.println(courseName + " " + (int) Math.floor(regularScoreAvg) + " " + (int) Math.floor(finalScoreAvg) + " " + (int) Math.floor(totalGradeAvg));
                else if ((t.findevaluationMethodByCourseName(courseName).equals("考察")))
                    System.out.println(courseName + " " + (int) Math.floor(finalScoreAvg) + " " + (int) Math.floor(totalGradeAvg));
                else if ((t.findevaluationMethodByCourseName(courseName).equals("实验")))
                    System.out.println(courseName + " " + (int) Math.floor(totalGradeAvg));
            } else {
                System.out.println(courseName + " has no grades yet");
            }
        }
    }
    /*public void courseSumAverage(InputClass t) {
        HashMap<String, double[]> courseScoresMap = new HashMap<>();

        // 遍历 courseSelections
        for (CourseSelection selection : courseSelections) {
            Course course = selection.getCourse();
            if (selection.getCourse()!=null){
                //System.out.println(selection.getCourse().getName());
                //如果此时课程和学生都不为空
                String courseName = selection.getCourse().getName();//获取课程名
                double regularScore = selection.getScore().getRegularScore();//获取平时成绩
                double finalScore = selection.getScore().getFinalScore();//获取期末成绩
                double totalGrade = selection.getScore().calculateTotalGrade();//获取总成绩
                double[] scores = {regularScore, finalScore, totalGrade};
                //System.out.println(selection.getCourse().getName()+totalGrade);
                if(selection.getStudent()==null && selection.getScore().calculateTotalGrade()==0){
                    courseScoresMap.put(courseName, scores);
                }else{
                    if (courseScoresMap.containsKey(courseName)) {
                        double[] existingScores = courseScoresMap.get(courseName);
                        double[] count = courseScoresMap.get(courseName);
                        // 累加新的平时成绩、期末成绩和总成绩
                        existingScores[0] += (int)Math.floor(scores[0]);  // 平时成绩
                        existingScores[1] += (int)Math.floor(scores[1]);  // 期末成绩
                        double s = 0;
                        s = existingScores[2];
                        existingScores[2] += (int)Math.floor(scores[2]);  // 总成绩
                        // 平均计算
                        //如果累加上不等于累加前的值，执行
                        if(s!=0) {
                            existingScores[0] /= 2;  // 平时成绩
                            existingScores[1] /= 2;  // 期末成绩
                            existingScores[2] /= 2;  // 总成绩
                        }
                        //System.out.println(courseName+existingScores[2]);
                        // 更新 HashMap
                        courseScoresMap.put(courseName, existingScores);
                    } else {
                        courseScoresMap.put(courseName, scores);
                    }
                }}
        }
        TreeMap<String, double[]> sortedCourseScoresMap = new TreeMap<>(new Comparator<String>() {
            @Override
            public int compare(String courseName1, String courseName2) {
                return courseName1.compareTo(courseName2);
            }
        });
        sortedCourseScoresMap.putAll(courseScoresMap);
        sortedCourseScoresMap.putAll(courseScoresMap);
        HashMap<String, double[]> result = courseScoresMap;
        for (Map.Entry<String, double[]> entry : sortedCourseScoresMap.entrySet()) {
            boolean hasGrades = false;
            double[] scores = entry.getValue();
            for (double score : scores) {
                if (score > 0) {
                    hasGrades = true;
                    break;
                }
            }
            String courseName = entry.getKey();
            //System.out.println(courseName+" "+scores[0]+" "+scores[1]+" "+scores[2]);

            if (hasGrades) {
                hasGrades = false;
                if (t.findevaluationMethodByCourseName(courseName).equals("考试"))
                    System.out.println(courseName + " " + (int) Math.floor(scores[0]) + " " + (int) Math.floor(scores[1]) + " " + (int) Math.floor(scores[2]));
                else if ((t.findevaluationMethodByCourseName(courseName).equals("考察")))
                    System.out.println(courseName + " " + (int) Math.floor(scores[1]) + " " + (int) Math.floor(scores[2]));
                else if ((t.findevaluationMethodByCourseName(courseName).equals("实验")))
                    System.out.println(courseName + " " + (int) Math.floor(scores[2]));
            }else {
                System.out.println(courseName +" has no grades yet");
            }
        }

        // 输出结果
    }*/
    public class ClassroomComparator implements Comparator<Classroom> {
        @Override
        public int compare(Classroom c1, Classroom c2) {
            return Integer.parseInt(c1.getClassNumber()) - Integer.parseInt(c2.getClassNumber());
        }
    }

    public void classroomSumAverage(InputClass t) {
        // 对classrooms列表按班级编号排序
        Collections.sort(classrooms, new ClassroomComparator());

        for (Classroom classroom : classrooms) {
            double averageScore = classroom.getAverageScore(t);
            if ((int) Math.floor(averageScore) == 0) {
                System.out.println(classroom.getClassNumber() + " has no grades yet");
            } else {
                System.out.println(classroom.getClassNumber() + " " + (int) Math.floor(averageScore));
            }
        }
    }
    /*public void classroomSumAverage(InputClass t) {
        for (Classroom classroom : classrooms) {
            double averageScore = classroom.getAverageScore(t);
            if((int)Math.floor(averageScore) == 0)
                System.out.println(classroom.getClassNumber()+" has no grades yet");
            else{
            System.out.println(classroom.getClassNumber()+" "+(int)Math.floor(averageScore));
        }
    }
    }*/
}

class CourseSelection {
    private Course course;       // 课程
    private Student student;     // 学生
    private Score score;         // 成绩

    public CourseSelection() {

    }

    public Course getCourse() {
        return course;
    }

    public void setCourse(Course course) {
        this.course = course;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public Score getScore() {
        return score;
    }

    public void setScore(Score score) {
        this.score = score;
    }
}
class Student {
    private String studentId;
    private String name;

    // 构造方法
    public Student(String studentId, String name) {
        this.studentId = studentId;
        this.name = name;
    }

    // 学号属性的 getter 和 setter 方法
    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    // 姓名属性的 getter 和 setter 方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
class Course {
    private String name;
    private String property;
    private String evaluationMethod;
    private int count;

    // 构造方法
    public Course(String name, String property, String evaluationMethod) {
        this.name = name;
        this.property = property;
        this.evaluationMethod = evaluationMethod;
    }

    // 课程名称属性的 getter 和 setter 方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count += count;
    }

    // 课程性质属性的 getter 和 setter 方法
    public String getProperty() {
        return property;
    }

    public void setProperty(String property) {
        this.property = property;
    }

    // 考核方式属性的 getter 和 setter 方法
    public String getEvaluationMethod() {
        return evaluationMethod;
    }

    public void setEvaluationMethod(String evaluationMethod) {
        this.evaluationMethod = evaluationMethod;
    }
}

//****成绩的抽象类和抽象方法****///
abstract class Score {
    protected double regularScore;
    protected double finalScore;

    public Score(double regularScore,double finalScore) {
        this.regularScore = regularScore;
        this.finalScore = finalScore;
    }
    public abstract double getRegularScore();

    public abstract double getFinalScore();

    public abstract double calculateTotalGrade();
}

class ExperientScore extends Score{
    public ExperientScore(double regularScore, double finalScore) {
        super(regularScore,finalScore);//将传入的finalScore值传递给父类，以便在父类中进行适当的初始化。
    }
    @Override
    public double getRegularScore() {
        return regularScore;
    }
    @Override
    public double getFinalScore() {
        return finalScore;
    }

    @Override
    public double calculateTotalGrade() {
        return finalScore;
    }
}
//*****考试成绩，由平时成绩和期末成绩加权计算******//
class ExamScore extends Score {

    public ExamScore(double regularScore, double finalScore) {
        super(regularScore,finalScore);//将传入的finalScore值传递给父类，以便在父类中进行适当的初始化。
    }
    @Override
    public double getRegularScore() {
        return regularScore;
    }
    @Override
    public double getFinalScore() {
        return finalScore;
    }

    @Override
    public double calculateTotalGrade() {
        double totalGrade = regularScore * 0.3 + finalScore * 0.7;
        return totalGrade;
    }
}


//******考察成绩，等于期末成绩******//
class AssessmentScore extends Score {
    public AssessmentScore(double regularScore,double finalScore) {
        super(regularScore,finalScore);
    }
    @Override
    public double getRegularScore() {
        return regularScore;
    }
    @Override
    public double getFinalScore() {
        return finalScore;
    }
    @Override
    public double calculateTotalGrade() {
        return finalScore;
    }
}


class Classroom {
    private String classNumber; // 班级号
    private ArrayList<Student> studentList; // 学生列表

    public Classroom(String classNumber) {
        this.classNumber = classNumber;
        this.studentList = new ArrayList<>();
    }

    // 获取班级号
    public String getClassNumber() {
        return classNumber;
    }

    // 设置班级号
    public void setClassNumber(String classNumber) {
        this.classNumber = classNumber;
    }

    // 获取学生列表
    public ArrayList<Student> getStudentList() {
        return studentList;
    }

    public void addStudent(Student student) {
        studentList.add(student);
    }
    public double getAverageScore(InputClass t) {
        // 计算班级所有学生总成绩的平均值
        double sumScores = 0;
        for (Student student : studentList) {
            double score = t.findScoreByStudentName(student.getStudentId());
            sumScores += score;
        }

        return (int)Math.floor(sumScores / studentList.size());
    }

}