BLOG3作业总结

import java.util.*;
import java.text.Collator;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Course[] course = new Course[100];
        Student[] student = new Student[100];
        Cls[] cls = new Cls[100];
        int courseCount = 0;                            //课程数量
        int studentCount = 0;                           //学生数量
        int classCount = 0;                             //班级数量
        /*获取输入*/
        StringBuilder sb = new StringBuilder();
        HashSet<String> set = new HashSet<>();
        while (sc.hasNextLine()) {
            String s = sc.nextLine();
            if (s.equals("end")) {
                break;
            }
            if (set.add(s)) { // 添加成功则说明是第一次出现的行，才将其加入 StringBuilder 中
                sb.append(s).append("\n");
            }
        }
        String str = sb.toString();
        String[] lines = str.split("\n");
        for(String line : lines)
        {
            String[] words = line.split(" ");
            boolean repeat = false;
            if(InputMatching.matchingInput(line)==1)
            {
                for(int i=0;i<courseCount;i++){
                    if(words[0].equals(course[i].getName())){
                        repeat = true;
                        break;
                    }
                }if(repeat) continue;
                course[courseCount] = new Course();
                course[courseCount].setName(words[0]);
                /*选修与必修*/
                switch (words[1]) {
                    case "必修":
                        course[courseCount].required = true;
                        break;
                    case "选修":
                        course[courseCount].required = false;
                        break;
                    case "实验":
                        course[classCount].pre = true;
                        break;
                }
                /*考试与考察与实验*/
                boolean pra = false;
                if(words[1].equals("实验")){
                    pra = true;
                    if(words[2].equals("实验")){
                        course[courseCount].pre = true;
                    }else {
                        course[courseCount].format = false;
                        System.out.println(words[0]+" : course type & access mode mismatch");
                        course[courseCount].setName(null);
                    }
                }
                if(course[courseCount].required&&!pra) {
                    course[courseCount].test = true;
                    if(words[2].equals("考察")||words[2].equals("实验")){
                        course[courseCount].format = false;
                        System.out.println(words[0]+" : course type & access mode mismatch");
                        course[courseCount].setName(null);
                    }
                }else if(!pra){
                    switch (words[2]) {
                        case "考试":
                            course[courseCount].test = true;
                            break;
                        case "考察":
                            course[courseCount].test = false;
                            break;
                        case "实验":
                            course[courseCount].format = false;
                            System.out.println(words[0] + " : course type & access mode mismatch");
                            course[courseCount].setName(null);
                            break;
                    }
                }

                courseCount++;
            }
            else if(InputMatching.matchingInput(line)==2||words.length>=5)
            {
                boolean mistake = false;
                if(Integer.parseInt(words[3])>100){
                    System.out.println("wrong format");
                    continue;
                }
                if(words.length>5){
                    if(Integer.parseInt(words[3])<4||Integer.parseInt(words[3])>9){
                        System.out.println("wrong format");
                        continue;
                    }try {
                        for (int i = 0; i < Integer.parseInt(words[3]); i++) {
                            if (Integer.parseInt(words[i + 4]) > 100 || Integer.parseInt(words[i + 4]) < 0) {
                                mistake = true;
                            }
                        }
                    }catch (ArrayIndexOutOfBoundsException ignored){

                    }
                    if(mistake) {
                        System.out.println("wrong format");
                        continue;
                    }
                }
                int courseIndex = 0;
                int classIndex = 0;
                int studentIndex = 0;
                boolean exist = false;
                boolean createStudent = true;
                boolean createClass = true;
                String classID = words[0].substring(0,6);
                /*获取课程下标*/
                for(int i=0;i<courseCount;i++){
                    if(words[2].equals(course[i].getName())){
                        courseIndex = i;
                        exist = true;
                        break;
                    }
                }
                /*不存在课程*/
                if(!exist){
                    System.out.println(words[2]+" does not exist");
                }
                /*已存在该班*/
                for(int i=0;i<classCount;i++){
                    if(classID.equals(cls[i].getID())){
                        createClass = false;
                        classIndex = i;
                        break;
                    }
                }
                if(createClass){
                    classIndex = classCount;
                    cls[classCount] = new Cls();
                    cls[classCount].setID(classID);
                    classCount++;
                }
                /*已存在该学生*/
                for(int i=0;i<studentCount;i++){
                    if(words[0].equals(student[i].getID())){
                        createStudent = false;
                        studentIndex = i;
                        break;
                    }
                }
                if(createStudent) {
                    student[studentCount] = new Student();
                    student[studentCount].setID(words[0]);
                    student[studentCount].setName(words[1]);
                    if(words.length==4){
                        if(course[courseIndex].pre){
                            System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
                            continue;
                        }
                        if(course[courseIndex].test){
                            if(exist)
                                System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
                            student[studentCount].format = false;
                        }else{
                            student[studentCount].setScore(Integer.parseInt(words[3]));
                            course[courseIndex].setTestScore(Integer.parseInt(words[3]));
                            course[courseIndex].setScore(Integer.parseInt(words[3]));
                            cls[classIndex].setScore(Integer.parseInt(words[3]));
                        }
                    }else if(words.length==5){
                        if(course[courseIndex].pre){
                            System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
                            continue;
                        }
                        if(!course[courseIndex].test){
                            if(exist)
                                System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
                            student[studentCount].format = false;
                        }else{
                            student[studentCount].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
                            cls[classIndex].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
                            course[courseIndex].setTestScore(Integer.parseInt(words[4]));
                            course[courseIndex].setTimeScore(Integer.parseInt(words[3]));
                            course[courseIndex].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
                        }
                    }else if(words.length<8){
                        System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
                    }else {
                        double theWhole = 0;
                        double theAverage;
                        int thePre = Integer.parseInt(words[3]);
                        if(words.length-4 != thePre){
                            System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
                            continue;
                        }
                        for(int i = 0;i<thePre;i++){
                            theWhole += Integer.parseInt(words[i+4]);
                        }
                        theAverage = theWhole / thePre;
                        student[studentCount].setScore(theAverage);
                        course[courseIndex].setScore(theAverage);
                        cls[classIndex].setScore(theAverage);
                    }
                    studentCount++;
                }else {
                    if(words.length==4){
                        if(course[courseIndex].test){
                            if(exist)
                                System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
                            student[studentIndex].format = false;
                        }else{
                            student[studentIndex].setScore(Integer.parseInt(words[3]));
                            course[courseIndex].setTestScore(Integer.parseInt(words[3]));
                            course[courseIndex].setScore(Integer.parseInt(words[3]));
                            cls[classIndex].setScore(Integer.parseInt(words[3]));
                        }
                    }else if(words.length==5){
                        if(!course[courseIndex].test){
                            if(exist)
                                System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
                            student[studentIndex].format = false;
                        }else{
                            student[studentIndex].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
                            cls[classIndex].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
                            course[courseIndex].setTestScore(Integer.parseInt(words[4]));
                            course[courseIndex].setTimeScore(Integer.parseInt(words[3]));
                            course[courseIndex].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
                        }
                    }else if(words.length<8){
                        System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
                    }
                    else {
                        double theWhole = 0;
                        double theAverage;
                        int thePre = Integer.parseInt(words[3]);
                        if(words.length-4 != thePre){
                            System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
                            continue;
                        }
                        for(int i = 0;i<thePre;i++){
                            theWhole += Integer.parseInt(words[i+4]);
                        }
                        theAverage = theWhole / thePre;
                        student[studentCount].setScore(theAverage);
                        course[courseIndex].setScore(theAverage);
                        cls[classIndex].setScore(theAverage);
                    }
                }
            }else System.out.println("wrong format");
        }
        List<Student> studentList = new ArrayList<>(Arrays.asList(student).subList(0, studentCount));
        List<Cls> clsList = new ArrayList<>(Arrays.asList(cls).subList(0, classCount));
        List<Course> courseList = new ArrayList<>(Arrays.asList(course).subList(0, courseCount));
        Collections.sort(studentList);
        Collections.sort(clsList);
        courseList.sort(new CourseComparator());
        for(Student students : studentList){
            if(students.getScore()==0){
                System.out.println(students.getID()+" "+students.getName()+ " did not take any exams");
            }
            else{
                System.out.println(students.getID()+" "+students.getName()+" "+ students.lastScore());
            }
        }

        for(Course course1 : courseList){
            if(course1.getScore()==0&&course1.format){
                System.out.println(course1.getName()+" has no grades yet");
            }else{
                if(course1.pre&&course1.format){
                    System.out.println(course1.getName()+" "+ (int)course1.getScore()/course1.getScoreCount());
                }
                else if(course1.test&&course1.format){
                    System.out.println(course1.getName()+" "+(int)course1.getTimeScore()/course1.getScoreCount()+" "+
                            (int)course1.getTestScore()/course1.getScoreCount()+" "+(int)course1.getScore()/course1.getScoreCount());
                }else if(course1.format){
                    System.out.println(course1.getName()+" "+
                            (int)course1.getTestScore()/course1.getScoreCount()+" "+(int)course1.getScore()/course1.getScoreCount());
                }
            }
        }
        for(Cls cls1 : clsList){
            if(cls1.getScore()==0){
                System.out.println(cls1.getID()+" has no grades yet");
            }else{
                System.out.println(cls1.getID()+" "+(int)cls1.getScore()/cls1.getScoreCount());
            }
        }
    }
}
class CourseComparator implements Comparator<Course> {
    @Override
    public int compare(Course c1, Course c2) {
        Collator collator = Collator.getInstance(Locale.CHINA);
        return collator.compare(c1.getName(), c2.getName());
    }
}
class Course implements Comparable<Course>{
    private String name;
    private double timeScore=0;
    private double testScore=0;
    private double score=0;
    private int scoreCount=0;
    public boolean test;
    public boolean required;
    public boolean format = true;
    public boolean pre;

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

    public double getTimeScore() {
        return timeScore;
    }

    public void setTimeScore(double timeScore) {
        this.timeScore += timeScore;
    }

    public double getTestScore() {
        return testScore;
    }

    public void setTestScore(double testScore) {
        this.testScore += testScore;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score += score;
        this.scoreCount++;
    }

    public int getScoreCount() {
        return scoreCount;
    }
    // 实现Comparable接口中的compareTo方法，按照课程名称字符顺序排列
    @Override
    public int compareTo(Course other) {
        return this.name.compareTo(other.getName());
    }
}
class Student implements Comparable<Student>{
    private String ID;
    private String name;
    private double score;
    private int scoreCount=0;
    public boolean format = true;

    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 double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score += score;
        this.scoreCount++;
    }
    public int lastScore(){
        return (int)score/scoreCount;
    }
    // 定义比较规则：按照id升序排列
    @Override
    public int compareTo(Student o) {
        return Integer.compare(Integer.parseInt(this.ID), Integer.parseInt(o.ID));
    }
}
class Cls implements Comparable<Cls>{
    private String ID;
    private double score;
    private int scoreCount=0;
    public void setID(String ID){
        this.ID = ID;
    }
    public String getID(){
        return ID;
    }

    public void setScore(double score) {
        this.score += score;
        this.scoreCount++;
    }
    public double getScore(){
        return score;
    }

    public int getScoreCount() {
        return scoreCount;
    }
    // 定义比较规则：按照id升序排列
    @Override
    public int compareTo(Cls o) {
        return Integer.compare(Integer.parseInt(this.ID), Integer.parseInt(o.ID));
    }
}
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 = "(考试|考察|实验)";

    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
    /*courseInput用于定义课程信息模式（正则表达式）*/
    static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching + "(scoreMatching)?";
    static String scoreInput2 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching + "(scoreMatching)?" + " " + 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) {
        return s.matches(scoreInput)||s.matches(scoreInput2);
    }
}