Java题目集7~11的总结

一、前言

第八次作业

主要涉及的知识点有类实现Comparable/Comparable<>接口类中重写compareTo(Object o)方法，使用Collections.sort()进行排序以及利用Comparator进行排序。这次只有一题，但难度还是比较大的，是写课程成绩统计程序-1。

第九次作业

主要涉及的知识点有Map和Set，用到了hashmap和hashset以及treemap，其中对于Map类：可以使用 get(key) 方法来获取 key 对应的 value，可以使用 remove(key) 方法来删除 key 对应的键值对(key-value)计算， Map 中的元素数量可以使用 size() 方法，可以使用 for-each 来迭代 Map 中的元素。题量很少只有一题，难度也适中。

第十次作业

主要涉及的知识点有HashMap排序和检索，以及多态。题量有4题，除了第三题课程成绩统计程序-2有难度外，其他三题都比较好写。

第十一次作业

主要涉及的知识点有ArrayList的排序和Stack类，对于Stack类： empty() 测试堆栈是否为空；peek( )查看堆栈顶部的对象，但不从堆栈中移除它； pop( )移除堆栈顶部的对象，并作为此函数的值返回该对象；push(Object element)把项压入堆栈顶部。题量有五题，难度中等，除了课程成绩统计程序-3。

二、设计与分析

题目集8

7-1 课程成绩统计程序-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）成绩平均分只取整数部分，小数部分丢弃

参考类图：

输入样例1:

仅有课程。例如：

java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end

 

输出样例1:

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

java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet

 

输入样例2:

单门考试课程 单个学生。例如：

java 必修 考试
20201103 张三 java 20 40
end

 

输出样例2:

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

20201103 张三 34
java 20 40 34
202011 34

 

输入样例3:

单门考察课程 单个学生。例如：

java 选修 考察
20201103 张三 java 40
end

 

输出样例3:

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

20201103 张三 40
java 40 40
202011 40

 

输入样例4:

考试课程 单个学生 不匹配的考核方式。例如：

java 必修 考试
20201103 张三 java 20
end

 

输出样例4:

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

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet

 

输入样例5:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

java 必修 考察
20201103 张三 java 40
end

 

输出样例5:

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

java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet

 

输入样例6:

单门课程，多个学生。例如：

java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end

 

输出样例6:

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

20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53

 

输入样例7:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end

 

输出样例7:

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

20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73

 

输入样例8:

单门课程，单个学生，成绩越界。例如：

数据结构 选修 考察
20201103 李四 数据结构 101
end

 

输出样例8:

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

wrong format
数据结构 has no grades yet

 

输入样例9:

多门课程，多个学生，多个成绩。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end

 

输出样例9:

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

20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72

 

代码长度限制

16 KB

时间限制

1000 ms

内存限制

64 MB

类图

 

 

 源码

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.util.Locale;
import java.text.Collator;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Data data = new Data();
        Scanner input = new Scanner(System.in);
        String information = "start";
        String courseInformation[] = null;
        String courseScoreInformation[] = null;
        int count = 0;
        while (!information.equals("end")) {
            information = input.nextLine();
            if (information.equals("end")) break;
            if (!(information.charAt(0) <= '9' && information.charAt(0) >= '0')) {
            courseInformation = information.split(" ");
            Course course = new Course(courseInformation[0],courseInformation[1],courseInformation[2]);
             if (searchCourse(courseInformation[0], data) == null) {
             data.getCourses().add(course);
             }
             course.setCourseSelects(data.getCourseSelects());
            
            } else {
                courseScoreInformation = information.split(" ");
                count ++;
                Student student = new Student(courseScoreInformation[0],courseScoreInformation[1]);  //学号和姓名
                if (searchStudent(courseScoreInformation[0],data) == null) {
                    data.getStudents().add(student);
                }
                if (courseScoreInformation.length == 5 && 
                        searchCourseSelect(searchCourse(courseScoreInformation[2], data), student, data) == null) {  //如果课程为考试
                    int usualScore = Integer.parseInt(courseScoreInformation[3]);
                    int finalScore = Integer.parseInt(courseScoreInformation[4]);
                    Score score = new ExamScore(usualScore,finalScore);
                    CourseSelect courseSelect = new CourseSelect(searchCourse(courseScoreInformation[2],data),student,score);
                    data.getCourseSelects().add(courseSelect);   
                    for (int i = 0; i < data.getCourseSelects().size(); i++) {
                        if (data.getCourseSelects().get(i).getStudent().getId().equals(student.getId())) {
                            student.getCourseSelects().add(courseSelect);
                        }
                    }
                }
                if (courseScoreInformation.length == 4 && 
                        searchCourseSelect(searchCourse(courseScoreInformation[2], data), student, data) == null) {  //如果课程为考察
                    int finalScore = Integer.parseInt(courseScoreInformation[3]);
                    Score score = new AccessScore(finalScore);
                    CourseSelect courseSelect = new CourseSelect(searchCourse(courseScoreInformation[2],data),student,score);
                    data.getCourseSelects().add(courseSelect);
                    for (int i = 0; i < data.getCourseSelects().size(); i++) {
                        if (data.getCourseSelects().get(i).getStudent().getId().equals(student.getId())) {
                            student.getCourseSelects().add(courseSelect);
                        }
                    }
                }
                if (searchClass(student.getClassId(),data) == null) {
                    Class studentClass = new Class(student.getClassId());
                    data.getClasses().add(studentClass);
                    studentClass.addStudent(student);
                }
                if (searchCourse(courseScoreInformation[2], data) == null) {
                    data.getCourses().get(count).getCourseSelects().add(searchCourseSelect(searchCourse(courseScoreInformation[2], data), student, data));
                }
            }
        }
        
        for (int i = 0; i < data.getClasses().size(); i++) {  //添加学生到班级中
           for (int j = 0; j < data.getStudents().size(); j++) {
            if (data.getClasses().get(i).hasStudent(data.getStudents().get(j))){
                data.getClasses().get(i).addStudent(data.getStudents().get(j));
            }
           }
        }
        
        Collections.sort(data.getStudents());
        Collections.sort(data.getClasses());
        Collections.sort(data.getCourses());
        
        for (int i = 0; i < data.getStudents().size(); i++) {
            if (data.getStudents().get(i).getId() == null ||data.getStudents().get(i).getName() == null) {
                System.out.println("wrong format");
            }
            if (data.getStudents().get(i) == null) return;
            System.out.println(data.getStudents().get(i).getId() + " " + data.getStudents().get(i).getName() + " " +
                    data.getStudents().get(i).getAverageScore());
        }
        
        for (int i = 0; i < data.getCourses().size(); i++) {
            if (data.getCourses().get(i) == null || data.getCourses().get(i).getCourseSelects() == null) return;
            if (data.getCourses().get(i).getAccessMethod().equals("考试")) {
                if(!data.getCourses().get(i).hasScore()) {
                    System.out.println(data.getCourses().get(i).getName() + " has no grades yet");
                    continue;
                }
                System.out.println(data.getCourses().get(i).getName() + " " + data.getCourses().get(i).getAverageUsualScore() + " " +
                    data.getCourses().get(i).getAverageFinalScore() + " " +
                    data.getCourses().get(i).getAverageTotalScore());
            }
            if (data.getCourses().get(i).getAccessMethod().equals("考察")) {
                if(!data.getCourses().get(i).hasScore()) {
                    System.out.println(data.getCourses().get(i).getName() + " has no grades yet");
                    continue;
                }
                System.out.println(data.getCourses().get(i).getName() + " " + data.getCourses().get(i).getAverageFinalScore() + " " +
                        data.getCourses().get(i).getAverageTotalScore());
                }
        }
        
        for (int i = 0; i < data.getClasses().size(); i++) {
            if(!data.getClasses().get(i).hasScore()) {
                System.out.println(data.getClasses().get(i).getClassId() + " has no grades yet");
                continue;
            }
            System.out.println(data.getClasses().get(i).getClassId() + " " + data.getClasses().get(i).getAverageScore());
        }
        
        
    }
        
        for (int i = 0; i < data.getCourses().size(); i++) {
            if (data.getCourses().get(i) == null || data.getCourses().get(i).getCourseSelects() == null) return;
            if (data.getCourses().get(i).getAccessMethod().equals("考试")) {
                if(!data.getCourses().get(i).hasScore()) {
                    System.out.println(data.getCourses().get(i).getName() + " has no grades yet");
                    continue;
                }
                System.out.println(data.getCourses().get(i).getName() + " " + data.getCourses().get(i).getAverageUsualScore() + " " +
                    data.getCourses().get(i).getAverageFinalScore() + " " +
                    data.getCourses().get(i).getAverageTotalScore());
            }
            if (data.getCourses().get(i).getAccessMethod().equals("考察")) {
                if(!data.getCourses().get(i).hasScore()) {
                    System.out.println(data.getCourses().get(i).getName() + " has no grades yet");
                    continue;
                }
                System.out.println(data.getCourses().get(i).getName() + " " + data.getCourses().get(i).getAverageFinalScore() + " " +
                        data.getCourses().get(i).getAverageTotalScore());
                }
        }
        
        for (int i = 0; i < data.getClasses().size(); i++) {
            if(!data.getClasses().get(i).hasScore()) {
                System.out.println(data.getClasses().get(i).getClassId() + " has no grades yet");
                continue;
            }
            System.out.println(data.getClasses().get(i).getClassId() + " " + data.getClasses().get(i).getAverageScore());
        }

       
        
        
        }
        
    }
    public static Course searchCourse(String courseName, Data data) {
        for (int i = 0; i < data.getCourses().size(); i++) {
            if (data.getCourses().get(i).getName().equals(courseName)) {
                return data.getCourses().get(i);
            }
        }
        return null;
    }
    
    public static Student searchStudent(String studentId, Data data) {
        for (int i = 0; i < data.getStudents().size(); i++) {
            if (data.getStudents().get(i).getId().equals(studentId)) {
                return data.getStudents().get(i);
            }
        }
        return null;
    }
    
    public static Class searchClass(String classId, Data data) {
        for (int i = 0; i < data.getClasses().size(); i++) {
            if (data.getClasses().get(i).getClassId().equals(classId)) {
                return data.getClasses().get(i);
            }
        }
        return null;
    }
    
    public static CourseSelect searchCourseSelect(Course course, Student student,Data data) {
        for (int i = 0; i < data.getCourseSelects().size(); i++) {
            if (data.getCourses().get(i).equals(course) && data.getStudents().get(i).equals(student)) {
                return data.getCourseSelects().get(i);
            }
        }
        return null;
    }

}

class AccessScore extends Score {  //考察成绩类
    private int finalScore;
    
    @Override
    public int getUsualScore() {
        return 0;
    }

    public AccessScore(int finalScore) {
        super();
        if (finalScore < 0 || finalScore >100) return;
        this.finalScore = finalScore;
    }

    public int getFinalScore() {
        return this.finalScore;
    }
    
    public int getTotalScore() {  //考察总成绩=期末成绩
        return this.finalScore;
    }
}

class Class implements Comparable<Class> {  //班级类
    private String classId = null;
    private ArrayList<Student> students = new ArrayList();

    
    public Class() {
        // TODO Auto-generated constructor stub
    }


    public Class(String classId) {
        super();
        this.classId = classId;
    }

    public String getClassId() {
        return classId;
    }


    public void setClassId(String classId) {
        this.classId = classId;
    }


    public ArrayList<Student> getStudents() {
        return students;
    }


    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }
    
    @Override
    public int compareTo(Class studentClass) {  //比较班级的班号，如果比该班级大返回1，小则返回-1，相等返回0
        // TODO Auto-generated method stub
        if (Integer.parseInt(classId) > Integer.parseInt(studentClass.classId)) {
            return 1;
        } else if (Integer.parseInt(classId) < Integer.parseInt(studentClass.classId)) {
            return -1;
        } else return 0;
    }
    
    public void addStudent(Student stu) {  //添加学生到班级里
        if (this.hasStudent(stu)) return;
        students.add(stu);
    }
    
    public boolean hasStudent(Student stu) {  //判断该班级是否该有学生
        for (int i = 0; i < students.size(); i++) {
            if (students.get(i).getClassId().equals(classId)) {
                return true;
            }
        }
        return false;
    }
    
    public boolean hasScore() {  //判断该班级是否有成绩
        return this.getAverageScore() != -1;
    }
    
    public int getAverageScore() {  //计算班级总成绩平均分
        int total = 0;
        for (int i = 0; i < this.students.size(); i ++) {
            total += this.students.get(i).getAverageScore();
        }
        if (this.students.size() == 0) return -1;
        return (int)((double)(total / this.students.size()));
    }
    
    
}

class Course implements Comparable<Course> {  //课程类
    
    private String name;  //课程名称
    private String courseType;  //课程性质
    private String accessMethod;  //课程考核方式
    private ArrayList<CourseSelect> courseSelects = new ArrayList();
    
    public Course() {
        // TODO Auto-generated constructor stub
    }

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

    public Course(String name, String courseType, String accessMethod) {
        super();
        this.name = name;
        this.courseType = courseType;
        this.accessMethod = accessMethod;
    }

    public Course(String name, String courseType, String accessMethod, ArrayList<CourseSelect> courseSelects) {
        super();
        
        this.name = name;
        this.courseType = courseType;
        this.accessMethod = accessMethod;
        this.courseSelects = courseSelects;
    }
    
    public String getName() {
        return name;
    }

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

    public String getCourseType() {
        return courseType;
    }

    public void setCourseType(String courseType) {
        this.courseType = courseType;
    }

    public String getAccessMethod() {
        return accessMethod;
    }

    public void setAccessMethod(String accessMethod) {
        this.accessMethod = accessMethod;
    }

    public ArrayList<CourseSelect> getCourseSelects() {
        return courseSelects;
    }

    public void setCourseSelects(ArrayList<CourseSelect> courseSelects) {
        this.courseSelects = courseSelects;
    }

    public int getAverageUsualScore() {  //计算单科平时成绩平均分
        int total = 0;
        for (int i = 0; i < courseSelects.size(); i++) {
            total += courseSelects.get(i).getScore().getUsualScore();
        }
        if (courseSelects.size() == 0) return -1;
        return (int)((double)(total / courseSelects.size()));
    }
    
    public int getAverageFinalScore() {  //计算单科期末考试平均分
        int total = 0;
        for (int i = 0; i < courseSelects.size(); i++) {
            total += courseSelects.get(i).getScore().getFinalScore();
        }
        if (courseSelects.size() == 0) return -1;
        return (int)((double)(total / courseSelects.size()));
    }
    
    public int getAverageTotalScore() {  //计算单科总成绩平均分
        int total = 0;
        for (int i = 0; i < courseSelects.size(); i++) {
            total += courseSelects.get(i).getScore().getTotalScore();
        }
        if (courseSelects.size() == 0) return -1;
        return (int)((double)(total / courseSelects.size()));
    }
    
    public boolean hasScore() {  //判断该课程是否有成绩
        return this.getAverageTotalScore() != -1;
    }

    @Override
    public int compareTo(Course course) {  //比较该课程名称的字符顺序，如果大返回1，小则返回-1，相等返回0
        // TODO Auto-generated method stub
        return Collator.getInstance(Locale.CHINA).compare(this.name, course.name); 

    }
    
}

 class CourseSelect {  //选课类
    private Course course;
    private Student student;
    private Score score;
    
    public CourseSelect(Course course, Student student, Score score) {
        super();
        this.course = course;
        this.student = student;
        this.score = score;
    }

    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 Data {  //数据类，存储数据
    private ArrayList<Course> courses = new ArrayList();
    private ArrayList<Student> students = new ArrayList();
    private ArrayList<Class> classes = new ArrayList();
    private ArrayList<CourseSelect> courseSelects = new ArrayList();
    
    public ArrayList<Course> getCourses() {
        return courses;
    }
    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }
    public ArrayList<Student> getStudents() {
        return students;
    }
    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }
    public ArrayList<Class> getClasses() {
        return classes;
    }
    public void setClasses(ArrayList<Class> classes) {
        this.classes = classes;
    }
    public ArrayList<CourseSelect> getCourseSelects() {
        return courseSelects;
    }
    public void setCourseSelects(ArrayList<CourseSelect> courseSelects) {
        this.courseSelects = courseSelects;
    }
    
    
    
}

class ExamScore extends Score {  //考试成绩类
    private int usualScore = -1;
    private int finalScore = -1;
    
    public ExamScore(int usualScore, int finalScore) {
        super();
        if (usualScore < 0 || usualScore >100) return;
        if (finalScore < 0 || finalScore >100) return;
        this.usualScore = usualScore;
        this.finalScore = finalScore;
    }

    @Override
    public int getUsualScore() {
        return this.usualScore;
    }

    public int getFinalScore() {
        return this.finalScore;
    }
    
    public int getTotalScore() {  //考试总成绩=平时成绩*0.3+期末成绩*0.7
        return (int)((double)(this.usualScore * 0.3 + this.finalScore * 0.7));
    }
}

abstract class Score {  //抽象分数类
    public abstract int getUsualScore();  //平时成绩
    public abstract int getFinalScore();  //期末成绩
    public abstract int getTotalScore();  //总成绩
    
    public Score() {
        // TODO Auto-generated constructor stub
    }

}
class Student implements Comparable<Student> {  //学生类
    private String id = null;  //学号
    private String name = null;  //姓名
    private ArrayList<CourseSelect> courseSelects = new ArrayList();  //选课
    
    public Student(String id, String name) {
        super();
        if (id.length() == 8) {
        this.id = id;
        } 
        if (name.length() < 10 && name.length() > 0) {
        this.name = name;
        }
        
    }
    
    public Student(String id, String name, ArrayList<CourseSelect> courseSelects) {
        super();
        this.id = id;
        this.name = name;
        this.courseSelects = courseSelects;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<CourseSelect> getCourseSelects() {
        return courseSelects;
    }

    public void setCourseSelects(ArrayList<CourseSelect> courseSelects) {
        this.courseSelects = courseSelects;
    }

    public String getClassId() {
        return this.id.substring(0, 6);
    }

    public boolean hasScore() {  //判断该学生是否有成绩
        return this.getAverageScore() != -1;
    }
    
    public int getAverageScore() {  //计算学生所有课程总成绩的平均分
        int total = 0;
        for (int i = 0; i < courseSelects.size(); i++) {
            total += courseSelects.get(i).getScore().getTotalScore();
        }
        if (courseSelects.size() == 0) return -1;
        return (int)((double)(total / courseSelects.size()));
    }

    @Override
    public int compareTo(Student student) {  //比较学生的学号，如果比该学生student大返回1，小则返回-1，相等返回0
        // TODO Auto-generated method stub
        if (Integer.parseInt(id) > Integer.parseInt(student.id)) {
            return 1;
        } else if (Integer.parseInt(id) < Integer.parseInt(student.id)) {
            return -1;
        } else return 0;
        
    }
    
    
    
}

分析

Score类为抽象类，AccessScore类和ExamScore类继承Score类，分别代表考察成绩和考试成绩两个类。类中的属性根据题目要求可以设计好。CourseSelect类、Class类、Course类和Student类设计方法同理。主方法主要创建了四个ArrayList数组。分别用来存储输入的课程信息、学生选课信息、成绩信息等，同时运用正则表达式匹配课程信息和成绩信息。在这题中，还使用了Comparable接口，在计算成绩之后，对ArrayList数组进行排序。但是我的主方法设计的不够完整，有很多缺陷，没有完全符合题目要求，因此也没有拿到很多分。

题目集9

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

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

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

输入格式:

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

输出格式:

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

输入样例:

在这里给出一组输入。例如：

//Test public method
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
exit

 

输出样例:

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

1	float
3	if
2	int
2	new
2	public
3	this
2	throw

 

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

源码

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    static Scanner input = new Scanner(System.in);
    public static void main(String[] args) {
        String code = StringConnection();
        if (NoSourceCodeinput(code)) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        Map<String, Integer> orderMap = sortMapByKey(matchKeyWords(splitCode(removeNote(removeString(code)))));
        orderMap.forEach((str, count) -> System.out.println(count + "\t" + str));
    }
    public static boolean NoSourceCodeinput(String code) {  //当未输入源码时，程序输出Wrong Format
        if (code == "") return true;    
        return false;
    }
    public static String removeNote(String code) {  //去除注释中的关键字
        return Pattern.compile("(/\\*([^*]|[\\r\\n]|(\\*+([^*/]|[\\r\\n])))*\\*+/|[ \\t]*//.*|\t@.*)").matcher(code).replaceAll("");
    }
    public static String removeString(String code) {  //去除字符串中的关键字
        return Pattern.compile("\"(.*[^\\\\]|)\"").matcher(code).replaceAll("");
    }
    public static String StringConnection() {  //将代码的每一个字符串一起连接起来成为新的字符串
        String code = "";
        String line = "";
        while (!(line = input.nextLine()).equals("exit")) {
            code = code.concat("\n").concat(line);
        }
        return code;
    }
    public static String[] splitCode(String code) {  //分割代码储存在一个数组中
         return code.split("\\s+|\\{|\\}|\\.|\\,|\\[|\\]|;|\\(|\\)");
    }
    public static HashMap<String, Integer> matchKeyWords(String[] code) {
        HashSet<String> keyWords = new HashSet<String>(); 
        keyWords.addAll(Arrays.asList("abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while、goto、const、true、false、null".split("、")));
        HashMap<String, Integer> matchKeyWords = new HashMap<String, Integer>();
        for (String str: code) {
            if (keyWords.contains(str)) {
                //如果hashMap中有此字符，则次数增1
                if (matchKeyWords.get(str) == null) {
                    matchKeyWords.put(str, 1);
                    continue;
                } 
                int count = matchKeyWords.get(str);
                count++;
                matchKeyWords.put(str, count);
            }
        }
        return matchKeyWords;
    }
     public static Map<String, Integer> sortMapByKey(HashMap<String, Integer> map) {  //当有统计数据时，关键字按照升序排列
            if (map == null || map.isEmpty()) return null;
            TreeMap<String, Integer> sortMap = new TreeMap<String, Integer>(new Comparator<String>() {
                public int compare(String obj1, String obj2) {
                    return obj1.compareTo(obj2);//升序排序
                }
            });
            sortMap.putAll(map);
            return sortMap;
        }
}

分析

主要考察了map和set的使用。我创建了几个方法，removeString（）来去除字符串中的关键字，removeNote()来去除注释中的关键字，stringConnection（）来连接字符串，splitCode（）来分割代码储存在一个数组里，最核心的方法是matchKeyWords（）匹配关键字和sortMapByKey（）将统计数据按升序排序。

题目集10

7-1 容器-HashMap-检索

输入多个学生的成绩信息，包括：学号、姓名、成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

使用HashMap存储学生信息，并实现根据学号的检索功能

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

以“end”为输入结束标志

end之后输入某个学号，执行程序输出该生的详细信息

输出格式:

输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩

如果没有查询到，则输出："The student "+查询的学号+" does not exist"

输入样例1:

在这里给出一组输入。例如：

20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20201116

 

输出样例1:

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

20201116 李四 78

 

 

输入样例2:

在这里给出一组输入。例如：

20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20202316

 

输出样例2:

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

The student 20202316 does not exist

 

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

源码

import java.util.HashMap;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashMap<String, String[]> map = new HashMap<String, String[]>();
        Scanner input = new Scanner(System.in);
        String information = "";
        String id = "";  //学号
        
        while (!information.equals("end")) {  //存入学生信息到map中
            information = input.nextLine();
            String [] informations = null;
            String [] value = new String[2];  //姓名和成绩
            if (information.equals("end")) break;
            informations = information.split(" ");
            id = informations[0];
            value[0] = informations[1];
            value[1] = informations[2];
            map.put(id, value);
        }
        String matchStudentId = input.next();        
        if (map.containsKey(matchStudentId)) {
            System.out.println(matchStudentId + " " + map.get(matchStudentId)[0] + " " + map.get(matchStudentId)[1]);
        } else System.out.println("The student " + matchStudentId + " does not exist");
        
    }

}

分析

主要考察的是HashMap如何检索信息，我是用下面的方法进行检索的。

String matchStudentId = input.next();        
 if (map.containsKey(matchStudentId)) {
    System.out.println(matchStudentId + " " + map.get(matchStudentId)[0] + " " + map.get(matchStudentId)[1]);
    } else System.out.println("The student " + matchStudentId + " does not exist");

 7-2 容器-HashMap-排序

输入多个学生的成绩信息，包括：学号、姓名、成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

要求：使用HashMap存储学生信息。

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

以“end”为输入结束标志

输出格式:

按学号从大到小的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+成绩

输入样例:

在这里给出一组输入。例如：

20201124 张少军 83
20201136 李四 78
20201118 郑觉先 80
end

 

输出样例:

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

20201136 李四 78
20201124 张少军 83
20201118 郑觉先 80

 

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

源码

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class Main {  //HashMap排序
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashMap<String, String[]> map = new HashMap<String, String[]>();
        Scanner input = new Scanner(System.in);
        String information = "";
        String id = "";  //学号
        while (!information.equals("end")) {  //存入学生信息到map中
            information = input.nextLine();
            String [] informations = null;
            String [] value = new String[2];  //姓名和成绩
            if (information.equals("end")) break;
            informations = information.split(" ");
            id = informations[0];
            value[0] = informations[1];
            value[1] = informations[2];
            map.put(id, value);
        }
        sortMapByKey(map).forEach((k, v) -> System.out.println(k + " " + map.get(k)[0] + " " + map.get(k)[1]));
        
    }
    public static Map<String, String[]> sortMapByKey(HashMap<String, String[]> map) {  //关键字按照降序排列
        if (map == null || map.isEmpty()) return null;
        TreeMap<String, String[]> sortMap = new TreeMap<String, String[]>(new Comparator<String>() {
            public int compare(String id1, String id2) {
                return id2.compareTo(id1);//降序排序
            }
        });
        sortMap.putAll(map);
        return sortMap;
    }


}

 

分析

主要考察的是HashMap的排序问题，在这里我是运用treeMap对HashMap的关键字进行降序排序

public static Map<String, String[]> sortMapByKey(HashMap<String, String[]> map) { //关键字按照降序排列
    if (map == null || map.isEmpty()) return null;
    TreeMap<String, String[]> sortMap = new TreeMap<String, String[]>(new Comparator<String>() {
public int compare(String id1, String id2) {
    return id2.compareTo(id1);//降序排序
}
});
    sortMap.putAll(map);
    return sortMap;
}

题目集11

7-2 课程成绩统计程序-3

课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，

要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。

完成课程成绩统计程序-2、3两次程序后，比较继承和组合关系的区别。思考一下哪一种关系运用上更灵活，更能够适应变更。

题目最后的参考类图未做修改，大家根据要求自行调整，以下内容加粗字体显示的内容为本次新增的内容。

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

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

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

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

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

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

1、输入：

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

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

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

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

实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重

实验次数至少4次，不超过9次

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

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

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

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

实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝

实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩

以上信息的相关约束：

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

2）学号由8位数字组成

3）姓名不超过10个字符

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

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

2、输出：

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

为避免四舍五入误差，

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

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

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

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

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

2）单门课程成绩按课程名称的字符顺序输出

课程成绩输出格式：课程名称+英文空格+总成绩平均分

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

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

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

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

异常情况：

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

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

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

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

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

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

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

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

信息约束：

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

参考类图（与第一次相同，其余内容自行补充）：

输入样例1:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
end

 

输出样例1:

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

java has no grades yet

 

输入样例2:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2
end

 

输出样例2:

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

java : number of scores does not match

 

输入样例3:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.1
end

 

输出样例3:

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

java : weight value error

 

输入样例4:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100
end

 

输出样例4:

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

20201116 张三 86
java 86
202011 86

 

输入样例5:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100 80
end

 

输出样例5:

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

20201116 张三 : access mode mismatch
20201116 张三 did not take any exams
java has no grades yet
202011 has no grades yet

 

代码长度限制

25 KB

时间限制

1500 ms

内存限制

64 MB

类图

源码

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.text.Collator;
import java.util.Locale;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String information = "start";
        String courseInformation[] = null;
        String courseScoreInformation[] = null;
        int flag = 0;
        ArrayList<Student> students = new ArrayList<Student>();
        String course = input.nextLine();
        if (!(course.charAt(0) <= '9' && course.charAt(0) >= '0')) {
            courseInformation = course.split(" ");
        } 
        while (!information.equals("end")) {
            information = input.nextLine();
                courseScoreInformation = information.split(" ");
                 if (Integer.parseInt(courseInformation[3]) >= 4 && Integer.parseInt(courseInformation[3]) <= 9) {
                     int number1 = Integer.parseInt(courseInformation[3]);
                     if (courseInformation.length < 4 + number1  || courseInformation.length > 4 + number1) {
                         System.out.println(courseInformation[0] +" : number of scores does not match");
                         return;
                     } else {
                         double weightValue = 0;
                         for (int i = 4; i < courseInformation.length; i++) {
                             weightValue += Float.parseFloat(courseInformation[i]);
                         }
                         if (Math.abs(weightValue - 1) > 0.001) {
                             System.out.println(courseInformation[0] + " : weight value error");
                             return;
                         } else {
                             if (courseScoreInformation.length > 3 + number1) {
                                Student student = new Student(courseScoreInformation[0], courseScoreInformation[1]);
                                students.add(student);
                                System.out.println(courseScoreInformation[0] + " " + courseScoreInformation[1] + " : access mode mismatch");
                                System.out.println(courseScoreInformation[0] + " " + courseScoreInformation[1] + " did not take any exams");
                                System.out.println(courseInformation[0] + " has no grades yet");
                                System.out.println(courseScoreInformation[0].substring(0, 6) + " has no grades yet");
                                break;
                             }
                             if (courseScoreInformation.length > 1) {
                                 double total = 0;
                                 for (int i = 4; i < courseInformation.length; i++) {
                                     total += Float.parseFloat(courseScoreInformation[i - 1]) * Float.parseFloat(courseInformation[i]);
                                 }
                                 Student student = new Student(courseScoreInformation[0], courseScoreInformation[1], (int)total);
                                 students.add(student);
                                 flag = 1;
                             } 
                         }
                     }
                     
                 }
                 if (courseScoreInformation.length == 1) break;
                 
                 if (courseInformation[1].equals("必修") && courseInformation[2].equals("实验")){
                        System.out.println(courseInformation[0] + " : course type & access mode mismatch");
                        System.out.println("wrong format");
                 } else if (courseScoreInformation[3].matches("[0-3]")) {
                    System.out.println("wrong format");
                    System.out.println(courseInformation[0] + " has no grades yet");
                    break;
                 } else {
                    int number2 = Integer.parseInt(courseScoreInformation[3]);
                    if (courseScoreInformation.length > 3 + number2 && flag == 0) {
                        System.out.println(courseScoreInformation[0] + " " + courseScoreInformation[1] + " : access mode mismatch");
                        System.out.println(courseScoreInformation[0] + " " + courseScoreInformation[1] + " did not take any exams");
                        System.out.println(courseInformation[0] + " has no grades yet");
                        System.out.println(courseScoreInformation[0].substring(0, 6) + " has no grades yet");
                        return;
                    }
                }
                
                }
        if (students.size() == 0) {
             System.out.println(courseInformation[0] + " has no grades yet");
             return;
         }
        Collections.sort(students);
         if (flag == 1) {
             float courseTotal = 0;
             for (int i = 0; i < students.size(); i++) {
                  System.out.println(students.get(i).getId() + " " + students.get(i).getName() + " " + students.get(i).getGrade());
                  courseTotal += students.get(i).getGrade();
             } 
             System.out.println(courseInformation[0]+ " " + (int)(courseTotal / students.size()));
             System.out.println(students.get(0).getId().substring(0, 6)+ " " + (int)(courseTotal / students.size()));
             return;
         }
            }
    }        

class AccessScore extends Score {  //考察成绩类
    private int finalScore;
    
    @Override
    public int getUsualScore() {
        return 0;
    }

    public AccessScore(int finalScore) {
        super();
        if (finalScore < 0 || finalScore >100) return;
        this.finalScore = finalScore;
    }

    public int getFinalScore() {
        return this.finalScore;
    }
    
    public int getTotalScore() {  //考察总成绩=期末成绩
        return this.finalScore;
    }
}
class Class implements Comparable<Class> {  //班级类
    private String classId = null;
    private ArrayList<Student> students = new ArrayList<Student>();

    
    public Class() {
        // TODO Auto-generated constructor stub
    }


    public Class(String classId) {
        super();
        this.classId = classId;
    }

    public String getClassId() {
        return classId;
    }


    public void setClassId(String classId) {
        this.classId = classId;
    }


    public ArrayList<Student> getStudents() {
        return students;
    }


    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }
    
    @Override
    public int compareTo(Class studentClass) {  //比较班级的班号，如果比该班级大返回1，小则返回-1，相等返回0
        // TODO Auto-generated method stub
        if (Integer.parseInt(classId) > Integer.parseInt(studentClass.classId)) {
            return 1;
        } else if (Integer.parseInt(classId) < Integer.parseInt(studentClass.classId)) {
            return -1;
        } else return 0;
    }
    
    public void addStudent(Student stu) {  //添加学生到班级里
        if (this.hasStudent(stu)) return;
        students.add(stu);
    }
    
    public boolean hasStudent(Student stu) {  //判断该班级是否该有学生
        for (int i = 0; i < students.size(); i++) {
            if (students.get(i).getClassId().equals(classId)) {
                return true;
            }
        }
        return false;
    }
    
    public boolean hasScore() {  //判断该班级是否有成绩
        return this.getAverageScore() != -1;
    }
    
    public int getAverageScore() {  //计算班级总成绩平均分
        int total = 0;
        for (int i = 0; i < this.students.size(); i ++) {
            total += this.students.get(i).getAverageScore();
        }
        if (this.students.size() == 0) return -1;
        return (int)((double)(total / this.students.size()));
    }
    
    
}

class Course implements Comparable<Course> {  //课程类
    
    private String name;  //课程名称
    private String courseType;  //课程性质
    private String accessMethod;  //课程考核方式
    private ArrayList<CourseSelect> courseSelects = new ArrayList<CourseSelect>();
    
    public Course() {
        // TODO Auto-generated constructor stub
    }

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

    public Course(String name, String courseType, String accessMethod) {
        super();
        this.name = name;
        this.courseType = courseType;
        this.accessMethod = accessMethod;
    }

    public Course(String name, String courseType, String accessMethod, ArrayList<CourseSelect> courseSelects) {
        super();
        
        this.name = name;
        this.courseType = courseType;
        this.accessMethod = accessMethod;
        this.courseSelects = courseSelects;
    }
    
    public String getName() {
        return name;
    }

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

    public String getCourseType() {
        return courseType;
    }

    public void setCourseType(String courseType) {
        this.courseType = courseType;
    }

    public String getAccessMethod() {
        return accessMethod;
    }

    public void setAccessMethod(String accessMethod) {
        this.accessMethod = accessMethod;
    }

    public ArrayList<CourseSelect> getCourseSelects() {
        return courseSelects;
    }

    public void setCourseSelects(ArrayList<CourseSelect> courseSelects) {
        this.courseSelects = courseSelects;
    }

    public int getAverageUsualScore() {  //计算单科平时成绩平均分
        int total = 0;
        for (int i = 0; i < courseSelects.size(); i++) {
            total += courseSelects.get(i).getScore().getUsualScore();
        }
        if (courseSelects.size() == 0) return 0;
        return (int)((double)(total / courseSelects.size()));
    }
    
    public int getAverageFinalScore() {  //计算单科期末考试平均分
        int total = 0;
        for (int i = 0; i < courseSelects.size(); i++) {
            total += courseSelects.get(i).getScore().getFinalScore();
        }
        if (courseSelects.size() == 0) return -1;
        return (int)((double)(total / courseSelects.size()));
    }
    
    public int getAverageTotalScore() {  //计算单科总成绩平均分
        int total = 0;
        for (int i = 0; i < courseSelects.size(); i++) {
            total += courseSelects.get(i).getScore().getTotalScore();
        }
        if (courseSelects.size() == 0) return -1;
        return (int)((double)(total / courseSelects.size()));
    }
    
    public boolean hasScore() {  //判断该课程是否有成绩
        return this.getAverageTotalScore() != -1;
    }

    @Override
    public int compareTo(Course course) {  //比较该课程名称的字符顺序，如果大返回1，小则返回-1，相等返回0
        // TODO Auto-generated method stub
        return Collator.getInstance(Locale.CHINA).compare(this.name, course.name); 

    }
    
}
class CourseSelect {  //选课类
    private Course course;
    private Student student;
    private Score score;
    
    public CourseSelect(Course course, Student student, Score score) {
        super();
        this.course = course;
        this.student = student;
        this.score = score;
    }

    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 Data {  //数据类，存储数据
    private ArrayList<Course> courses = new ArrayList<Course>();
    private ArrayList<Student> students = new ArrayList<Student>();
    private ArrayList<Class> classes = new ArrayList<Class>();
    private ArrayList<CourseSelect> courseSelects = new ArrayList<CourseSelect>();
    
    public ArrayList<Course> getCourses() {
        return courses;
    }
    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }
    public ArrayList<Student> getStudents() {
        return students;
    }
    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }
    public ArrayList<Class> getClasses() {
        return classes;
    }
    public void setClasses(ArrayList<Class> classes) {
        this.classes = classes;
    }
    public ArrayList<CourseSelect> getCourseSelects() {
        return courseSelects;
    }
    public void setCourseSelects(ArrayList<CourseSelect> courseSelects) {
        this.courseSelects = courseSelects;
    }
    
    
    
}
class ExamScore extends Score {  //考试成绩类
    private int usualScore;
    private int finalScore;
    
    public ExamScore(int usualScore, int finalScore) {
        super();
        if (usualScore < 0 || usualScore >100) return;
        if (finalScore < 0 || finalScore >100) return;
        this.usualScore = usualScore;
        this.finalScore = finalScore;
    }

    @Override
    public int getUsualScore() {
        return this.usualScore;
    }

    public int getFinalScore() {
        return this.finalScore;
    }
    
    public int getTotalScore() {  //考试总成绩=平时成绩*0.3+期末成绩*0.7
        return (int)((double)(this.usualScore * 0.3 + this.finalScore * 0.7));
    }
}
abstract class Score {  //抽象分数类
    public abstract int getUsualScore();  //平时成绩
    public abstract int getFinalScore();  //期末成绩
    public abstract int getTotalScore();  //总成绩
    
    public Score() {
        // TODO Auto-generated constructor stub
    }

}
class Student implements Comparable<Student> {  //学生类
    private String id = null;  //学号
    private String name = null;  //姓名
    private int grade = 0;
    private ArrayList<CourseSelect> courseSelects = new ArrayList<CourseSelect>();  //选课
    
    public Student(String id, String name) {
        super();
        if (id.length() == 8) {
        this.id = id;
        } 
        if (name.length() < 10 && name.length() > 0) {
        this.name = name;
        }
        
    }
    
    public Student(String id, String name, int grade) {
        super();
        this.id = id;
        this.name = name;
        this.grade = grade;
    }

    public Student(String id, String name, ArrayList<CourseSelect> courseSelects) {
        super();
        this.id = id;
        this.name = name;
        this.courseSelects = courseSelects;
    }

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<CourseSelect> getCourseSelects() {
        return courseSelects;
    }

    public void setCourseSelects(ArrayList<CourseSelect> courseSelects) {
        this.courseSelects = courseSelects;
    }

    public String getClassId() {
        return this.id.substring(0, 6);
    }

    public boolean hasScore() {  //判断该学生是否有成绩
        return this.getAverageScore() != -1;
    }
    
    public int getAverageScore() {  //计算学生所有课程总成绩的平均分
        int total = 0;
        for (int i = 0; i < courseSelects.size(); i++) {
            total += courseSelects.get(i).getScore().getTotalScore();
        }
        if (courseSelects.size() == 0) return 0;
        return (int)((double)(total / courseSelects.size()));
    }

    @Override
    public int compareTo(Student student) {  //比较学生的学号，如果比该学生student大返回1，小则返回-1，相等返回0
        // TODO Auto-generated method stub
        if (Integer.parseInt(id) > Integer.parseInt(student.id)) {
            return 1;
        } else if (Integer.parseInt(id) < Integer.parseInt(student.id)) {
            return -1;
        } else return 0;
        
    }
    
    
    
}

 

分析

由于这一题并没有做出来，只是对了很少的一部分样例，在此不做分析。

7-3 jmu-Java-02基本语法-03-身份证排序

1. 输入n，然后连续输入n个身份证号。
2. 然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出exit并退出。
   输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
   输入sort2，将所有身份证按照里面的年月日升序输出。

注意：处理输入的时候，全部使用Scanner的nextLine()方法，以免出错。

输入样例:

6
410425198309308225
320203197206115011
431227196108033146
330226196605054190
34080019810819327X
320111197112301539
sort1
sort2
e

 

输出样例:

1961-08-03
1966-05-05
1971-12-30
1972-06-11
1981-08-19
1983-09-30
431227196108033146
330226196605054190
320111197112301539
320203197206115011
34080019810819327X
410425198309308225
exit

 

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

源码

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {  // jmu-Java-02基本语法-03-身份证排序

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        int number = Integer.parseInt(input.nextLine());  //输入身份证的数量
        int count = 0;
        ArrayList<Identity> identities = new ArrayList<Identity>();  //储存年月日
        while (count != number) {
            String str = input.nextLine();
            Identity identity = new Identity(str);
            identities.add(identity);
            count++;
        }
        Collections.sort(identities);
        String sort = "sort1";
        while (!(!sort.equals("sort1") && !sort.equals("sort2"))) {
            sort = input.nextLine();
            if (!sort.equals("sort1") && !sort.equals("sort2")) {
                System.out.println("exit");
                break;
            }
            if (sort.equals("sort1")) {
                for(int i = 0; i < identities.size(); i++) {
                    System.out.println(identities.get(i).getYear() + "-" + identities.get(i).getMOnth() + "-" + identities.get(i).getDay());
                }
            }
            if (sort.equals("sort2")) {
                for(int i = 0; i < identities.size(); i++) {
                    System.out.println(identities.get(i).getIdentity());
                }
            }
        }
            
        
    }

}
class Identity implements Comparable<Identity>{
    private String identity;

    public Identity(String identity) {
        super();
        this.identity = identity;
    }
    public String getDate() {
        return this.identity.substring(6, 14);
    }
    public String getYear() {
        return this.identity.substring(6, 10);
    }
    public String getMOnth() {
        return this.identity.substring(10, 12);
    }
    public String getDay() {
        return this.identity.substring(12, 14);
    }
    public String getIdentity() {
        return identity;
    }
    public void setIdentity(String identity) {
        this.identity = identity;
    }
    @Override
    public int compareTo(Identity o) {
        // TODO Auto-generated method stub
        int date1 = Integer.parseInt(getDate());
        int date2 = Integer.parseInt(o.getDate());
        return date1 - date2;
    }
}

分析

这里考察的主要是ArrayList的排序，我在Identity类里实现了comparable接口，使得每一个Identity对象可以进行比较，从而能够使用Collection.sort方法对ArrayList里的对象排序。

三、踩坑心得

第九次作业

这次作业踩的一个坑是代码中的[]以及,分隔，这个卡了好久。后面发现是splitCode（）方法里的正则表达式出现了问题。

踩坑截图

 改正后

第十一次作业

这次作业踩的一个坑是stack的满栈和空栈问题。

踩坑截图

改正后

import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();  //输入n，建立可包含n个元素的ArrayIntegerStack对象
        ArrayIntegerStack array = new ArrayIntegerStack(n);
        int m = input.nextInt();  //输入m个值，均入栈。每次入栈均打印入栈返回结果。
        int count = 0;
        while (count != m) {
            Integer item = input.nextInt();
            System.out.println(array.push(item));
            count++;
        }
        //输出栈顶元素，输出是否为空，输出size
        System.out.println(array.peek() + "," + array.empty() + "," + array.size());
        //使用Arrays.toString()输出内部数组中的值。
        System.out.println(Arrays.toString(array.getStack()));
        int x = input.nextInt();  //输入x，然后出栈x次，每次出栈均打印。
        count = 0;
        while (count != x) {
            System.out.println(array.pop());
            count++;
        }
        //输出栈顶元素，输出是否为空，输出size
        System.out.println(array.peek() + "," + array.empty() + "," + array.size());
        //使用Arrays.toString()输出内部数组中的值。
        System.out.println(Arrays.toString(array.getStack()));
    }

}

interface IntegerStack {
    public Integer push(Integer item);
    //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。

    public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
    public Integer peek();  //获得栈顶元素，如果为空，则返回null.
    public boolean empty(); //如果为空返回true
    public int size();      //返回栈中元素个数
}

class ArrayIntegerStack implements IntegerStack {
    private int max = 0;
    private int size = 0;
    private Integer[] stack;
    public ArrayIntegerStack(int n) {
        stack = new Integer[n];
        max = n;
    }

    public Integer[] getStack() {
        return stack;
    }

    public void setStack(Integer[] stack) {
        this.stack = stack;
    }

    @Override
    public Integer push(Integer item) {  
    //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。
    if (item == null) {
        return null;
    } else if (size == max) {
        return null;
    } else {
        stack[size] = item;
        size++;
        return item;
    }
    }
    @Override
    public Integer pop() {  //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
        if (empty()) {
            return null;
        } else {
            size--;
            return stack[size];    
        }
        
    }

    @Override
    public Integer peek() {  //获得栈顶元素，如果为空，则返回null.
        if (empty()) {
            return null;
        } else {
            return stack[size - 1];
        }
            
    }

    @Override
    public boolean empty() {  //如果为空返回true
        if (size == 0) return true;
        return false;
    }

    @Override
    public int size() {  //返回栈中元素个数
        return size;
    }
    
}

 

四、改进建议

1.把重复代码改成方法来实现功能，减少代码量，使得代码更加简洁，也更符合单一职责。

2.要养成写注释的好习惯，每一个方法都要写注释，便于自己查看。

五、总结

通过这一阶段的学习和做题，我了解和基本掌握了map和set的用法，知道了HashMap如何检索和排序，也会ArrayList的排序方法。同时通过写雨刷的仿真系统以及农夫过河的游戏界面，我熟悉了JavaFx的一些基本组件和用法，懂得了一些界面设计的方法。

六、对本门课程进行客观性评价

教学理念（OBE）

在我看来，段老师教学理念中以学生为主体，发挥学生的主观能动性，充分调动学生的思考，激发学生的兴趣。

教学方法（边讲边练）

我比较赞同这种的教学方法，通过边讲边练，我们可以熟练老师上课讲的方法并加以实践，达到巩固的效果。

教学组织（线上线下混合式教学）

通过观看学习通的线上视频，我们可以提前预习老师要讲的内容，达到一个预习的作用，这是很好的，可以让我们提前知道哪个知识点是自己上课需要特别注意的。

教学过程（PTA题目集驱动）

总体还是可以的，提高了一定的编程能力。但是有时候pta题目集比较难和多，会跟其他科目的作业之类的起冲突，无法分配好做题时间，所以可以适当减少一点题目难度或者减少题量。

教学模式（BOPPPS)

段老师采用的应该是以教育目标为导向,以学生为中心的教学模式，达到了一个比较好的教学成果。