第三次blog

LiuLile / 2023-06-27 / 原文

1.前言

这是第三次作业总结，总体难度适中，主要考验我们的学习能力和对编程的理解能力，有之前题目的迭代（菜单和成绩系统）和新方法的使用（如：题目集9中的考查语法(map, set)的使用），迭代的部分因为能力的问题（主要就是懒）没有完善之前的代码，所以难以迭代，都学到最后阶段了，还学的那么差，怪不好意思的。这次的作业跨度范围广，跨度时间大，还是段老师说的对，我们每次写题目的时候就应该写博客的总结，要不然到后面一下子好难回忆起来。这几次作业主要是编程题，涵盖了不同的主题和难度级别。从菜单设计到成绩分析，再到语法和继承多态，这些题目考察了不同的编程概念和技能。

2.设计与分析

第七次oop训练

因为前面的菜单系统没有认真完成的缘故所以迭代起来非常吃力，这里因为没有正确的缘故，就不分析了Q…Q

第八次oop训练

课程成绩统计程序-1

题目：7-1 课程成绩统计程序-1

分数 100

作者蔡轲

单位南昌航空大学

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

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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）成绩平均分只取整数部分，小数部分丢弃

参考类图：

源码如下：

import java.util.*;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        String s1 = in.nextLine();
        String s2 = in.nextLine();
        String s3 = in.nextLine();
        String s4 = in.nextLine();
        
        
        Course course = new Course();
        Score score = new Score();
        Class Class = new Class();
        Student student = new Student();
        

        if(s1.matches("^(java|\\S{1,10}) \\S{2} \\S{2}$")) {
            String[] split1 = s1.split(" ");
            course.setName(split1[0]);
            course.setQuality(split1[1]);
            course.setWay(split1[2]);
            
            if(s2.matches("^(java|\\S{1,10}) \\S{2} \\S{2}$")) {
                Course course2 = new Course();
                String[] split2 = s2.split(" ");
                course2.setName(split2[0]);
                course2.setQuality(split2[1]);
                course2.setWay(split2[2]);
                if(s3.matches("^(java|\\S{1,10}) \\S{2} \\S{2}$")) {
                    Course course3 = new Course();
                    String[] split3 = s3.split(" ");
                    course3.setName(split3[0]);
                    course3.setQuality(split3[1]);
                    course3.setWay(split3[2]);
                    if(s4.matches("^end$")) {
                        System.out.println(course.getName() + " has no grades yet");
                        System.out.println(course2.getName() + " has no grades yet");
                        System.out.println(course3.getName() + " has no grades yet");
                        
                    }
                    
                }

                
            }
            
            if(s2.matches("^[0-9]{8} \\S{1,10} (java|\\S{1,10}) ([0-9]{1,2}|100) ([0-9]{1,2}|100)$") && course.getQuality().equals("必修")  && course.getWay().equals("考试")){
                String[] split2 = s2.split(" ");
                Class.setClassname(split2[0]);
                Class.setName(split2[0]=split2[0].substring(0,6));
                student.setName(split2[1]);
                TestScores testScores = new TestScores();
                testScores.setUsualgrades(Integer.parseInt(split2[3]));
                testScores.setFinalgrades(Integer.parseInt(split2[4]));
                int theScore = (testScores.getUsualgrades() * 3 + testScores.getFinalgrades() * 7)/10;
                if(s3.matches("^end$")) {
                    System.out.println(Class.getClassname() + " " + student.getName() + " " + theScore);
                    System.out.println(course.getName() +  " "  +  testScores.getUsualgrades() + " " + testScores.getFinalgrades() + " " + theScore);
                    System.out.println(Class.getName() + " " + theScore);
                }
                
            }
            
            if(s2.matches("^[0-9]{8} \\S{1,10} (java|\\S{1,10}) ([0-9]{1,2}|100)$") && course.getQuality().equals("选修")  && course.getWay().equals("考察")) {
                String[] split2 = s2.split(" ");
                Class.setClassname(split2[0]);
                Class.setName(split2[0]=split2[0].substring(0,6));
                student.setName(split2[1]);
                score.setScore(Integer.parseInt(split2[3]));
                if(s3.matches("^end$")) {
                    System.out.println(Class.getClassname() + " " + student.getName() + " " + score.getScore());
                    System.out.println(course.getName() +  " "  +  score.getScore() + " " + score.getScore());
                    System.out.println(Class.getName() + " " + score.getScore());
                }
                
            }
            
            if(s2.matches("^[0-9]{8} \\S{1,10} (java|\\S{1,10}) ([0-9]{1,2}|100)$") && course.getQuality().equals("必修")  && course.getWay().equals("考试")) {
                String[] split2 = s2.split(" ");
                Class.setClassname(split2[0]);
                Class.setName(split2[0]=split2[0].substring(0,6));
                student.setName(split2[1]);
                System.out.println(Class.getClassname() + " " + student.getName() + " : " + "access mode mismatch");
                System.out.println(Class.getClassname() + " " + student.getName() + " " + "did not take any exams");
                System.out.println(course.getName() + " " + "has no grades yet");
                System.out.println(Class.getName() + " " + "has no grades yet");
            }
            
            if(course.getQuality().equals("必修")  && course.getWay().equals("考察")) {
                String[] split2 = s2.split(" ");
                Class.setClassname(split2[0]);
                Class.setName(split2[0]=split2[0].substring(0,6));
                student.setName(split2[1]);
                System.out.println(course.getName() + " : course type & access mode mismatch");
                System.out.println(course.getName() + " does not exist");
                System.out.println(Class.getClassname() + " " + student.getName() + " " + "did not take any exams");
                System.out.println(Class.getName() + " " + "has no grades yet");
                
            }
            
            
            if(s2.matches("^20[0-9]{6} \\S{1,10} (java|\\S{1,10}) [0-9]{3,5}$")){
                if(s3.matches("^end$")) {
                    System.out.println("wrong format");
                    System.out.println(course.getName() + " has no grades yet");
                }
                 
            }
        
        }
        

    }

}

class Course{
    private String name;
    private String quality;
    private String way;
    Scanner in = new Scanner(System.in);
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getQuality() {
        return quality;
    }
    public void setQuality(String quality) {
        this.quality = quality;
    }
    public String getWay() {
        return way;
    }
    public void setWay(String way) {
        this.way = way;
    }
    
    public void getCourse() {
        name = in.nextLine();
        quality = in.nextLine();
        way = in.nextLine();
    }
    
}

class Student{
    Class Class;
    CourseSelection courseSelection;
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    

    
}

class Score{
    int score;
    TestScores testScores;
    ExamineGrades examineGrades;
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    
    public int testScore() {
        score = (testScores.getFinalgrades() * 7 + testScores.getUsualgrades() * 3) / 10;
        return score;
    }
    public int examineGrades() {
        return score;
    }
    
}

abstract class AbstractScore{

    
}

class TestScores extends AbstractScore{
    private int finalgrades;
    private int usualgrades;
    public int getFinalgrades() {
        return finalgrades;
    }
    public void setFinalgrades(int finalgrades) {
        this.finalgrades = finalgrades;
    }
    public int getUsualgrades() {
        return usualgrades;
    }
    public void setUsualgrades(int usualgrades) {
        this.usualgrades = usualgrades;
    }

    
    
}

class ExamineGrades extends AbstractScore{
    private int examineGrades;

    public int getExamineGrades() {
        return examineGrades;
    }

    public void setExamineGrades(int examineGrades) {
        this.examineGrades = examineGrades;
    }

    
    
}


class Class{
    private String name;
    private String classname;
    private int ClassAverage;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getClassname() {
        return classname;
    }
    public void setClassname(String classname) {
        this.classname = classname;
    }
    
    

    
}
class CourseSelection{
    Score score;
    Student student;
    Course course;
    
    Scanner in = new Scanner(System.in);
    public Score getScore() {
        return score;
    }
    public void setScore(Score score) {
        this.score = score;
    }
    public Student getStudent() {
        return student;
    }
    public void setStudent(Student student) {
        this.student = student;
    }
    public Course getCourse() {
        return course;
    }
    
    public void setCourse() {
        this.course.setName(in.nextLine());
        in.nextLine();
        this.course.setQuality(in.nextLine());
        in.nextLine();
        this.course.setWay(in.nextLine());
    }
    
    
    
}

这题目使用了if和正则表达式如果用了while加正则表达式会更加简单

第九次oop训练

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

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

//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



源码如下：

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Map;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        Scanner x = new Scanner(System.in);
        StringBuilder a = new StringBuilder();
        Map map=new TreeMap();
        String[] gjc = {"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"};
        String kg,exit="exit";
        int i,n,flag=0;

        //输入
        kg = x.nextLine();
        while( !kg.equals(exit)) {
            a.append(kg.replaceAll("//.*", " ").replaceAll("\".*\"", " "));//去掉"//"后和的内容以及双引号里的内容
            kg = x.nextLine();
            flag=1;
        }
        String b = a.toString().replaceAll("/\\*\\s*.*\\s*\\*/", " ");//去掉"/* */"里的内容,放入字符串b中
        //System.out.println(b);

        //如果没有内容
        if(flag==0) {
            System.out.println("Wrong Format");
        }

        // 循环找每个关键词出现的次数
        for(i=0;i< gjc.length;i++) {
            Pattern pattern = Pattern.compile("\\b"+gjc[i]+"\\b");//创建关键词的正则表达式
            Matcher matcher = pattern.matcher(b);//字符串与关键词匹配
            n=0;
            while(matcher.find()) {//找到该关键词的话,记录该关键词的次数
                n++;
                //System.out.println(matcher.group());

            }
            if(n!=0){//把次数不是0的关键词替换为次数
                map.put(gjc[i], n);
            }
            //System.out.println(map);
        }
        //System.out.println(map);
        String map1= String.valueOf(map);//把map转化为字符串map1
        //System.out.println(map1);
        String map2=map1.replace("{","").replace("}","");//把map1里的"{""}"去掉存入字符串map2
        //System.out.println(map2);
        String[] map3=map2.split(", ");//把map2根据", "分开，存入字符串数组map3

        //循环输出
        for (i=0;i< map3.length;i++){
            String[] map4=map3[i].split("=");//把每个字符串map3根据"="分开，存入字符串数组map4
            System.out.println(map4[1]+"\t"+map4[0]);
        }

    }
}

这题目一开始写题目的时候没有考虑（int ***）里的内容int和this.loadFactor中的this导致答案错误，通过修改之后不段改进源代码。

查找关键字，并记录关键字的个数，可以利用map，进行键值对方式存储，存储关键字，而且题目需要按照关键字升序排列，所以可以用TreeMap

第十次oop训练

分析：因为第九次oop训练学习set和map的时候已经学习了HashMap的内容，所以并没有什么难度，主要就是掌握加强一下HashMap的使用

7-1容器-HashMap-检索

7-1 容器-HashMap-检索

分数 10

作者蔡轲

单位南昌航空大学

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

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

姓名可能会存在重复。

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

输入格式:

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

以“end”为输入结束标志

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

输出格式:

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

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

输入样例1:

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

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

输出样例1:

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

20201116 李四 78

输入样例2:

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

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

输出样例2:

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

The student 20202316 does not exist

源码：

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

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        HashMap<String, String[]> students = new HashMap<>();  // 学生信息存储在 HashMap 中
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("end")) {
                break;
            }
            String[] info = input.split(" ");
            students.put(info[0], new String[]{info[1], info[2]});
        }
        String searchNumber = scanner.nextLine(); 
        if (students.containsKey(searchNumber)) { 
            String[] info = students.get(searchNumber);
            System.out.println(searchNumber + " " + info[0] + " " + info[1]);
        } else {  
            System.out.println("The student " + searchNumber + " does not exist");
        }
    }
}

7-2 容器-HashMap-排序

分析：在上一题的基础上增加了排序，创建了一个学生类方便进行数据存储和后面的比较，这里我使用的是Comparable< >接口中的compareTo( )方法用来对数据进行排序

源码如下：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Map<Integer, Stu> map = new HashMap<>();
        while (true) {
            String str = in.nextLine();
            if (str.equals("end")) {
                break;
            }
            int id = Integer.parseInt(str.split(" ")[0]);
            String name = str.split(" ")[1];
            int score = Integer.parseInt(str.split(" ")[2]);
            if (map.containsKey(id)) {
                map.get(id).setScore(score);
            } else {
                map.put(id, new Stu(id, name, score));
            }
        }
        List<Stu> list = new ArrayList<>(map.values());
        Collections.sort(list);
        for (Stu stu : list) {
            System.out.println(stu);
        }
    }
}

class Stu implements Comparable<Stu> {
    private int id;
    private String name;
    private int score;

    public Stu(int id, String name, int score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public int compareTo(Stu o) {
        return o.id - this.id;
    }

    @Override
    public String toString() {
        return id + " " + name + " " + score;
    }
}

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

这一题需要之前的课程成绩代码进行迭代，因为上次作业的错误与不完整导致这次作业的难度明显加大，所以没有完成

分析：每次作业都需认真对待，不能含糊，每一次的不认真都是在给你自己挖坑，不要什么都留到最后，不要知难而退。

7-4 动物发声模拟器（多态）

分数 20

作者刘凤良

单位天津仁爱学院

设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩

其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。

请在下面的【】处添加代码。

//动物发生模拟器. 请在下面的【】处添加代码。 public class AnimalShoutTest2 { public static void main(String[] args) { Cat cat = new Cat(); Dog dog = new Dog(); Goat goat = new Goat(); speak(cat); speak(dog); speak(goat); } //定义静态方法speak() 【】 } //定义抽象类Animal 【】class Animal{ 【】 } //基于Animal类，定义猫类Cat，并重写两个抽象方法 class Cat 【】{ 【】【】 } //基于Animal类，定义狗类Dog，并重写两个抽象方法 class Dog 【】{ 【】【】 } //基于Animal类，定义山羊类Goat，并重写两个抽象方法 class Goat 【】{ 【】【】 }

输入样例:

输出样例:

猫的叫声：喵喵狗的叫声：汪汪山羊的叫声：咩咩

这一题很简单，主要就是考察我们多态。

源码如下：

public class Main {
    public static void main(String[] args) {        
         Cat cat = new Cat();
         Dog dog = new Dog();        
        Goat goat = new Goat();
         speak(cat);
         speak(dog);
         speak(goat);
    }//定义静态方法speak()
    private static void speak(Cat cat) {
        // TODO Auto-generated method stub
        System.out.println(cat.getAnimalClass() + "的叫声："  + cat.shout());
        
    }
    private static void speak(Dog dog) {
        // TODO Auto-generated method stub
        System.out.println(dog.getAnimalClass() + "的叫声："  + dog.shout());
    }
    private static void speak(Goat goat) {
        System.out.println(goat.getAnimalClass() + "的叫声："  + goat.shout());
    }
    

}

abstract class Animal{
    abstract String getAnimalClass();
    abstract String shout();
   
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{

    @Override
    String getAnimalClass() {
        return "猫";
        // TODO Auto-generated method stub
        
    }

    @Override
    String shout() {
        return "喵喵";
        // TODO Auto-generated method stub
        
    }
 
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal{

    @Override
    String getAnimalClass() {
        return "狗";
        // TODO Auto-generated method stub
        
    }

    @Override
    String shout() {
        return "汪汪";
        // TODO Auto-generated method stub
        
    }
 
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{

    @Override
    String getAnimalClass() {
        return "山羊";
        // TODO Auto-generated method stub
        
    }

    @Override
    String shout() {
        return "咩咩";
        // TODO Auto-generated method stub
        
    }

}

第十一次oop训练

7-1 容器-ArrayList-排序

分数 12

作者蔡轲

单位南昌航空大学

题目描述

编辑

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

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

姓名可能会存在重复。

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

输入格式:

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

以“end”为输入结束标志

输出格式:

按数学/物理成绩之和从高到低的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+数学/物理成绩之和

成绩相同的情况，按输入的先后顺序输出。

输入样例:

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

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

输出样例:

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

20201136 李四 164 20201124 张少军 158 20201118 郑觉先 142

分析：这里主要是学习了ArrayList的用法和之前学习的排序方法Comparable< >接口中的compareTo( )方法的结合

源码：

import java.util.*;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList <Student> list = new ArrayList<>();
        Scanner in = new Scanner(System.in);
        String s = null;

        //输入
        s = in.nextLine();
        while(!s.equals("end")) {
            String[] split1 = s.split(" ");

            Student stu = new Student(split1[0],split1[1],Integer.parseInt(split1[2]),Integer.parseInt(split1[3]));
            list.add(stu);


            s = in.nextLine();
        }

        //比较
        Collections.sort(list);
        
        for(int i=0;i<list.size();i++) {
            Student student = list.get(i);
            System.out.println(student.getClassname() + " " + student.getName() + " " +student.getAllScore());
        }

    }

}
class Student implements Comparable<Student> {
    private String classname;
    private String name;
    private int mathScore;
    private int physicScore;

    public Student(String classname, String name, int mathScore, int physicScore) {
        super();
        this.classname = classname;
        this.name = name;
        this.mathScore = mathScore;
        this.physicScore = physicScore;
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public String getClassname() {
        return classname;
    }

    public void setClassname(String classname) {
        this.classname = classname;
    }

    public String getName() {
        return name;
    }

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

    public int getMathScore() {
        return mathScore;
    }
    public void setMathScore(int mathScore) {
        this.mathScore = mathScore;
    }
    public int getPhysicScore() {
        return physicScore;
    }
    public void setPhysicScore(int physicScore) {
        this.physicScore = physicScore;
    }
    public int getAllScore(){
        return this.mathScore + this.physicScore;
    }

    @Override
    public int compareTo(Student student) {
        return student.getAllScore() - this.getAllScore();
    }
}

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

分数 9

作者郑如滨

单位集美大学

输入n，然后连续输入n个身份证号。
然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出exit并退出。

输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。

输入sort2，将所有身份证按照里面的年月日升序输出。

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

输入样例:

6 410425198309308225 320203197206115011 431227196108033146 330226196605054190 34080019810819327X 320111197112301539 sort1 sort2 e

输出样例:

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

分析：这一题和上一题差不多，都是一样的方法，主要就是这里多了substring(6,14)方法分割年月日，这里我在eclipse上运行没有问题，但是在pta上因为内存超限无法运行

源码：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int count=Integer.valueOf(sc.nextLine());
        String s[]=new String[count];
        for (int i=0;i<count;i++){
            s[i]=sc.nextLine();
        }
        String temp;
        SimpleDateFormat df=new SimpleDateFormat("yyyyMMdd");
        while (true){
            String tem=sc.nextLine();
            if (tem.equals("sort1")){
                Date date[]=new Date[count];
                for (int j=0;j<count;j++){
                    for (int i=0;i<count-j-1;i++){
                        String bir1=s[i].substring(6,14);
                        String bir2=s[i+1].substring(6,14);
                        Date d1;
                        Date d2;
                        try {
                            d1 = df.parse(bir1);
                            d2 =df.parse(bir2);
                            if (d1.getTime()>d2.getTime()){
                                temp=s[i];
                                s[i]=s[i+1];
                                s[i+1]=temp;
                            }
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                    }
                }
                for (int i=0;i<count;i++){
                    String bir=s[i];
                    System.out.println(bir.substring(6,10)+"-"+bir.substring(10,12)+"-"+bir.substring(12,14));
                }
            }else if (tem.equals("sort2")){
                Date date[]=new Date[count];
                for (int j=0;j<count;j++){
                    for (int i=0;i<count-j-1;i++){
                        String bir1=s[i].substring(6,14);
                        String bir2=s[i+1].substring(6,14);
                        Date d1;
                        Date d2;
                        try {
                            d1 = df.parse(bir1);
                            d2 =df.parse(bir2);
                            if (d1.getTime()>d2.getTime()){
                                temp=s[i];
                                s[i]=s[i+1];
                                s[i+1]=temp;
                            }
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                    }
                }
                for (int i=0;i<count;i++){
                    System.out.println(s[i]);
                }
 
            }else {
                System.out.println("exit");
            }
        }
    }
}
class Time implements Comparable<Time> {
    private String year;
    private String month;
    private String day;
    
    
    public Time(String year, String month, String day) {
        super();
        this.year = year;
        this.month = month;
        this.day = day;
    }


    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 Time() {
        super();
        // TODO Auto-generated constructor stub
    }


    @Override
    public int compareTo(Time o) {
        // TODO Auto-generated method stub
        int a =Integer.parseInt(this.year);
        int b =Integer.parseInt(o.year);
        return a-b;
    }
    

}
class ID implements Comparable<ID>{
    private String id;
    private String judge;
    public ID() {
        super();
        // TODO Auto-generated constructor stub
    }
    public ID(String id, String judge) {
        super();
        this.id = id;
        this.judge = judge;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getJudge() {
        return judge;
    }
    public void setJudge(String judge) {
        this.judge = judge;
    }
    @Override
    public int compareTo(ID o) {
        // TODO Auto-generated method stub
        int a =Integer.parseInt(this.judge);
        int b =Integer.parseInt(o.judge);
        return a-b;
    }
    
    

}