OOP第三次总结

前言

训练集07

涉及知识点

类设计，正则表达式

题量

代码量十分大

难度

由于前几次菜单问题没有深入研究，对我来说这次作业的难度还是很大

训练集08

涉及知识点

类设计，正则表达式

题量

代码量还是比较大的

难度

相对于前几次菜单问题来说，难度没有那么大，但我还是出现了一些问题，没有满分

训练集09

涉及知识点

Map与Set类的使用，正则表达式

题量

由于老师要求我们尽量少于60行，所以大家都把自己的代码压缩的很少

难度

难度较低，但是要把代码压缩到60行以内还是有些难度

训练集10

涉及知识点

Map类的使用，类设计，继承与多态

题量

成绩统计程序代码量较大，其余三题的代码量都较少

难度

成绩统计程序难度较大，其余三题的难度都较小

训练集11

涉及知识点

类设计，接口的使用，对于Stack类各方法的理解

题量

题量较大且涉及知识较多

难度

难度是这几次作业中最大的

设计与分析

课程成绩统计程序

训练集08 7-1

import java.util.*;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        CourseSelection cs = new CourseSelection();
        String infor1 = input.nextLine();
        while (!infor1.equals("end")){
            String[] infor = infor1.split(" ");
            if(infor.length == 3){
                boolean isRequired = false, isExam = false;
                if(infor[1].equals("必修")){
                    isRequired = true;
                }
                if(infor[2].equals("考试")){
                    isExam = true;
                }
                Course course = new Course(infor[0],isRequired,isExam);
                if(course.check()) {
                    cs.addCourse(course);
                } else {
                    System.out.println(infor[0] + " : course type & access mode mismatch");
                }
            }

            if (infor.length == 4) {
                if (Integer.parseInt(infor[3]) >100)
                    System.out.println("wrong format");
                else {
                    int index1, index2, index;
                    boolean flag = true;

                    Student student = new Student(infor[0], infor[1]);
                    ClassRoom classRoom = new ClassRoom(infor[0].substring(0, 6), student);

                    index1 = cs.containStudent(student.getId());
                    index2 = cs.containClass(classRoom.getName());
                    index = cs.containCourse(infor[2]);

                    if (index1 == -1) {//如果cs.getStudents()中没有student
                        cs.addStudent(student);
                        index1 = cs.containStudent(student.getId());
                    }
                    if (index2 == -1) {//如果cs.getClassRooms()中没有classRoom
                        cs.addClass(classRoom);
                        index2 = cs.containClass(classRoom.getName());
                    }
                    if (index == -1) {//如果cs.getCourses()中没有infor[2]
                        System.out.println(infor[2] + " does not exist");
                        flag = false;
                    }
                    cs.getClassRooms().get(index2).addStudent(cs.getStudents().get(index1));
                    if (flag) {
                        if (cs.getCourses().get(index).isExam())
                            System.out.println(cs.getStudents().get(index1).getId() + " " + cs.getStudents().get(index1).getName() + " : access mode mismatch");
                        else {
                            cs.getCourses().get(index).setScore(new InspectScore(Integer.parseInt(infor[3])));

                            cs.courseAddToStudent(cs.getCourses().get(index), index1);
                            cs.studentAddToCourse(cs.getStudents().get(index1), index);
                        }
                    }
                }
            }
            if (infor.length == 5) {
                if (Integer.parseInt(infor[3]) >100 || Integer.parseInt(infor[4]) >100)
                    System.out.println("wrong format");
                else {
                    int index1, index2, index;
                    boolean flag = true;

                    Student student = new Student(infor[0], infor[1]);
                    ClassRoom classRoom = new ClassRoom(infor[0].substring(0, 6), student);

                    index1 = cs.containStudent(student.getId());
                    index2 = cs.containClass(classRoom.getName());
                    index = cs.containCourse(infor[2]);

                    if (index1 == -1) {//如果cs.getStudents()中没有student
                        cs.addStudent(student);
                        index1 = cs.containStudent(student.getId());
                    }
                    if (index2 == -1) {//如果cs.getClassRooms()中没有classRoom
                        cs.addClass(classRoom);
                        index2 = cs.containClass(classRoom.getName());
                    }
                    if (index == -1) {//如果cs.getCourses()中没有infor[2]
                        System.out.println(infor[2] + " does not exist");
                        flag = false;
                    }
                    cs.getClassRooms().get(index2).addStudent(cs.getStudents().get(index1));
                    if (flag) {
                        if (!cs.getCourses().get(index).isExam())
                            System.out.println(cs.getStudents().get(index1).getId() + " " + cs.getStudents().get(index1).getName() + " : access mode mismatch");
                        else {
                            cs.getCourses().get(index).setScore(new ExamScore(Integer.parseInt(infor[4]), Integer.parseInt(infor[3])));

                            cs.courseAddToStudent(cs.getCourses().get(index), index1);
                            cs.studentAddToCourse(cs.getStudents().get(index1), index);
                        }
                    }
                }
            }
            infor1 = input.nextLine();
        }
        Collections.sort(cs.getStudents(), new Comparator<Student>() {
            public int compare(Student o1, Student o2) {
                return o1.getAverageScore() - o2.getAverageScore();
            }
        });
        Collections.sort(cs.getClassRooms(), new Comparator<ClassRoom>() {
            public int compare(ClassRoom o1, ClassRoom o2) {
                return o1.getAverageScore() - o2.getAverageScore();
            }
        });
        for (Student s:
                cs.getStudents()) {
            if(s.getAverageScore() == 0)
                System.out.println(s.getId() + " " + s.getName() + " did not take any exams");
            else
                System.out.println(s.getId() + " " + s.getName() + " " + s.getAverageScore());
        }
        for (Course c:
             cs.getCourses()) {
            if(c.getAverageScore()  == 0)
                System.out.println(c.getName() + " has no grades yet");
            else {
                if (c.isExam())
                    System.out.println(c.getName() + " " + c.getPerformanceAverage() + " " + c.getFinalAverage() + " " + c.getAverageScore());
                else
                    System.out.println(c.getName() + " " + c.getFinalAverage() + " " + c.getAverageScore());
            }
        }
        for (ClassRoom c:
                cs.getClassRooms()) {
            if(c.getAverageScore()  == 0)
                System.out.println(c.getName() + " has no grades yet");
            else
                System.out.println(c.getName() + " " + c.getAverageScore());
        }
    }
}
class ClassRoom {
    private String name;
    private ArrayList<Student> students = new ArrayList<>();
    public ClassRoom(String name, Student student){
        this.name = name;
        students.add(student);
    }
    public void addStudent(Student student){
        students.add(student);
    }
    public void removeStudent(Student student){
        students.remove(student);
    }
    public int getAverageScore(){
        if(students.isEmpty())
            return 0;
        int sum = 0;
        for (Student s:
             students) {
            sum += s.getAverageScore();
        }
        return sum / students.size();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public ArrayList<Student> getStudents() {
        return students;
    }
    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }
}
class Course {
    private String name;//课程名称
    private boolean isRequired;//是否为必修课
    private boolean isExam;//考核方式是否为考试
    private Score score;//总成绩
    private ArrayList<Student> students = new ArrayList<>();//选这门课学生
    public Course(String name, boolean isRequired, boolean isExam) {
        this.name = name;
        this.isRequired = isRequired;
        this.isExam = isExam;
        if (isExam)
            score = new ExamScore();
        else
            score = new InspectScore();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public boolean isRequired() {
        return isRequired;
    }
    public void setRequired(boolean required) {
        isRequired = required;
    }
    public boolean isExam() {
        return isExam;
    }
    public void setExam(boolean exam) {
        isExam = exam;
    }
    public ArrayList<Student> getStudents() {
        return students;
    }
    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }
    public void addStudent(Student student){
        students.add(student);
    }
    public void removeStudent(Student student){
        students.remove(student);
    }
    public Score getScore() {
        return score;
    }
    public void setScore(Score score) {
        this.score = score;
    }
    public boolean check(){
        if(isRequired != isExam && isRequired)
            return false;
        return true;
    }
    public int getAverageScore(){
        if(students.isEmpty())
            return 0;
        int sum = 0;
        for (Student s:
                students) {
            sum += s.getAverageScore();
        }
        return sum / students.size();
    }
    public int getFinalAverage(){
        if(students.isEmpty())
            return 0;
        int sum = 0;
        for (Student s:
                students) {
            sum += s.getFinalAverage();
        }
        return sum / students.size();
    }
    public int getPerformanceAverage(){
        if(students.isEmpty())
            return 0;
        int sum = 0;
        for (Student s:
                students) {
            sum += s.getPerformanceAverage();
        }
        return sum / students.size();
    }
}
class CourseSelection {
    private ArrayList<Course> courses = new ArrayList<>();
    private ArrayList<Student> students = new ArrayList<>();
    private ArrayList<ClassRoom> classRooms = new ArrayList<>();
    public void addStudent(Student student){
        students.add(student);
    }
    public void removeStudent(Student student){
        students.remove(student);
    }
    public void addCourse(Course course){
        courses.add(course);
    }
    public void removeCourse(Course course){
        courses.remove(course);
    }
    public void studentAddToCourse(Student student, int n){
        courses.get(n).getStudents().add(student);
    }
    public void courseAddToStudent(Course course, int n){
        students.get(n).getCourses().add(course);
    }
    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<ClassRoom> getClassRooms() {
        return classRooms;
    }
    public void setClassRooms(ArrayList<ClassRoom> classRooms) {
        this.classRooms = classRooms;
    }
    public void addClass(ClassRoom classRoom){
        classRooms.add(classRoom);
    }
    public void removeClass(ClassRoom classRoom){
        classRooms.remove(classRoom);
    }
    public int containCourse(String s){
        boolean flag = false;
        int index = 0;
        for (Course c:
             courses) {
            if(c.getName().equals(s)) {
                flag = true;
                index = courses.indexOf(c);
                break;
            }
        }
        if(!flag)
            return -1;
        return index;
    }
    public int containStudent(String s){
        boolean flag = false;
        int index = 0;
        for (Student c:
                students) {
            if(c.getId().equals(s)) {
                flag = true;
                index = students.indexOf(c);
                break;
            }
        }
        if(!flag)
            return -1;
        return index;
    }
    public int containClass(String s){
        boolean flag = false;
        int index = 0;
        for (ClassRoom c:
                classRooms) {
            if(c.getName().equals(s)) {
                flag = true;
                index = classRooms.indexOf(c);
                break;
            }
        }
        if(!flag)
            return -1;
        return index;
    }
}
abstract class Score {
    private int score;//总成绩
    private int finalScore = 0;//期末成绩
    private int performanceScore = 0;//平时成绩
    public Score() {
    }
    public Score(int performanceScore){
        this.performanceScore = performanceScore;
    }
    public Score(int finalScore, int performanceScore) {
        this.finalScore = finalScore;
        this.performanceScore = performanceScore;
    }
    public abstract int getScore();
    public void setScore(int score) {
        this.score = score;
    }
    public int getFinalScore() {
        return finalScore;
    }
    public void setFinalScore(int finalScore) {
        if(finalScore >= 0 && finalScore <= 100)
            this.finalScore = finalScore;
        else
            System.out.println("wrong format");
    }
    public int getPerformanceScore() {
        return performanceScore;
    }
    public void setPerformanceScore(int performanceScore) {
        if(performanceScore >= 0 && performanceScore <= 100)
            this.performanceScore = performanceScore;
        else
            System.out.println("wrong format");
    }
    public boolean check(){
        if(finalScore >= 0 && finalScore <= 100 && performanceScore >= 0 && performanceScore <= 100)
            return true;
        return false;
    }
}
class Student {
    private String id;
    private String name;
    private ArrayList<Course> courses = new ArrayList<>();
    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<Course> getCourses() {
        return courses;
    }
    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }
    public void addCourse(Course course){
        courses.add(course);
    }
    public void removeCourse(Course course){
        courses.remove(course);
    }
    public Student(String id, String name){
        this.id = id;
        this.name = name;
    }
    public int getAverageScore(){
        if(courses.isEmpty())
            return 0;
        int sum = 0;
        for (Course c:
             courses) {
            sum += c.getScore().getScore();
        }
        return sum / courses.size();
    }
    public int getFinalAverage(){
        if(courses.isEmpty())
            return 0;
        int sum = 0;
        for (Course c:
                courses) {
            sum += c.getScore().getFinalScore();
        }
        return sum / courses.size();
    }
    public int getPerformanceAverage(){
        if(courses.isEmpty())
            return 0;
        int sum = 0;
        for (Course c:
                courses) {
            sum += c.getScore().getPerformanceScore();
        }
        return sum / courses.size();
    }
}
class ExamScore extends Score{
    public ExamScore() {
    }
    public ExamScore(int finalScore, int performanceScore){
        setFinalScore(finalScore);
        setPerformanceScore(performanceScore);
    }
    public int getScore(){
        return (int)(getFinalScore() * 0.7 + getPerformanceScore() * 0.3);
    }
}
class InspectScore extends Score{
    public InspectScore() {
    }
    public InspectScore(int finalScore){
        setFinalScore(finalScore);
    }
    public int getScore(){
        return getFinalScore();
    }
}

之前对菜单计价程序没有上心，所以本次课程成绩统计系统算是我第一次开写这种代码量大的迭代程序。根据老师给出的参考类图做了类的设计，但是思路不是很明确，后来根据自己的理解重新设计了各类的功能，在选课类CourseSelection中加入了几个课程学生班级的ArrayList，为了统计学生和课程的平均分，在学生类中添加了课程的ArrayList作为学生所选的课程，在课程类中加入了学生的ArrayList作为选这门课的学生。这样设计在只有一位学生时可以正常存入、计算成绩，但是在有多名学生的时候，最后输入的那名学生的成绩会覆盖之前所有人的成绩。

在参考了其他人的代码之后，对类的设计进行了重构.

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.text.Collator;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String s_record = s.nextLine();
        ParseInput handle = new ParseInput();
        while (!s_record.equals("end")) {
            handle.parseInput(s_record);// 解析用户输入的每一行数据
            s_record = s.nextLine();
        }
        handle.showStudents();
        handle.showCourses();
        handle.showClasses();
    }
}

class Class implements Comparable{
    String num;
    int averg;
    Student stu;
    Class(String num,int averg)
    {
        this.averg = averg;
        this.num = num;
    }
    Class(String num)
    {
        this.num = num;
    }
    public String getNum() {
        return num;
    }
    public void setNum(String num) {
        this.num = num;
    }
    public int getAverg() {
        return averg;
    }
    public void setAverg(int averg) {
        this.averg = averg;
    }
    @Override
    // public int compareTo(Object arg) {
    //     // TODO Auto-generated method stub
    //      if(arg instanceof Class){
    //            Class goods = (Class) arg;
    //             if(this.averg<goods.averg) return -1;
    //             else
    //                 return 1;
    //         }
    //        throw new RuntimeException("传入的数据类型不一致");
    //     }

        public int compareTo(Object o) {
        // TODO Auto-generated method stub
         if(o instanceof Class){
               Class goods = (Class) o;
                if(this.num.compareTo(goods.num)<0) return -1;
                else
                    return 1;
            }
           throw new RuntimeException("传入的数据类型不一致");
        }
    }
    
class Course implements Comparable{
    String type;
    String name;
    String bcho;
    int ccave;
    int nnave;
    int ffave;
    Course(String name,String type,String bcho)
    {
        this.bcho = bcho;
        this.name = name;
        this.type = type;
    }
    public String getBcho() {
        return bcho;
    }

    public void setBcho(String bcho) {
        this.bcho = bcho;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
//    @Override
//    public int compareTo(Object 0) {
//        // TODO Auto-generated method stub
//         if(o instanceof Course){
//               Course goods = (Course) o;
//                if(this.ccave<goods.ccave) return -1;
//                else
//                    return 1;
//            }
//           throw new RuntimeException("传入的数据类型不一致");
//        }
//    }
    // public int compareTo(Object agro) {
    //     // TODO Auto-generated method stub
    //      if(agro instanceof Course){
    //            Course goods = (Course) agro;
    //             if(this.ccave<goods.ccave) return -1;
    //             else
    //                 return 1;
    //         }
    //        throw new RuntimeException("传入的数据类型不一致");
    //     }
        public int compareTo(Object o) {
        // TODO Auto-generated method stub
         if(o instanceof Course){
               Course goods = (Course) o;
//                if(this.ccave<goods.ccave) return -1;
//                else
//                    return 1;
              Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
                return compare.compare(name,goods.name);
            }
           throw new RuntimeException("传入的数据类型不一致");
        }
    public int compareTo(Course o) {
        Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(name,o.getName());
    }
    }

class InputMatching {
    static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
    static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String scoreMatching = "([1-9]?[0-9]|100)";
    static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String courseTypeMatching = "(选修|必修|实验)";
    static String checkcourseTypeMatching = "(考试|考察|实验)";
    //cousrInput用于定义课程信息模式（正则表达式）
    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
    //scoreInput用于定义成绩信息模式（正则表达式）
    static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching + "(scoreMatching)?";

    public static int matchingInput(String s) {
        if (matchingCourse(s)) {
            return 1;
        }
        if (matchingScore(s)) {
            return 2;
        }
            return 0;
    }

    private static boolean matchingCourse(String s) {
        return s.matches(courseInput);
    }

    private static boolean matchingScore(String s) {
        //System.out.println(match);
        return s.matches(scoreInput);
    }
}

class ParseInput {
    InputMatching im;
    ArrayList<Course> classlist = new ArrayList<>();
    ArrayList<Student> stulist = new ArrayList<>();
    ArrayList<Class> clist = new ArrayList<>();
    ArrayList<St> ss = new ArrayList<>();
    public void parseInput(String s_record) {
        // TODO Auto-generated method stub
        String[] swd = s_record.split(" ");
                if (im.matchingInput(s_record) == 1) {
            String[] a = s_record.split(" ");
            if (a[1].equals("必修") == true && a[2].equals("考察") == true) {
                System.out.println(a[0] + " : course type & access mode mismatch");
                return;
            }
            if(a[1].equals("实验")==true&&a[2].equals("实验")==false)
            {
                System.out.println(a[0] + " : course type & access mode mismatch");
                return;
            }
            if(a[2].equals("实验")==true&&a[1].equals("实验")==false)
            {
                System.out.println(a[0] + " : course type & access mode mismatch");
                return;
            }
            Course cls = new Course(a[0], a[1], a[2]);
            if (judecls(classlist, a[0]) == null) {
                classlist.add(cls);
            }
        }
        if(im.matchingInput(s_record) !=1&&swd.length<=5) {
            String[] a = s_record.split(" ");
            if (a.length == 4) {
                Course clss;
                clss = judecls(classlist, a[2]);
                if (clss == null) {
                    System.out.println(a[2] + " does not exist");
                    dd(a[0],a[1]);
                    if(jude(clist,a[0].substring(0,6))==null)
                    {
                    Class cl = new Class(a[0].substring(0,6));
                    clist.add(cl);
                    }
                    return;
                } 
                else {
                    if (clss.bcho.equals("考试") == true) {
                        System.out.println(a[0] + " " + a[1] + " : access mode mismatch");
                        // 学号+英文空格+姓名+英文空格+": access mode mismatch"
                        dd(a[0],a[1]);
                        if(jude(clist,a[0].substring(0,6))==null)
                        {
                        Class cl = new Class(a[0].substring(0,6));
                        clist.add(cl);
                        }
                        return;
                    } else {
                        int grade;
                        grade = Integer.valueOf(a[3]);
                        if(grade>100||grade<0)
                        {
                            System.out.println("wrong format");
                            return;
                        }
                        Student stu = new Student(a[0], a[1], clss, grade);
                        if(jude(clist,a[0].substring(0,6))==null)
                        {
                        Class cl = new Class(a[0].substring(0,6));
                        clist.add(cl);
                        }
                        stu.setfinal(grade);
                        stulist.add(stu);
                        dd(a[0],a[1]);
                    }
                }
            } 
            else {
                Course clss;
                clss = judecls(classlist, a[2]);
                if (clss == null) {
                    System.out.println(a[0] + " " + a[1] + " :" + a[2] + " does not exist");
                    System.out.println(a[2] + " does not exist");
                    // 学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
                    dd(a[0],a[1]);
                    if(jude(clist,a[0].substring(0,6))==null)
                    {
                    Class cl = new Class(a[0].substring(0,6));
                    clist.add(cl);
                    }
                    return;
                } else {
                    if (clss.bcho.equals("考核") == true) {
                        //System.out.println(a[0] + " " + a[1] + " : access mode mismatch");
                        // 学号+英文空格+姓名+英文空格+": access mode mismatch"
                        dd(a[0],a[1]);
                        if(jude(clist,a[0].substring(0,6))==null)
                        {
                        Class cl = new Class(a[0].substring(0,6));
                        clist.add(cl);
                        }
                        return;
                    } else {
                        int egrade, ngrade;
                        ngrade = Integer.valueOf(a[3]);
                        egrade = Integer.valueOf(a[4]);
                        if(ngrade>100||egrade<0||ngrade<0||egrade>100)
                        {
                            System.out.println("wrong format");
                            return;
                        }
                        Student stu = new Student(a[0], a[1], clss, egrade, ngrade);
                        if(jude(clist,a[0].substring(0,6))==null)
                        {
                        Class cl = new Class(a[0].substring(0,6));
                        clist.add(cl);
                        }
                        stu.setFinal(egrade, ngrade);
                        stulist.add(stu);
                        dd(a[0],a[1]);
                    }
                }
            }
        }
        if(im.matchingInput(s_record) !=1&&swd.length>5)
        {
            if(s_record.indexOf("end")!=-1)
                return;
            String[] a = s_record.split(" ");
            int n = a.length - 4;
            int num =  Integer.valueOf(a[3]);
            if(num==3)
            {
                System.out.println("wrong format");
                return;
            }
            if(n!=num)
            {
                System.out.println(a[0]+" "+a[1]+" : access mode mismatch");
                if(jude(clist,a[0].substring(0,6))==null)
                {
                Class cl = new Class(a[0].substring(0,6));
                clist.add(cl);
                }
                dd(a[0],a[1]);
                return;
            }
            int[] x = new int[num];
            int sum = 0;
            for(int i=0;i<num;i++)
            {
                x[i]= Integer.valueOf(a[4+i]);
                sum = sum +x[i];
                if(x[i]>100||x[i]<0)
                {
                    System.out.println("wrong format");
                    return;
                }
            }
            Course clss;
            clss = judecls(classlist, a[2]);
            if (clss == null) {
                // System.out.println(a[0] + " " + a[1] + " :" + a[2] + " does not exist");
                // 学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
                System.out.println(a[2] + " does not exist");
            }
            Student st = new Student(a[0],a[1],clss,sum/num);
            if(jude(clist,a[0].substring(0,6))==null)
            {
            Class cl = new Class(a[0].substring(0,6));
            clist.add(cl);
            }
            stulist.add(st);
            st.setFinal_grade(sum/num);
            dd(a[0],a[1]);
    }
    }
    public Course judecls(ArrayList<Course> cls, String name) {
        for (int i = 0; i < cls.size(); i++) {
            if (cls.get(i).name.equals(name) == true)
                return cls.get(i);
        }
        return null;
    }
    
    public Class jude(ArrayList<Class> cls, String num) {
        for (int i = 0; i < cls.size(); i++) {
            if (cls.get(i).num.equals(num) == true)
                return cls.get(i);
        }
        return null;
    }
    
    public St jugde(ArrayList<St> cls, String id) {
        for (int i = 0; i < cls.size(); i++) {
            if (cls.get(i).id.equals(id) == true)
                return cls.get(i);
        }
        return null;
    }
    
    public void dd(String s,String n)
    {
        St stt = new St(s,n);
        if(jugde(ss,s)==null)
            ss.add(stt);
    }

    public void showStudents() {
        // TODO Auto-generated method stub
//        Collections.sort(stulist);
//        for (int i = 0; i < stulist.size(); i++) {
//            Student st = stulist.get(i);
//            System.out.println(st.id + " " + st.name + " " + st.final_grade);
//        }
        int sum = 0;
        int n = 0;
        for (int i = 0; i < ss.size(); i++) {
            for (int j = 0; j < stulist.size(); j++) {
                if (ss.get(i).id.equals(stulist.get(j).id) == true) {
                    sum = sum + stulist.get(j).final_grade;
                    n++;
                }
            }
            if (n == 0)
                System.out.println(ss.get(i).id+" "+ss.get(i).name + " did not take any exams");
            else {
                ss.get(i).aevv = sum / n;
            }
            sum = 0;
            n = 0;
        }
        Collections.sort(ss);
        for (int i = 0; i < ss.size(); i++) {
            St cs = ss.get(i);
            if(cs.aevv!=0)
            System.out.println(cs.id+" "+cs.name+" "+cs.aevv);
        }
    }

    public void showCourses() {
        // TODO Auto-generated method stub
        int sum = 0;
        int n = 0;
        int esum = 0;
        int nsum = 0;
        for (int i = 0; i < classlist.size(); i++) {
            for (int j = 0; j < stulist.size(); j++) {
                if (classlist.get(i).name.equals(stulist.get(j).cls.name) == true) {
                    if (classlist.get(i).bcho.equals("考试") == true) {
                        nsum = nsum + stulist.get(j).nor_grade;
                    }
                    esum = esum + stulist.get(j).exa_grade;
                    sum = sum + stulist.get(j).final_grade;
                    n++;
                }
            }
            if (n == 0)
                System.out.println(classlist.get(i).name + " has no grades yet");
            else {
                classlist.get(i).ccave = sum / n;
                classlist.get(i).ffave = esum / n;
                if (classlist.get(i).bcho.equals("考试") == true)
                    classlist.get(i).nnave = nsum / n;
            }
            sum = 0;
            n = 0;
            esum = 0;
            nsum = 0;
        }
        Collections.sort(classlist);
  //       for(int i =0;i<classlist.size()-1;i++)
        // {
        //     Course cc = classlist.get(i);
        //     cc.compareTo(classlist.get(i+1));
        // }
        for (int i = 0; i < classlist.size(); i++) {
            Course cs = classlist.get(i);
            if(cs.ffave!=0)
            {
            if(classlist.get(i).bcho.equals("考试") == true)
                System.out.println(cs.name+" "+cs.nnave+" "+cs.ffave+" "+cs.ccave);
            if(classlist.get(i).bcho.equals("考察") == true)
                System.out.println(cs.name+" "+cs.ffave+" "+cs.ccave);
            if(classlist.get(i).bcho.equals("实验") == true)
                System.out.println(cs.name+" "+cs.ccave);
            }
        }
    }

    public void showClasses() {
         //TODO Auto-generated method stub
        int sum = 0;
        int n = 0;
        for (int i = 0; i < clist.size(); i++) {
            for (int j = 0; j < stulist.size(); j++) {
                if (clist.get(i).num.equals(stulist.get(j).id.substring(0, 6)) == true) {
                    sum = sum + stulist.get(j).final_grade;
                    n++;
                }
            }
            if (n == 0)
                System.out.println(clist.get(i).num + " has no grades yet");
            else {
                clist.get(i).averg = sum / n;
            }
            sum = 0;
            n = 0;
        }
        Collections.sort(clist);
        for (int i = 0; i < clist.size(); i++) {
            Class cs = clist.get(i);
            if(cs.averg!=0)
            System.out.println(cs.num+" "+cs.averg);
        }
    }
}


class St implements Comparable{
    String id;
    Student stu;
    String name;
    int aevv;
    St(String id,String name)
    {
        this.id=id;
        this.name = name;
    }
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
         if(o instanceof St){
               St goods = (St) o;
                if(this.id.compareTo(goods.id)<0) return -1;
                else
                    return 1;
            }
           throw new RuntimeException("传入的数据类型不一致");
        }
}


class Student implements Comparable{
    Course cls;
    String id;
    String name;
    int final_grade;
    int nor_grade;
    int exa_grade;
    int avv;
    Student(String id,String name,Course cls,int exa_grade)
    {
        this.name = name;
        this.cls = cls;
        this.id=id;
        this.exa_grade = exa_grade;
    }
    Student(String id,String name,Course cls,int exa_grade,int nor_grade)
    {
        this.name = name;
        this.cls = cls;
        this.id=id;
        this.exa_grade = exa_grade;
        this.nor_grade = nor_grade;
    }
//    Student(String id,String name,Course cls,int final_grade)
//    {
//        this.name = name;
//        this.cls = cls;
//        this.id=id;
//        this.final_grade = final_grade;
//    }
    public void setfinal(int exa_grade)
    {
        final_grade = exa_grade;
    }
    public void setFinal(int exa_grade,int nor_grade)
    {
        final_grade = (int)(exa_grade*0.7 + nor_grade*0.3);
    }
    public Course getCls() {
        return cls;
    }

    public void setCls(Course cls) {
        this.cls = cls;
    }

    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 int getFinal_grade() {
        return final_grade;
    }

    public void setFinal_grade(int final_grade) {
        this.final_grade = final_grade;
    }

    public int getNor_grade() {
        return nor_grade;
    }

    public void setNor_grade(int nor_grade) {
        this.nor_grade = nor_grade;
    }

    public int getExa_grade() {
        return exa_grade;
    }

    public void setExa_grade(int exa_grade) {
        this.exa_grade = exa_grade;
    }
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
         if(o instanceof Student){
               Student goods = (Student) o;
                if(this.id.compareTo(goods.id)<0) return -1;
                else
                    return 1;
            }
           throw new RuntimeException("传入的数据类型不一致");
        }
}

以上是课程成绩统计程序-2 的代码。

使用了正则表达式对输入的所有情况进行匹配，并且大幅降低了各类的耦合度。

训练集09 7-1

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

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String[] checkCode,keyWord = {"abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "default", "do", "double", "else", "enum", "extends", "final", "finally", "float", "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native", "new", "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "try", "void", "volatile", "while", "true", "false", "null"};
        Map<String, Integer> map = new TreeMap<>();
        Set<String> set = new HashSet<>();
        for (String kw : keyWord) {
            set.add(kw);
        }
        StringBuilder sb = new StringBuilder();
        String str;
        while (!(str = input.nextLine()).equals("exit")) {
            sb.append(str).append("\n");
        }
        String code = sb.toString();
        if (code.isEmpty()){
            System.out.println("Wrong Format");
            System.exit(0);
        }
        String regex = String.join("|",set);
        for (String word : code.split("\\s+|\\W+")) {
            if (word.matches(regex))
                map.put(word, map.getOrDefault(word, 0) + 1);
        }
        check(code, regex, "\\\"(.*)\\\"", map);
        check(code, regex, "\\/\\*(.*)\\*\\/", map);
        check(code, regex, "\\/\\/(.*)", map);
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getValue() + "\t" + entry.getKey());
        }
    }
    public static void check(String code, String regex1, String regex2, Map<String, Integer> map){
        Pattern pattern = Pattern.compile(regex2);
        Matcher matcher = pattern.matcher(code);
        while (matcher.find()){
            String sub = code.substring(matcher.start(), matcher.end());
            String[] checkCode = sub.split("\\s+|\\W+");
            for (String c: checkCode) {
                if (c.matches(regex1))
                    map.put(c, map.get(c) - 1);
                if (map.get(c) != null)
                    if (map.get(c) == 0)
                        map.remove(c);
            }
        }
    }
}

为了压缩代码行数，去学习了Matcher和Pattern类的简单使用，用于匹配不同方式分隔后的关键词。但还是存在一定问题。

自己多次测试了[]以及,分隔和//以及/* */两种注释的情况，答案没有出现错误，但是没有通过测试点。针对这两种情况我的正则表达式应该是包括了的，让我有些不得其解。

训练集10

7-1

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Map<String, String> map = new HashMap<>();
        String str;
        while (!(str = input.nextLine()).equals("end")){
            String[] infor = str.split(" ");
            map.put(infor[0], infor[1] + " " + infor[2]);
        }
        String id = input.nextLine();
        map.forEach((key, value) -> {
            if (key.equals(id)) {
                System.out.println(key + " " + value);
                System.exit(0);
            }
        });
        System.out.println("The student " + id + " does not exist");
    }
}

仅需将输入按空格分割后，将学号作为key，名字与成绩一起作为value存入Map中即可。

7-2

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Map<Integer, String> map = new HashMap<>();

        String str;
        while (!(str = input.nextLine()).equals("end")) {
            String[] infor = str.split(" ");
            map.put(Integer.parseInt(infor[0]), infor[1] + " " + infor[2]);
        }
        Map<Integer, String> treeMap = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        map.forEach((key, value) -> {
            treeMap.put(key, value);
        });
        treeMap.forEach((key, value) -> {
            System.out.println(key + " " + value);
        });
    }
}

本题思路与上题一致，但是需要使用TreeMap的有参构造方法，使TreeMap按照学号大小排序。

训练集11

7-1

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

class Student {
    private String id;
    private String name;
    private int mathScore;
    private int physicsScore;

    public Student(String id, String name, int mathScore, int physicsScore) {
        this.id = id;
        this.name = name;
        this.mathScore = mathScore;
        this.physicsScore = physicsScore;
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getMathScore() {
        return mathScore;
    }

    public int getPhysicsScore() {
        return physicsScore;
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();

        Scanner scanner = new Scanner(System.in);

        while (true) {
            String input = scanner.nextLine();
            if (input.equals("end")) {
                break;
            }

            String[] info = input.split(" ");
            String id = info[0];
            String name = info[1];
            int mathScore = Integer.parseInt(info[2]);
            int physicsScore = Integer.parseInt(info[3]);

            Student student = new Student(id, name, mathScore, physicsScore);
            students.add(student);
        }

        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int sum1 = s1.getMathScore() + s1.getPhysicsScore();
                int sum2 = s2.getMathScore() + s2.getPhysicsScore();

                return sum2 - sum1;
            }
        });

        for (Student student : students) {
            int sum = student.getMathScore() + student.getPhysicsScore();
            System.out.println(student.getId() + " " + student.getName() + " " + sum);
        }
    }
}

一开始没想到可以直接在创建一个学生类来存储信息，初建了两个Map一个用于存入信息一个用于排序，十分麻烦。

创建一个学生类存储信息后变得十分简单。

7-2

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = Integer.parseInt(input.nextLine());
        ArrayList<Id> arrayList = new ArrayList<>();
        for (int i = 0; i < n; i ++){
            arrayList.add(new Id(input.nextLine()));
        }
        String str = input.nextLine();

        while (str.equals("sort1") || str.equals("sort2")){
            if (str.equals("sort1")){
                Collections.sort(arrayList, new Comparator<Id>() {
                    @Override
                    public int compare(Id o1, Id o2) {
                        return Integer.parseInt(o1.getId().substring(6, 14)) - Integer.parseInt(o2.getId().substring(6, 14));
                    }
                });
                for (Id i:
                        arrayList) {
                    System.out.println(i.getYear() + "-" + i.getMonth() + "-" + i.getDay());
                }
            }
            if (str.equals("sort2")){
                Collections.sort(arrayList, new Comparator<Id>() {
                    @Override
                    public int compare(Id o1, Id o2) {
                        return Integer.parseInt(o1.getId().substring(6, 14)) - Integer.parseInt(o2.getId().substring(6, 14));
                    }
                });
                for (Id i:
                     arrayList) {
                    System.out.println(i.getId());
                }
            }
            str = input.nextLine();
        }
        if (!str.equals("sort1") && !str.equals("sort2")){
            System.out.println("exit");
            System.exit(0);
        }
    }
}
class Id {
    private String id;
    private String year;
    private String month;
    private String day;

    public String getId() {
        return id;
    }

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

    public String getYear() {
        return year;
    }

    public void setYear(String year) {
        this.year = year;
    }

    public String getMonth() {
        return month;
    }

    public void setMonth(String month) {
        this.month = month;
    }

    public String getDay() {
        return day;
    }

    public void setDay(String day) {
        this.day = day;
    }

    public Id(String id){
        this.id = id;
        year = id.substring(6,10);
        month = id.substring(10,12);
        day = id.substring(12,14);
    }
}

本题特殊之处就是需要用到Collections.sort方法编写对ArrayList的排序规则。

7-4

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        ArrayIntegerStack stack = new ArrayIntegerStack(n);

        int m = input.nextInt();

        for (int i = 0; i < m; i++) {
            int value = input.nextInt();
            Integer result = stack.push(value);
            System.out.println(result);
        }

        System.out.println(stack.peek() + "," +stack.empty() + "," +stack.size());
        System.out.println(Arrays.toString(stack.getStack()));

        int x = input.nextInt();
        for (int i = 0; i < x; i++) {
            Integer result = stack.pop();
            System.out.println(result);
        }

        System.out.println(stack.peek() + "," +stack.empty() + "," +stack.size());
        System.out.println(Arrays.toString(stack.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 Integer[] stack;
    private int top;
    private int maxSize;

    public ArrayIntegerStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new Integer[maxSize];
        top = -1;
    }

    @Override
    public Integer push(Integer item) {
        if (item == null || top >= maxSize - 1) {
            return null;
        }

        stack[++top] = item;

        return item;
    }

    @Override
    public Integer pop() {
        if (empty()) {
            return null;
        }

        Integer item = stack[top];
        top--;
        return item;
    }

    @Override
    public Integer peek() {
        if (empty()) {
            return null;
        }

        return stack[top];
    }

    @Override
    public boolean empty() {
        return top == -1;
    }

    @Override
    public int size() {
        return top + 1;
    }

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

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

    public int getTop() {
        return top;
    }

    public void setTop(int top) {
        this.top = top;
    }

    public int getMaxSize() {
        return maxSize;
    }

    public void setMaxSize(int maxSize) {
        this.maxSize = maxSize;
    }
}

要用数组实现Stack类的各种方法，想要理清栈顶元素的index还是有些困难。

7-5

import java.util.*;

class PersonOverride {
    private String name;
    private int age;
    private boolean gender;
    
    public PersonOverride() {
        this("default", 1, true);
    }
    
    public PersonOverride(String name, int age, boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    @Override
    public String toString() {
        return name + "-" + age + "-" + gender;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        
        PersonOverride other = (PersonOverride) obj;
        return name.equals(other.name) &&
                age == other.age &&
                gender == other.gender;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n1 = scanner.nextInt();
        PersonOverride[] persons1 = new PersonOverride[n1];
        for (int i = 0; i < n1; i++) {
            persons1[i] = new PersonOverride();
        }

        int n2 = scanner.nextInt();
        PersonOverride[] persons2 = new PersonOverride[n2];
        for (int i = 0; i < n2; i++) {
            String name = scanner.next();
            int age = scanner.nextInt();
            boolean gender = scanner.nextBoolean();

            PersonOverride person = new PersonOverride(name, age, gender);
            boolean exists = false;
            for (PersonOverride p : persons2) {
                if (p != null && p.equals(person)) {
                    exists = true;
                    break;
                }
            }
            if (!exists) {
                persons2[i] = person;
            }
        }

        for (PersonOverride person : persons1) {
            System.out.println(person);
        }

        for (PersonOverride person : persons2) {
            if (person != null) {
                System.out.println(person);
            }
        }

        int count = 0;
        for (PersonOverride person : persons2) {
            if (person != null) {
                count++;
            }
        }
        System.out.println(count);

        System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
}

总结

经过本阶段的学习，能看到自己的进步，但更多的还是发现了自己的不足。

1、通过和其他同学代码的对比，我缺少边写代码边写注释的习惯，特别是在写课程成绩统计程序这种时间跨度较大，代码量也大的程序的时候，需要花很多时间去重新浏览并且理解一遍各代码的功能。

2、对类的设计理解不够，自己做的类设计无法像老师给出的参考类图一般各类功能明确并且耦合度低。