oop第三次blog总结

oop题目集07

*菜单计价程序-5

oop题目集08

*课程成绩统计程序-1

oop题目集09

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

oop题目集10

*容器-HashMap-检索

*容器-HashMap-排序

*课程成绩统计程序-2

*动物发声模拟器（多态）

oop题目集11

*容器-ArrayList-排序

*课程成绩统计程序-3

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

*jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack

*jmu-Java-03面向对象基础-05-覆盖

一、前言

　　这次题目集相比与前面几次的题目集的题目都加大了很多，并且相比于前面的题目难度也略有增加，所考察的知识点也更加全面和综合，具体如下：

oopt题目集07

　　这次题目集仍然是前面几次菜单集的迭代，由于我前面几次菜单做的并不是很理想，所以在做这次题目集仍然成绩并不是非常理想。

　　所涉及的知识点：类与类之间的关系，类的设计，正则表达式等。

oop题目集08

　　这次题目集是一次新的迭代——课程成绩统计，难度适中，但是由于一开始没有设计好相关的类结构，导致四处碰壁。

　　　所涉及的知识点：类的设计，正则表达式，类与类的关系等；

oop题目集09

　　出乎意料的是，这次题目集不是上一次的迭代，而是统计Java程序中关键词的出现次数，这次题目相比于迭代难度还是降低了很多，但是最后还是有个测试点没有搞出来。

　　涉及的知识点：Hashmap的使用，正则表达式等。

oop题目集10

　　这次题目集有四道题，不出意外的，其中有一道题目就是课程成绩统计程序的迭代，难度除了这道题难度较大的情况下，其他难度都一般。

　　涉及的知识点：HashMap的检索和排序，类的设计，正则表达式，多态等。

oop题目集11

　　这次题目集有五题，是这几次题目集量最大的一次，相关的知识点也比较多，相比于前几次的难度也增大了一点。

　　涉及的知识点：正则表达式，类的涉及，Arraylist排序，类与类之间的关系。

　　总之，通过这几次发现自己的有在进步，之前遇到大作业的第一想法是逃避，现在已经学会了要正对困难，在一次次的大作业的迭代中发现自己的编程能力相比于之前进步了不少，也了解了更多相关的知识点。

二、设计与分析

首先分析一下本次的迭代程序——课程成绩统计程序

oop题目集08

*课程成绩统计程序-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.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String []sentence = new String[100];
        sentence[0] = input.nextLine();
        ArrayList<Student> student = new ArrayList<>();
        Course []course = new Course[100];
        ChooseCourse[]chooseCourse = new ChooseCourse[100];
        int n = 0;
        int m =0;
        int p =0;
        int isLength = 1;
        int isMatch = 0;
        int courseCheck = 1;
        int courseCheck1 = 0;
        int totalPeople = 0;
        int averageGrade = 0;
        int total = 0;
        String courseName = " ";
        String className = " ";
        // int isSuccess;
        String method;
        for(int i = 0;!sentence[i].equals("end");){

            String []splited  = sentence[i].split(" ");

            if(splited.length == 3 && sentence[i].matches("^\\S+ (必修|选修) (考试|考察)$")){//把相应的数据存到course数组里面,课程信息
                course[n] = new Course();
                course[n].name = splited[0];
                course[n].character = splited[1];
                course[n].method = splited[2];
                if(course[n].character.equals("必修") && !course[n].method.equals("考试")){//课程类型与考核类型不匹配
                    courseCheck = 0;
                    System.out .println(course[n].name + " : course type & access mode mismatch");
                    System.out.println(course[n].name + " does not exist");
                }
                n++;
            }
            else if(splited.length == 4 && sentence[i].matches("^[0-9]{8}+ \\S{1,10}+ \\S+ ([0-9]{1,2}|100)$")){//长度为4，只有期末成绩(考试类型为考察)，把课程成绩信息储存在choosecourse数组中
                isLength = 4;
                chooseCourse[m] =new ChooseCourse();
                chooseCourse[m].student.number = splited[0];
                chooseCourse[m].student.name = splited[1];
                chooseCourse[m].course.name = splited[2];
                chooseCourse[m].course.checkScore.finalGrade = Integer.parseInt(splited[3]);
                //f(splited[0].length() == )
                if(Integer.parseInt(splited[3]) > 100 || Integer.parseInt(splited[3]) < 0){
                    System.out.println("wrong format");
                    System.out.println(splited[2] + " has no grades yet");
                }
                //student

                for(int j = 0;j < n; j++){//进行匹配，看有没有和课程信息中一样的课程
                    if(!splited[2].equals(course[j].name))//未匹配成功，循环继续下一次匹配
                        continue;
                    else{//匹配成功
                        totalPeople++;
                        total = total + Integer.parseInt(splited[3]);
                        averageGrade = total / totalPeople;
                        isMatch = 1;
                       // int isSuccess = j;
                        course[j].checkScore.totalGrade = course[j].checkScore.totalGrade + course[j].checkScore.finalGrade;
                        //      averageGrade = course[j].checkScore.averageTotalGrade = (course[j].checkScore.totalGrade/totalPeople);
                        if(!course[j].method.equals("考察")){//匹配错误
                            System.out.println(splited[0] + " " + splited[1] + " : access mode mismatch");
                            System.out.println(splited[0] + " " + splited[1] + " did not take any exams");
                            System.out.println(splited[2] + " has no grades yet");
                            System.out.println(splited[0].substring(0,6) + " has no grades yet");
                        }
                        else if(course[j].method.equals("考察") && !course[j].character.equals("必修") && !(Integer.parseInt(splited[3]) > 100 || Integer.parseInt(splited[3]) < 0)){
                            courseCheck = 1;
                            courseCheck1 = 1;
                            courseName = splited[2];
                            className = splited[0].substring(0,6);
                            System.out.println(splited[0] + " " + splited[1] + " " + splited[3]);
                          //  System.out.println(splited[2] + " " + splited[3] + " " + splited[3]);
                          //  System.out.println(splited[0].substring(0,6) + " " + splited[3]);
                        }

                    }
                }

                if(courseCheck == 0){//课程类型与考核类型不匹配
                    System.out.println(splited[0] + " " + splited[1] + " did not take any exams");
                    System.out.println(splited[0].substring(0,6) + " has no grades yet");
                }
                m++;
            }
            else if(splited.length == 4 && Integer.parseInt(splited[3]) > 100 || Integer.parseInt(splited[3]) < 0){
                isLength = 4;
                System.out.println("wrong format");
                System.out.println(splited[2] + " has no grades yet");
            }
            else if(splited.length == 5 && sentence[i].matches("^[0-9]{8}+ \\S{1,10}+ \\S+ ([0-9]{1,2}|100)+ ([0-9]{1,2}|100)$")){//长度为5，期末成绩和平时成绩，把课程成绩信息储存在choosecourse数组中
                isLength = 5;
                chooseCourse[p] =new ChooseCourse();
                chooseCourse[p].student.number = splited[0];
                chooseCourse[p].student.name = splited[1];
                chooseCourse[p].course.name = splited[2];
                chooseCourse[p].course.testscore.dailyGrade = Integer.parseInt(splited[3]);
                chooseCourse[p].course.testscore.finalGrade = Integer.parseInt(splited[4]);
                chooseCourse[p].course.testscore.totalGrade = (int)(Integer.parseInt(splited[3]) * 0.3 + Integer.parseInt(splited[4])*0.7);
                if(Integer.parseInt(splited[3]) > 100 || Integer.parseInt(splited[3]) < 0){
                    System.out.println("wrong format");
                    System.out.println(splited[2] + " has no grades yet");
                }

                if(Integer.parseInt(splited[4]) > 100 || Integer.parseInt(splited[4]) < 0){
                    System.out.println("wrong format");
                    System.out.println(splited[2] + " has no grades yet");
                }

                for(int j = 0;j < n; j++){//进行匹配，看有没有和课程信息中一样的课程
                    if(!splited[2].equals(course[j].name))//未匹配成功，循环继续下一次匹配
                        continue;
                    else{//匹配成功
                        totalPeople++;
                        total = total + Integer.parseInt(splited[3]);
                        averageGrade = total / totalPeople;
                        isMatch = 1;

                        course[j].checkScore.totalGrade = course[j].checkScore.totalGrade + course[j].checkScore.finalGrade;
                        //      averageGrade = course[j].checkScore.averageTotalGrade = (course[j].checkScore.totalGrade/totalPeople);
                        if(!course[j].method.equals("考试")){//匹配错误
                            System.out.println(splited[0] + " " + splited[1] + " : access mode mismatch");
                            System.out.println(splited[0] + " " + splited[1] + " did not take any exams");
                            System.out.println(splited[2] + " has no grades yet");
                            System.out.println(splited[0].substring(0,6) + " has no grades yet");
                        }
                        else if(course[j].method.equals("考试") &&
                                !(Integer.parseInt(splited[3]) > 100 || Integer.parseInt(splited[3]) < 0) &&
                                !(Integer.parseInt(splited[4]) > 100 || Integer.parseInt(splited[4]) < 0)){
                            System.out.println(splited[0] + " " + splited[1] + " " + chooseCourse[p].course.testscore.totalGrade);
                            System.out.println(splited[2] + " " + splited[3] + " " + splited[4] + " " + chooseCourse[p].course.testscore.totalGrade);
                            System.out.println(splited[0].substring(0,6) + " " +chooseCourse[p].course.testscore.totalGrade);
                        }

                    }
                }

                p++;
            }
            else if(splited.length == 5 && Integer.parseInt(splited[3]) > 100 || Integer.parseInt(splited[3]) < 0){
                isLength = 5;
                System.out.println("wrong format");
                System.out.println(splited[2] + " has no grades yet");
            }

            else if(splited.length == 5 && Integer.parseInt(splited[4]) > 100 || Integer.parseInt(splited[4]) < 0){
                isLength = 5;
                System.out.println("wrong format");
                System.out.println(splited[2] + " has no grades yet");
            }

            else{
                System.out.println("wrong format");
            }
/*
            if(splited.length == 4 && Integer.parseInt(splited[3]) > 100 || Integer.parseInt(splited[3]) < 0){
                System.out.println(splited[2] + " has no grades yet");
            }
            if(splited.length == 5 && Integer.parseInt(splited[3]) > 100 || Integer.parseInt(splited[3]) < 0){
                System.out.println(splited[2] + " has no grades yet");
            }
            if(splited.length == 5 && Integer.parseInt(splited[4]) > 100 || Integer.parseInt(splited[4]) < 0){
                System.out.println(splited[2] + " has no grades yet");
            }

            
 */
            i++;
            sentence[i] = input.nextLine();

        }

        if(isLength == 1){
            for(int i = 0;i < n;i++){
                System.out.println(course[i].name + " has no grades yet");
            }
        }

        if(courseCheck1 == 1){
            System.out.println(courseName + " " + averageGrade + " " + averageGrade );
            System.out.println(className + " " + averageGrade);
        }
    }
}

class CheckScore extends TestScore {
    int finalGrade;
    int totalGrade;
    int averageTotalGrade;
}

 class ChooseCourse {
    Course course = new Course();
    Student student = new Student();
    Score score;
}


class Class {
}

class Course {
    String name;
    String character;//性质——必修or非必修
    String method = "无";//考核方式，可选，如果性质是必修课，考核方式可以没有，所以一开始定义为“无”
    TestScore testscore = new TestScore();
    CheckScore checkScore = new CheckScore();
}

abstract class Score {

}

class Student {
    String name;
    String number;
    ArrayList<Integer> grade = new ArrayList<>();
}

class TestScore extends Score {
    int finalGrade;
    int dailyGrade;
    int totalGrade = (int) (0.3 * this.dailyGrade + 0.7 * this.finalGrade);

}

输入样例1:

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

java 实验 实验
20201103 张三 java 4 70 80 90
end

输出样例1:

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

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

输入样例2:

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

java 实验 实验
20201103 张三 java 3 70 80 90
end

输出样例2:

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

wrong format
java has no grades yet

输入样例3:

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

java 必修 实验
20201103 张三 java 3 70 80 90 100
end

输出样例3:

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

java : course type & access mode mismatch
wrong format

输入样例4:

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

java 必修 实验
20201103 张三 java 4 70 80 90 105
end

输出样例4:

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

java : course type & access mode mismatch
wrong format

输入样例5:

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

java 选修 考察
C语言 选修 考察
java实验 实验 实验
编译原理 必修 考试
20201101 王五 C语言 76
20201216 李四 C语言 78
20201307 张少军 编译原理 82 84
20201103 张三 java实验 4 70 80 90 100
20201118 郑觉先 java 80
20201328 刘和宇 java 77
20201220 朱重九 java实验 4 60 60 80 80
20201132 王萍 C语言 40
20201302 李梦涵 C语言 68
20201325 崔瑾 编译原理 80 84
20201213 黄红 java 82
20201209 赵仙芝 java 76
end

输出样例5:

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

20201101 王五 76
20201103 张三 85
20201118 郑觉先 80
20201132 王萍 40
20201209 赵仙芝 76
20201213 黄红 82
20201216 李四 78
20201220 朱重九 70
20201302 李梦涵 68
20201307 张少军 83
20201325 崔瑾 82
20201328 刘和宇 77
C语言 65 65
java 78 78
java实验 77
编译原理 81 84 82
202011 70
202012 76
202013 77

代码长度限制

30 KB

时间限制

1000 ms

内存限制

64 MB

我的源代码如下

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

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

        HashMap<String,Course> courses = new HashMap<>();
        HashMap<String,Student> students = new HashMap<>();
        HashMap<String,Class> classes = new HashMap<>();
        ArrayList<chooseCourse> chooseCourses = new ArrayList<>();
        Scanner input = new Scanner(System.in);
        String scentence = input.nextLine();
        for(;!scentence.equals("end");){
            if(scentence.matches("^\\S{1,10} (必修|选修|实验) (考试|考察|实验)$")){
                String []splited = scentence.split(" ");//new String[100];
                if(((splited[1].equals("必修") && splited[2].equals("考试")) ||
                        (splited[1].equals("选修") && (splited[2].equals("考试") || splited[2].equals("考察")))||
                        (splited[1].equals("实验") && splited[2].equals("实验")))){
                    if(!courses.containsKey(splited[0])){
                        Course course1 = new Course();
                        course1.name = splited[0];
                        course1.character = splited[1];
                        course1.method = splited[2];
                        courses.put(splited[0],course1);
                    }
                }
               else{
                    System.out.println(splited[0] + " : course type & access mode mismatch");
                }
            }

            else if(scentence.matches("[0-9]{8} \\S{1,10} \\S{1,10} ([0-9]|[1-9][0-9]|100)")){
                String []splited = scentence.split(" ");
                //当出现重复课程需要忽略
                for(int i=0;i<chooseCourses.size();i++){
                    if(chooseCourses.get(i).student.num.equals(splited[0]) && chooseCourses.get(i).student.name.equals(splited[1]) &&
                            chooseCourses.get(i).course.name.equals(splited[2])){
                        break;
                    }
                }
                //实例化student，储存信息
                Student student = new Student();
                student.name = splited[1];
                student.num = splited[0];
                students.put(splited[0],student);//把student储存到hashmap里面
                String classNum = splited[0].substring(0,6);
                if(!classes.containsKey(classNum)){
                    Class aClass = new Class();
                    aClass.classNum = classNum;
                    classes.put(classNum,aClass);
                    classes.get(classNum).student = new HashMap<>();
                }
                classes.get(classNum).student.put(splited[0],student);
                if(!courses.containsKey(splited[2])){//判断课程是否存在
                    System.out.println(splited[0] + " does not exist");
                    break;
                }
                else if(!courses.get(splited[2]).method.equals("考察")){//判断考察方式是否相同
                    System.out.println(splited[0] +" "+ splited[1] + " : access mode mismatch");
                    break;
                }
                else {
                    chooseCourse chooseCourse = new chooseCourse();
                    chooseCourse.student = student;
                    chooseCourse.course = courses.get(splited[2]);//对应的课程加入选课系统中
                    checkScore checkscore = new checkScore();//创建成绩类
                    checkscore.finalGrade = Integer.parseInt(splited[3]);//考察的存入成绩
                    chooseCourse.score = checkscore;
                    chooseCourses.add(chooseCourse);//添加到arraylist
                }
            }

            else if(scentence.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 []splited = scentence.split(" ");
                //当出现重复课程需要忽略
                for(int i=0;i<chooseCourses.size();i++){
                    if(chooseCourses.get(i).student.num.equals(splited[0]) && chooseCourses.get(i).student.name.equals(splited[1]) &&
                            chooseCourses.get(i).course.name.equals(splited[2])){
                        break;
                    }
                }
                //实例化student，储存信息
                Student student = new Student();
                student.name = splited[1];
                student.num = splited[0];
                String classNum = splited[0].substring(0,6);
                if(!classes.containsKey(classNum)){
                    Class aClass = new Class();
                    aClass.classNum = classNum;
                    classes.put(classNum,aClass);
                    classes.get(classNum).student = new HashMap<>();
                }
                classes.get(classNum).student.put(splited[0],student);
                students.put(splited[0],student);//把student储存到hashmap里面
                if(!courses.containsKey(splited[2])){//判断课程是否存在
                    System.out.println(splited[0] + " does not exist");
                    break;
                }
                else if(!courses.get(splited[2]).method.equals("考试")){//判断考察方式是否相同
                    System.out.println(splited[0] +" "+ splited[1] + " : access mode mismatch");
                    break;
                }
                else {
                    chooseCourse chooseCourse = new chooseCourse();
                    chooseCourse.student = student;
                    chooseCourse.course = courses.get(splited[2]);//对应的课程加入选课系统中
                    testScore testscore = new testScore();//创建成绩类

                    testscore.dialyGrade = Integer.parseInt(splited[3]);
                    testscore.finalGrade = Integer.parseInt(splited[4]);//考试的存入成绩
                    chooseCourse.score = testscore;
                    chooseCourses.add(chooseCourse);//添加到arraylist
                }
            }

            //判断实验
            else if(scentence.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 []splited = scentence.split(" ");
                //当出现重复课程需要忽略
                for(int i=0;i<chooseCourses.size();i++){
                    if(chooseCourses.get(i).student.num.equals(splited[0]) && chooseCourses.get(i).student.name.equals(splited[1]) &&
                            chooseCourses.get(i).course.name.equals(splited[2])){
                        break;
                    }
                }
                //实例化student，储存信息
                Student student = new Student();
                student.name = splited[1];
                student.num = splited[0];
                students.put(splited[0],student);//把student储存到hashmap里面
                String classNum = splited[0].substring(0,6);
                if(!classes.containsKey(classNum)){
                    Class aClass = new Class();
                    aClass.classNum = classNum;
                    classes.put(classNum,aClass);
                    classes.get(classNum).student = new HashMap<>();
                }
                classes.get(classNum).student.put(splited[0],student);
                if(!courses.containsKey(splited[2])){//判断课程是否存在
                    System.out.println(splited[0] + " does not exist");
                    break;
                }
                else if(!courses.get(splited[2]).method.equals("实验")){//判断考察方式是否相同
                    System.out.println(splited[0] + " "+splited[1] + " : access mode mismatch");
                    break;
                }
                else if(splited.length-4!=Integer.parseInt(splited[3])){
                    System.out.println(splited[0] + " "+splited[1] + " : access mode mismatch");
                    break;
                }
                else {
                    chooseCourse chooseCourse = new chooseCourse();
                    chooseCourse.student = student;
                    chooseCourse.course = courses.get(splited[2]);//对应的课程加入选课系统中
                    experimentScore experimentScore = new experimentScore();//创建成绩类
                    for(int i = 4;i < splited.length;i++){
                        experimentScore.grade.add(Integer.valueOf(splited[i]));
                    }
                    // 考察的存入成绩
                    chooseCourse.score = experimentScore;
                    chooseCourses.add(chooseCourse);//添加到arraylist
                }
            }

            else
                System.out.println("wrong format");
            scentence = input.nextLine();
        }

        //按照学号排序，并输出成绩
        TreeMap<String, Student> sortedMap = new TreeMap<>(students);
        List<String> keys = new ArrayList<String>(sortedMap.keySet());
        for(int i = 0;i < sortedMap.size();i++){
            String num = keys.get(i);
            Student student = sortedMap.get(num);
            int allGrade = 0;
            int addNum = 0;
            for(int j = 0;j<chooseCourses.size();j++){
                if(num.equals(chooseCourses.get(j).student.num)){
                    allGrade = allGrade + chooseCourses.get(j).score.getGrade();
                    addNum++;
                }
            }
            if(addNum == 0){
                System.out.println(student.num+" "+student.name+" did not take any exams");
                break;
            }
            int averageGrade = allGrade/addNum;
            System.out.println(num + " " + student.name + " " + averageGrade);
        }

        //给课程排序
        /*
        TreeMap<String,Course> courseTreeMap = new TreeMap<>(courses);
        Map<String,Course> resultMap = new HashMap<>();
        for(String key : courseTreeMap.keySet()){
            Course course = courseTreeMap.get(key);
            resultMap.put(key,course);
        }

        //输出
        for(String key : resultMap.keySet()){
            Course course = resultMap.get(key);
            System.out.println(key);
        }

         */

        // 创建中文比较器
        Comparator<String> chineseComparator = new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                Collator collator = Collator.getInstance(Locale.CHINA);
                return collator.compare(s1, s2);
            }
        };

        // 将哈希映射中的所有键存储到列表中并按照中文比较器排序
        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 addNum = 0;
            int allGrade = 0;
            int finalGrade = 0;
            int dialyGrade = 0;
            int addNum1 = 0;
            int x = -1;//判断是考试还是考察
            for(int i = 0;i < chooseCourses.size();i++){
                if(key.equals(chooseCourses.get(i).course.name)){
                    if(course.character.equals("必修")){
                        x = 0;//表示为考试
                        allGrade = allGrade + chooseCourses.get(i).score.getGrade();
                        if(chooseCourses.get(i).score instanceof testScore){
                            finalGrade = finalGrade + ((testScore) chooseCourses.get(i).score).finalGrade;
                            dialyGrade = dialyGrade +((testScore) chooseCourses.get(i).score).dialyGrade;
                            addNum++;
                            addNum1++;
                        }
                    }

                    if(chooseCourses.get(i).course.character.equals("选修")){
                        allGrade = allGrade + chooseCourses.get(i).score.getGrade();
                        if(chooseCourses.get(i).course.method.equals("考试")) {
                            x = 0;//表示为考试
                            if (chooseCourses.get(i).score instanceof testScore) {
                                finalGrade = finalGrade + ((testScore) chooseCourses.get(i).score).finalGrade;
                                dialyGrade = dialyGrade + ((testScore) chooseCourses.get(i).score).dialyGrade;
                                addNum++;
                                addNum1++;
                            }
                        }

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

                    //实验
                    if(chooseCourses.get(i).course.method.equals("实验")){
                        x = 1;//表示为实验
                        allGrade = allGrade + chooseCourses.get(i).score.getGrade();
                        addNum++;
                    }
                }
            }
            if(x == -1){
                System.out.println(course.name+" has no grades yet");
            }
            if(x == 0){//考试
                System.out.println(key + " " + dialyGrade/addNum1 +" " + finalGrade/addNum + " " + allGrade/addNum);
            }
            if(x == 2){
                System.out.println(key + " " + finalGrade/addNum + " " + allGrade/addNum);
            }
            if(x == 1){//实验
                System.out.println(key + " " + allGrade/addNum);
            }
        }

        //给班级排序
        TreeMap<String, Class> 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);
            Class classs = classMap.get(num);
            int allGrade = 0;
            int addNum = 0;
            for(int j = 0;j<chooseCourses.size();j++){
                if(num.equals(chooseCourses.get(j).student.num.substring(0,6))){
                    allGrade = allGrade + chooseCourses.get(j).score.getGrade();
                    addNum++;
                }
            }
            if(addNum == 0){
                System.out.println(classs.classNum+" has no grades yet");
                break;
            }
            int averageGrade = allGrade/addNum;
            System.out.println(num + " " + averageGrade);
        }

    }
}


class Class{
    String classNum;
    HashMap<String,Student> student;
}

class Student{
    String num;
    String name;
}

class Course{
    String name;
    String method;
    String character;
}

abstract class score{
    abstract int getGrade();
}

class testScore extends score{
    int finalGrade;
    int dialyGrade;
    @Override
    int getGrade() {
        return (int)(finalGrade * 0.7 + dialyGrade * 0.3);
    }
}

class checkScore extends score{
    int finalGrade;
    @Override
    int getGrade() {
        return finalGrade;
    }
}

class experimentScore extends score{
    ArrayList<Integer> grade = new ArrayList<>();
    @Override
    int getGrade() {
        int allGrade = 0;
        int n = 0;
        for(int i = 0;i < grade.size();i++){
            allGrade = allGrade + grade.get(i);
            n++;
        }
        return (int)(allGrade/n);
    }
}

class chooseCourse{
    Student student;
    Course course;
    score score;
}

　　类图如下：

　　吸取上次的教训，这次题目对于我来说是相当于一次重做，而不是所谓的“迭代”，我重构了原来的代码。其实在上次题目之中，我遇到的比较麻烦的坎就是排序，由于一开始没有考虑清楚，我将所有的数据都用的是数组储存，然而这导致在排序过程中会很麻烦，所以在这一次的代码重构过程中我选择使用HashMap进行储存数据，从而提高了排序的效率。

同时，这次题目相比于上一次的题目所增加的内容就是实验的环节，这就考察了上次的代码有没有考虑到代码的延展性，如果上次代码结构处理的好的话在这里其实不大需要花费太长的时间，然而，我上次的代码确实稀巴烂，不然也不会重构。

oop题目集11

*课程成绩统计程序-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.text.Collator;
import java.util.*;

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

        HashMap<String,Course> courses = new HashMap<>();
        HashMap<String,Student> students = new HashMap<>();
        HashMap<String,Class> classes = new HashMap<>();
        ArrayList<chooseCourse> chooseCourses = new ArrayList<>();
       // ArrayList<Integer> grade = new ArrayList<>()
        Scanner input = new Scanner(System.in);
        String scentence = input.nextLine();
        for(;!scentence.equals("end");){
            if(scentence.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)$") ||
                    scentence.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )((0.(0)+[1-9]|0.[1-9][0-9]*|1)( )(0.(0)+[1-9]|0.[1-9][0-9]*|1)$)") ||
                    scentence.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )([4-9])((( )(0.(0)+[1-9]|0.[1-9][0-9]*|1))*)(( )(0.(0)+[1-9]|0.[1-9][0-9]*|1))$")
            ){
                String []splited = scentence.split(" ");//new String[100];
                if(courses.containsKey(splited[0])) {
                    break;
                }
                if(((splited[1].equals("必修") && splited[2].equals("考试")) ||
                        (splited[1].equals("选修") && (splited[2].equals("考试") || splited[2].equals("考察")))||
                        (splited[1].equals("实验") && splited[2].equals("实验")))){

                        Course course1 = new Course();
                        course1.name = splited[0];
                        course1.character = splited[1];
                        course1.method = splited[2];
                        float allWeight = 0;


                    if((splited[1].equals("实验") && splited[2].equals("实验")) && Integer.parseInt(splited[3]) != (splited.length - 4)){
                        System.out.println(splited[0] + " : number of scores does not match");
                        break;
                    }
                    if(splited[1].equals("考试") && splited.length != 5) {
                        System.out.println(splited[0] + " : number of scores does not match");
                        break;
                    }
                    if(splited[2].equals("考察") && splited.length != 3){
                        System.out.println(splited[0] + " : number of scores does not match");
                        break;
                    }
                    if(splited[2].equals("考试")){
                        allWeight = Float.parseFloat(splited[3])+Float.parseFloat(splited[4]);
                    }
                    if(splited[2].equals("实验")){
                        for(int i = 4;i < splited.length;i++){
                            allWeight += Float.parseFloat(splited[i]);
                        }
                    }
                    if(splited[2].equals("考察")){
                        allWeight = 1;
                    }
                    if(!(allWeight > 0.99 && allWeight < 1.01)){
                        System.out.println(splited[0] + " : weight value error");
                        break;
                    }
                    if(splited[2].equals("考察")){
                        course1.weight.add(allWeight);
                    }
                    if(splited[2].equals("考试")){
                           course1.weight.add(Float.parseFloat(splited[3]));
                           course1.weight.add(Float.parseFloat(splited[4]));
                    }
                    if(splited[2].equals("实验")){
                            for(int i = 4;i < splited.length;i++){
                                 course1.weight.add(Float.parseFloat(splited[i]));
                            }
                    }
                        courses.put(splited[0],course1);

                }
               else{
                    System.out.println(splited[0] + " : course type & access mode mismatch");
                }


            }



            //判断实验
            else if(scentence.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)$") ||
                    scentence.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)( )([0-9]|[1-9][0-9]|100)$") ||
                    scentence.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 []splited = scentence.split(" ");
                //当出现重复课程需要忽略
                for(int i=0;i<chooseCourses.size();i++){
                    if(chooseCourses.get(i).student.num.equals(splited[0]) && chooseCourses.get(i).student.name.equals(splited[1]) &&
                            chooseCourses.get(i).course.name.equals(splited[2])){
                        break;
                    }
                }
                //实例化student，储存信息
                Student student = new Student();
                student.name = splited[1];
                student.num = splited[0];
                students.put(splited[0],student);//把student储存到hashmap里面
                String classNum = splited[0].substring(0,6);
                if(!classes.containsKey(classNum)){
                    Class aClass = new Class();
                    aClass.classNum = classNum;
                    classes.put(classNum,aClass);
                    classes.get(classNum).student = new HashMap<>();
                }
                classes.get(classNum).student.put(splited[0],student);
                if(!courses.containsKey(splited[2])){//判断课程是否存在
                    System.out.println(splited[0] + " does not exist");
                    break;
                }
                else if(courses.get(splited[2]).weight.size() != splited.length - 3){//判断考察方式是否相同
                    System.out.println(splited[0] + " "+splited[1] + " : access mode mismatch");
                    break;
                }
                else {

                    chooseCourse chooseCourse = new chooseCourse();
                    chooseCourse.student = student;
                    chooseCourse.course = courses.get(splited[2]);//对应的课程加入选课系统中
                    score score = new score();
                    for(int i = 3;i < splited.length;i++){
                        score.grade.add(Integer.parseInt(splited[i]));
                    }
                    // 考察的存入成绩
                    chooseCourse.score = score;
                    chooseCourses.add(chooseCourse);//添加到arraylist
                }
            }

            else
                System.out.println("wrong format");
            scentence = input.nextLine();
        }

        //按照学号排序，并输出成绩
        TreeMap<String, Student> sortedMap = new TreeMap<>(students);
        List<String> keys = new ArrayList<String>(sortedMap.keySet());
        for(int i = 0;i < sortedMap.size();i++){
            String num = keys.get(i);
            Student student = sortedMap.get(num);
            int allGrade = 0;
            int addNum = 0;
            for(int j = 0;j<chooseCourses.size();j++){
                if(num.equals(chooseCourses.get(j).student.num)){
                    allGrade = allGrade + chooseCourses.get(j).score.getGrade(chooseCourses.get(j).course);
                    addNum++;
                }
            }
            if(addNum == 0){
                System.out.println(student.num+" "+student.name+" did not take any exams");
                break;
            }
            int averageGrade = allGrade/addNum;
            System.out.println(num + " " + student.name + " " + averageGrade);
        }


        // 创建中文比较器
        Comparator<String> chineseComparator = new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                Collator collator = Collator.getInstance(Locale.CHINA);
                return collator.compare(s1, s2);
            }
        };

        // 将哈希映射中的所有键存储到列表中并按照中文比较器排序
        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 allGrade = 0;
            int addNum = 0;
            for(int j = 0;j<chooseCourses.size();j++){
                if(course.name.equals(chooseCourses.get(j).course.name)){
                    allGrade = allGrade + chooseCourses.get(j).score.getGrade(chooseCourses.get(j).course);
                    addNum++;
                }
            }
            if(addNum == 0){
                System.out.println(course.name+" has no grades yet");
                break;
            }
            int averageGrade = allGrade/addNum;
            System.out.println(course.name + " " + averageGrade);
        }

        //给班级排序
        TreeMap<String, Class> 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);
            Class classs = classMap.get(num);
            int allGrade = 0;
            int addNum = 0;
            for(int j = 0;j<chooseCourses.size();j++){
                if(num.equals(chooseCourses.get(j).student.num.substring(0,6))){
                    allGrade = allGrade + chooseCourses.get(j).score.getGrade(chooseCourses.get(j).course);
                    addNum++;
                }
            }
            if(addNum == 0){
                System.out.println(classs.classNum+" has no grades yet");
                break;
            }
            int averageGrade = allGrade/addNum;
            System.out.println(num + " " + averageGrade);
        }

    }
}


class Class{
    String classNum;
    HashMap<String,Student> student;
}

class Student{
    String num;
    String name;
}

class Course{
    String name;
    String method;
    String character;
    ArrayList<Float> weight = new ArrayList<>();
}

class score{
    ArrayList<Integer> grade = new ArrayList<>();
    int getGrade(Course course){
        float grade1 = 0;
        for(int i = 0; i < course.weight.size(); i++){
            grade1 = grade1 + course.weight.get(i) * grade.get(i);
        }

        return (int) grade1;
    }
}


class chooseCourse{
    Student student;
    Course course;
    score score;
}

类图如下：

　　这一道题相比于上一道题的题目类结构发生了改变。在上一题中，我分别用了三个类计算不同类型数据的成绩，然而在这一道题中，由于考察和考试的课程同之前的实验成绩一样，添加了权重，于是在这里就将之前的成绩计算类合并成了一个类从而大大降低了代码行数，但是不知道由于啥，有些测试点还是过不了，得的分不是很完整。特别说明一下，这里的排序我基本都是将原来的hashmap转换成了treemap，再对数据进行排序（个人认为这种方法比较简单）。

oop题目集09

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

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

分数 100

作者段喜龙

单位南昌航空大学

编写程序统计一个输入的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.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
    public static void main(String[] args) {
        HashMap<String,Integer> hashMap = new HashMap<>();
        String[] keyWord = { "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const",
                "continue", "default", "do", "double", "else", "enum", "extends", "false", "final", "finally", "float",
                "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native", "new",
                "null", "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super",
                "switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "void", "volatile",
                "while" };//关键词数组
        int count = 0;
        Scanner input = new Scanner(System.in);
        String sentence = input.nextLine();
        String code = "";
        for(;!sentence.equals("exit");){//输入代码,拼接代码
            code = code + "\n" + sentence;
            sentence = input.nextLine();
        }
        if(code.isBlank())//判断输入的代码是否为空
            System.out.println("Wrong Format");
        else{
            code.replace("\\[","").replace("\\]","").replace("\\,","");
            code = delete(code);
            code = delete1(code);
            code = delete2(code);
        }
        for(int i = 0;i < keyWord.length; i ++){//数量统计
            Pattern pattern = Pattern.compile("\\b" + keyWord[i] + "\\b");// 创建关键词的正则表达式
            Matcher matcher = pattern.matcher(code);// 字符串与关键词匹配
            count = 0;
            while (matcher.find()) // 找到该关键词的话,记录该关键词的次数
                count++;
            if (count != 0)
                hashMap.put(keyWord[i], count);
        }
        Set set = hashMap.keySet();
        Object[] arr = set.toArray();
        Arrays.sort(arr);
        for (Object k : arr) {
            System.out.println(hashMap.get(k) + "\t" + k);
        }
    }
    public static String delete(String code){//删除字符串的内容
            String regstr = "\".*?\"";
            String tmp = code.replaceAll(regstr," ");
            return tmp;
    }
    public static String delete1(String code){//删除单行注释
        String regstr = "//.*";
        String tmp = code.replaceAll(regstr," ");
        return tmp;
    }
    public static String delete2(String code){//删除多行注释
        String regstr = "/\\*[\\s\\S]*?\\*/";
        String tmp = code.replaceAll(regstr," ");
        return tmp;
    }
}

　　我把这道题单独拿出来分析的原因是，我通过这道题真正掌握了和了解了正则表达式的用法。我是分别写了三个方法——删除字符串的内容、删除单行注释、删除多行注释，然后将代码进行输出。

三、踩坑心得

这一次踩坑最大的当然是浮点数的精度问题了

当时这个权重我直接写的allweight == 1,导致相关测试点过不了，还是在问了同学之后才发现了这个问题。

还有一个坑让我映像深刻

在题目

“7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack”中

这个数组我原本定义的是int 类型，结果导致当stack里面没有数据时，输出的是“0”，而题目测试点给的是“null”.后来在上网查找资料时发现需要用Integer类，而不是int类。

四、改进和建议

总之，这次需要改进的就是自己类的结构的设计，在第一次课程成绩统计的程序中我还仅仅是“面向样例编程”，这个思维简直是太太太低级了，

希望自己能够有点“大局观”，先进行类的设计，再动手，不要太功利性了，不然注定走不长远。

还有就是，不要把所有的功能实现的代码全往主函数里面放，通过写不同的方法和类实现不同的功能进行调用。

五、总结

不足：

1.注意类结构的设计，不要一拿到题目就开始想着过测试点，注意类结构的设计

2.注意单一职责问题，多写类和方法，不要全部放在主函数

进步：

1.熟练掌握了正则表达式

2.同时对Hashset ArrayList HashMap等相关知识点有了更深的理解和掌握

3.同时，我觉得我在态度和心态上有了进步，之前总想逃避问题的我，开始想着怎么解决一个复杂的问题。

l六、最后的最后

教学理念（OBE）:是一种以成果为目标导向的教育理念。对于我来说我还是希望老师可以再给那么多一点点的帮助。

教学方法（边讲边练）：我认为这种方法可以提升学生的动手能力，同时对相应的知识点有更深的映像

教学组织（线上线下混合式教学）：这种线上线下结合的方式，能够提升教学的效率。

教学过程（PTA题目集驱动）：通过这种布置题目的方式，可以提高学生的编码能力，边练边学。但是可以注意题目的连贯性，就比如我们做的原本是日期类的设计，但是中途又突然改成了别人班迭代了几次的菜单题目，难度一下无法接受。

教学模式（BOPPPS）:可以提高学生的参与度，同时提高学生对于知识点的掌握度。

最后的最后：关于Java的博客就到这啦。段老师真的是一位很好的老师，以学生为中心，认真负责（虽然总是给俺们施压，但是我们都知道您刀子嘴豆腐心），希望以后能再上老师的专业课！

完结，撒花！

posted on 2023-06-27 12:54 tiam_sy 阅读(51) 评论(0) 编辑收藏举报

刷新页面返回顶部

tiam-syyy

导航

公告