6-8次PTA题目集（成绩计算系列）分析-526互联

前言
知识点：
1. 类和对象：定义班级、学生和课程等类，并创建相应的对象；
2. 封装和访问控制：使用private、public等关键字对类的字段进行封装和访问控制；
3. 集合类：使用ArrayList或者其他集合类存储学生和课程信息；
4. 输入输出：通过控制台或者文件读写来输入和输出学生课程成绩信息；
5. 循环和条件语句：使用for循环和if语句进行遍历和条件判断；
6. 数组：使用数组存储学生的各门课程成绩；
7. 方法和函数：定义方法来计算学生课程总分、平均分等；
8. 异常处理：处理可能出现的异常情况，如输入格式错误等。
题量：感觉有点大
难度：成绩计算系列难度大，其它还好
设计与分析
课程成绩统计程序-1：

  1 import java.util.ArrayList;
  2 import java.util.Scanner;
  3 public class Main {
  4     static ArrayList<Course> listCourse = new ArrayList<>();
  5     static ArrayList<Student> listStudent = new ArrayList<>();
  6     public static void main(String[] args) {
  7         ArrayList<String> list = new ArrayList<>();
  8         Scanner sc = new Scanner(System.in);
  9         String s = null;
 10         while (!("end".equals(s = sc.nextLine()))){
 11             list.add(s);
 12         }
 13         int count = 0;
 14         for (String s1 : list) {
 15             //System.out.println(s1);
 16             /*java 选修 考察
 17             20201103 张三 java 40
 18             end*/
 19             String[] s2 = s1.split(" ");
 20             if(s2.length == 3){
 21                 Course cou = new Course();
 22                 cou.setCourse(s2[0]);
 23                 cou.setMajor(s2[1]);
 24                 cou.setElective(s2[2]);
 25                 listCourse.add(cou);
 26             }
 27             if(s2.length == 4){
 28                 Student stuTemp = new Student();
 29                 stuTemp.setId(s2[0]);
 30                 stuTemp.setName(s2[1]);
 31             }
 32         }
 33 
 34         System.out.println("wrong format");
 35         /*for (Course course : stu.getListCourse()) {
 36             System.out.println(course.getCourse()+","+course.getMajor()+","+course.getElective());
 37         }*/
 38 
 39     }
 40 }
 41 class Student {
 42     private String name;
 43     private String Id;
 44     private String keChen;
 45     private int pinShiFen;
 46     private int kaoShiFen;
 47 
 48     public Student() {
 49     }
 50 
 51     public Student(String name, String id) {
 52         this.name = name;
 53         Id = id;
 54     }
 55 
 56     public String getName() {
 57         return name;
 58     }
 59 
 60     public void setName(String name) {
 61         this.name = name;
 62     }
 63 
 64     public String getId() {
 65         return Id;
 66     }
 67 
 68     public void setId(String id) {
 69         Id = id;
 70     }
 71 }
 72 class Course {
 73     private String major;//主修
 74     private String elective;//选修
 75 
 76     private String course;//课程
 77 
 78     public Course() {
 79     }
 80 
 81     public Course(String major, String elective, String course) {
 82         this.major = major;
 83         this.elective = elective;
 84         this.course = course;
 85     }
 86 
 87     public String getMajor() {
 88         return major;
 89     }
 90 
 91     public void setMajor(String major) {
 92         this.major = major;
 93     }
 94 
 95     public String getElective() {
 96         return elective;
 97     }
 98 
 99     public void setElective(String elective) {
100         this.elective = elective;
101     }
102 
103     public String getCourse() {
104         return course;
105     }
106 
107     public void setCourse(String course) {
108         this.course = course;
109     }
110 }
111 class Class {
112 
113     private String num;
114     private int classAverage;
115 
116     public Class() {
117     }
118 
119     public Class( String num, int classAverage) {
120         this.num = num;
121         this.classAverage = classAverage;
122     }
123 
124 
125     public String getNum() {
126         return num;
127     }
128 
129     public void setNum(String num) {
130         this.num = num;
131     }
132 
133     public int getClassAverage() {
134         return classAverage;
135     }
136 
137     public void setClassAverage(int classAverage) {
138         this.classAverage = classAverage;
139     }
140 }

代码中定义了三个类：Main、Student和Course。其中，Main类是程序的入口，Student类表示学生对象，Course类表示课程对象。
程序开始时创建了两个ArrayList集合变量listCourse和listStudent，用于存储课程对象和学生对象。然后通过Scanner读取用户输入的信息，将每行信息添加到list集合中，直至输入"end"结束。接下来，程序对list集合进行遍历，根据空格分隔每行信息并判断长度。长度为3表示该行为课程信息，创建一个Course对象并设置相应属性，然后将其添加到listCourse集合中。长度为4表示该行为学生信息，创建一个Student对象并设置相应属性，但在代码中没有将该学生对象添加到listStudent集合中，可能是遗漏了这部分代码。最后，程序输出"wrong format"，表示输入的信息格式错误。
第7次题目集
7-1 容器-HashMap-检索：

import java.util.HashMap;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        HashMap<String, String> student = new HashMap<>();
        Scanner sc = new Scanner(System.in);
        while (true) {
            String input = sc.nextLine();
            if (input.equals("end")) {
                break;
            } else {
                String[] s = input.split(" ");
                student.put(s[0], s[1] + " " + s[2]);
            }
        }
        String id = sc.nextLine();
        if (student.containsKey(id)) {
            System.out.println(id + " " + student.get(id));
        } else {
            System.out.println("The student " + id + " does not exist");
        }
    }
}

使用了HashMap<String, String>来存储学生信息，其中键（key）表示学生的编号，值（value）表示学生的姓名和姓氏。程序通过Scanner从控制台读取用户输入的学生信息，直到输入"end"为止。
在读取每行学生信息时，代码使用split方法将输入的字符串按空格进行分割，得到一个包含学生编号和姓名的String数组s。然后，将学生编号作为键，姓名作为值，将它们添加到HashMap对象student中。
接下来，代码继续通过Scanner获取一个学生编号id，并使用containsKey方法判断该编号是否存在于student的键集合中。如果存在，则通过get方法获取对应的值（即学生的姓名和姓氏），并将学生编号和姓名输出到控制台。如果不存在，则输出"The student + 学生编号 + does not exist"。
这段代码实现了一个简单的学生信息查询功能，用户可以输入一系列学生信息，然后通过学生编号来查询对应的学生姓名和姓氏。
7-2 容器-HashMap-排序：

 1 import java.util.*;
 2 public class Main {
 3     public static void main(String[] args) {
 4         HashMap<String, String> student = new HashMap<>();
 5         Scanner sc = new Scanner(System.in);
 6         //System.out.println("请输入学生信息（格式：学号 姓名 成绩），以end结束：");
 7         while (true) {
 8             String input = sc.nextLine();
 9             if (input.equals("end")) {
10                 break;
11             } else {
12                 String[] s = input.split(" ");
13                 student.put(s[0], s[1] + " " + s[2]);
14             }
15         }
16         ArrayList<String> list = new ArrayList<>(student.keySet());
17         //System.out.println(list);
18         Collections.sort(list, Collections.reverseOrder());
19         //System.out.println(list);
20         for (String s : list) {
21             System.out.println(s+" "+student.get(s));
22         }
23     }
24 }

首先创建了一个HashMap对象student，用于存储学生信息。然后通过Scanner从控制台读取用户输入的学生信息，直到输入"end"为止。
在读取每行学生信息时，代码使用split方法将输入的字符串按空格进行分割，得到一个包含学号、姓名和成绩的String数组s。然后，将学号作为键，姓名和成绩拼接后的字符串作为值，将它们添加到HashMap对象student中。
接下来，代码将student的键集合转换为一个ArrayList对象list，并使用Collections.sort方法对list进行倒序排序。
最后，通过for循环遍历排好序的list，根据学号获取对应学生的完整信息，并将其输出到控制台。
7-3 课程成绩统计程序-2：

  1 import java.util.ArrayList;
  2 import java.util.Scanner;
  3 public class Main {
  4     static ArrayList<Course> listCourse = new ArrayList<>();
  5     static ArrayList<Student> listStudent = new ArrayList<>();
  6     public static void main(String[] args) {
  7         ArrayList<String> list = new ArrayList<>();
  8         Scanner sc = new Scanner(System.in);
  9         String s = null;
 10         while (!("end".equals(s = sc.nextLine()))){
 11             list.add(s);
 12         }
 13         int count = 0;
 14         for (String s1 : list) {
 15             //System.out.println(s1);
 16             /*java 选修 考察
 17             20201103 张三 java 40
 18             end*/
 19             String[] s2 = s1.split(" ");
 20             if(s2.length == 3){
 21                 Course cou = new Course();
 22                 cou.setCourse(s2[0]);
 23                 cou.setMajor(s2[1]);
 24                 cou.setElective(s2[2]);
 25                 listCourse.add(cou);
 26             }
 27             if(s2.length == 4){
 28                 Student stuTemp = new Student();
 29                 stuTemp.setId(s2[0]);
 30                 stuTemp.setName(s2[1]);
 31             }
 32         }
 33 
 34         System.out.println("wrong format");
 35         /*for (Course course : stu.getListCourse()) {
 36             System.out.println(course.getCourse()+","+course.getMajor()+","+course.getElective());
 37         }*/
 38 
 39     }
 40 }
 41 class Student {
 42     private String name;
 43     private String Id;
 44     private String keChen;
 45     private int pinShiFen;
 46     private int kaoShiFen;
 47 
 48     public Student() {
 49     }
 50 
 51     public Student(String name, String id) {
 52         this.name = name;
 53         Id = id;
 54     }
 55 
 56     public String getName() {
 57         return name;
 58     }
 59 
 60     public void setName(String name) {
 61         this.name = name;
 62     }
 63 
 64     public String getId() {
 65         return Id;
 66     }
 67 
 68     public void setId(String id) {
 69         Id = id;
 70     }
 71 }
 72 class Course {
 73     private String major;//主修
 74     private String elective;//选修
 75 
 76     private String course;//课程
 77 
 78     public Course() {
 79     }
 80 
 81     public Course(String major, String elective, String course) {
 82         this.major = major;
 83         this.elective = elective;
 84         this.course = course;
 85     }
 86 
 87     public String getMajor() {
 88         return major;
 89     }
 90 
 91     public void setMajor(String major) {
 92         this.major = major;
 93     }
 94 
 95     public String getElective() {
 96         return elective;
 97     }
 98 
 99     public void setElective(String elective) {
100         this.elective = elective;
101     }
102 
103     public String getCourse() {
104         return course;
105     }
106 
107     public void setCourse(String course) {
108         this.course = course;
109     }
110 }
111 class Class {
112 
113     private String num;
114     private int classAverage;
115 
116     public Class() {
117     }
118 
119     public Class( String num, int classAverage) {
120         this.num = num;
121         this.classAverage = classAverage;
122     }
123 
124 
125     public String getNum() {
126         return num;
127     }
128 
129     public void setNum(String num) {
130         this.num = num;
131     }
132 
133     public int getClassAverage() {
134         return classAverage;
135     }
136 
137     public void setClassAverage(int classAverage) {
138         this.classAverage = classAverage;
139     }
140 }

定义一个空的数据结构，用于存储课程信息和成绩。
输入课程信息和成绩：
- 读取用户输入的课程数目n。
- 创建一个循环，从1到n依次执行以下步骤：
  - 读取用户输入的课程名称、课程性质和考核方式。
  - 将课程信息添加到数据结构中。
输入考试/考查课程成绩：
- 读取用户输入的考试/考查课程数目m。
- 创建一个循环，从1到m依次执行以下步骤：
  - 读取用户输入的学号、姓名、课程名称、平时成绩和期末成绩。
  - 根据课程名称找到对应的课程信息。
  - 计算考试/考查课程的总成绩并将其添加到数据结构中。
输入实验课程成绩：
- 读取用户输入的实验课程数目k。
- 创建一个循环，从1到k依次执行以下步骤：
  - 读取用户输入的学号、姓名、课程名称、实验次数和实验成绩。
  - 根据课程名称找到对应的课程信息。
  - 计算实验课程的总成绩（实验成绩的平均值）并将其添加到数据结构中。
输出课程统计信息：
- 创建一个循环，遍历数据结构中的课程信息。
- 对于每个课程，根据课程性质判断考核方式，分别计算总成绩。
- 输出每个课程的名称、性质、考核方式和总成绩。

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

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()
    public static void speak(Animal animal) {
        System.out.print(animal.getAnimalClass() + "的叫声：");
        animal.shout();
    }
}

//定义抽象类Animal
abstract class Animal {
    //获取动物类别getAnimalClass()、动物叫shout()；
    public abstract String getAnimalClass();

    public abstract void shout();
}

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

    @Override
    public void shout() {
        System.out.println("喵喵");
    }
}

//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal {

    @Override
    public String getAnimalClass() {
        return "狗";
    }

    @Override
    public void shout() {
        System.out.println("汪汪");
    }
}

//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal {

    @Override
    public String getAnimalClass() {
        return "山羊";
    }

    @Override
    public void shout() {
        System.out.println("咩咩");
    }
}

代码定义了一个抽象类Animal作为基类，其中包含两个抽象方法getAnimalClass()和shout()。然后通过三个具体的子类Cat、Dog和Goat分别继承Animal类，并实现了这两个抽象方法。

在Main类的main方法中，创建了一个Cat对象、一个Dog对象和一个Goat对象，并依次调用了speack方法。speak方法接受一个Animal类型的参数，输出动物的类别和叫声。

运行程序时，会依次输出每个动物的类别和对应的叫声，分别是猫的"喵喵"、狗的"汪汪"和山羊的"咩咩"。
7-1 容器-ArrayList-排序：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        while (!line.equals("end")) {
            String[] s = line.split(" ");
            if (s.length == 4) {
                list.add(new Student(s[0], s[1], Integer.parseInt(s[2]), Integer.parseInt(s[3])));
            }
            line = sc.nextLine();
        }
        //简单理解:
        //o1 - o2 :升序排列
        //o2 - o1 :降序排序
        //Integer[] arr = {2,3,1,5,6,7,8,4,9};
        /*Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });*/
        // 按数学和物理成绩之和从高到低排序
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Integer.compare(o2.getSum(), o1.getSum()); // 从大到小排序
            }
        });
        for (Student student : list) {
            System.out.println(student.getId() + " " + student.getName() + " " + student.getSum());
        }
    }


}

class Student {
    private String id;
    private String name;
    private int math;
    private int physics;

    public Student() {
    }

    public Student(String id, String name, int math, int physics) {
        this.id = id;
        this.name = name;
        this.math = math;
        this.physics = physics;
    }

    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 getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getPhysics() {
        return physics;
    }

    public void setPhysics(int physics) {
        this.physics = physics;
    }

    public int getSum() {
        return math + physics;
    }
}

首先创建了一个存储Student对象的ArrayList列表，并通过用户输入添加学生信息。每个学生信息包括学号(id)、姓名(name)、数学成绩(math)和物理成绩(physics)。

然后，使用Collections.sort()方法对学生列表进行排序，排序规则是通过自定义的比较器(Comparator)来实现的。比较器通过比较学生对象的数学和物理成绩之和(getSum())进行排序，按照从高到低排列。比较器的定义通过实现compare()方法来实现。

最后，通过遍历排序后的学生列表，打印每个学生的学号、姓名和总成绩。
7-2 课程成绩统计程序-3：
太复杂了

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

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<String> list3 = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        //System.out.println("要输入的次数");
        int a = sc.nextInt();
        sc.nextLine();//读取多余的换行符
        for (int i = 0; i < a; i++) {
            String s = sc.nextLine();
            list1.add(s);
        }
        for (String s : list1) {
            String s1 = s.substring(6, 10) + "-" + s.substring(10, 12) + "-" + s.substring(12, 14);
            list2.add(s1);
        }
        for (String s : list1) {
            String s1 = s.substring(6, 10) + s.substring(10, 12) + s.substring(12, 14);
            list3.add(s1);
        }
        while (true) {
            //System.out.println("请选择要使用的方式");
            String choose = sc.nextLine();
            switch (choose) {
                case "sort1": {
                    Collections.sort(list2);
                    for (String s : list2) {
                        System.out.println(s);
                    }
                    break;
                }
                case "sort2": {
                    Collections.sort(list3);
                    for (int i = 0; i < list1.size(); i++) {
                        for (int j = 0; j < list1.size(); j++) {
                            if (list1.get(j).contains(list3.get(i))){
                                System.out.println(list1.get(j));
                            }
                        }
                    }
                    break;
                }
                default:{
                    System.out.println("exit");
                    System.exit(0);
                }
            }
        }
    }
}

首先，定义了三个ArrayList列表list1、list2和list3用于存储输入的字符串信息。通过Scanner类获取用户输入的次数a，然后使用nextLine()方法读取每行输入的字符串，并将其添加到list1中。
接下来，分别对list1中的每个字符串进行处理，提取其中的日期部分并格式化为YYYY-MM-DD的形式，并将结果添加到list2中。同时，将日期部分整合为纯数字的形式(YYYYMMDD)，并添加到list3中。

然后，通过一个无限循环，等待用户选择要使用的方式(sort1或sort2)，用户可以通过输入命令来执行相应的操作。如果选择sort1，则对list2进行排序并打印排序后的结果；如果选择sort2，则对list3进行排序，并根据排序后的结果匹配并打印原始输入的字符串；如果选择其他任何值，则退出程序。

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

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

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[] arr;
    private int top = 0;

    public ArrayIntegerStack(int n){
        arr = new Integer[n];
        Arrays.fill(arr, null);
    }

    public ArrayIntegerStack(){}

    @Override
    public String toString() {
        return Arrays.toString(arr);
    }

    @Override
    public Integer push(Integer item) {
        if (item == null || arr.length == top){
            return null;
        }
        arr[top++] = item;
        return item;
    }

    @Override
    public Integer pop() {
        if (top == 0){
            return null;
        }
        return arr[--top];
    }

    @Override
    public Integer peek() {
        if (top == 0){
            return null;
        }
        return arr[top - 1];
    }

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

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

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        ArrayIntegerStack ais = new ArrayIntegerStack(n);
        int m = scanner.nextInt();
        while(m-- > 0){
            int item = scanner.nextInt();
            System.out.println(ais.push(item));
        }
        System.out.println(ais.peek() + "," + ais.empty() + "," + ais.size());
        System.out.println(ais);
        int x = scanner.nextInt();
        while(x-- > 0){
            System.out.println(ais.pop());
        }
        System.out.println(ais.peek() + "," + ais.empty() + "," + ais.size());
        System.out.println(ais);
    }
}

这段代码实现了一个整数栈数据结构，包括入栈、出栈、获取栈顶元素、判断栈是否为空以及获取栈中元素个数等功能。

首先定义了一个IntegerStack接口，该接口包含了五个方法：push()用于将元素入栈，pop()用于出栈，peek()用于获取栈顶元素，empty()用于判断栈是否为空，size()用于获取栈中元素个数。

然后实现了一个名为ArrayIntegerStack的类，该类实现了IntegerStack接口。它通过一个数组来保存栈中的元素，使用一个变量top表示栈顶的位置。在初始化时，可以指定栈的容量。栈的大小可以通过调用size()方法获得。入栈时，检查元素是否为null以及栈是否已满，如果满足条件则返回null，否则将元素添加到栈顶，并返回插入的元素。出栈时，检查栈是否为空，如果为空则返回null，否则返回栈顶元素并将栈顶指针前移。获取栈顶元素时，检查栈是否为空，如果为空则返回null，否则返回栈顶元素。判断栈是否为空时，只需判断栈顶指针是否为0即可。最后，通过重写toString()方法，可以直接打印整个栈的元素。

在Main类的main()方法中，首先通过Scanner类获取用户输入的栈的容量和操作次数，并创建一个ArrayIntegerStack对象。然后，根据用户输入的操作类型进行相应的操作：入栈、获取栈顶元素、判断栈是否为空以及出栈。最后，输出栈顶元素、判断栈是否为空以及栈中元素个数，并打印整个栈的元素。

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

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

    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;
        }
        public String getName() {
            return name;
        }

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

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public boolean isGender() {
            return gender;
        }

        public void setGender(boolean gender) {
            this.gender = gender;
        }

        @Override
        public String toString() {
            String s = name + "-" + age + "-" + gender;
            return s;
        }
        @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 sc = new Scanner(System.in);
        int n1 = sc.nextInt();
        sc.nextLine();
        PersonOverride[] persons1 = new PersonOverride[n1];
        for (int i = 0; i < n1; i++) {
            PersonOverride p1 = new PersonOverride();
            persons1[i] = p1;
        }
        int n2 = sc.nextInt();
        sc.nextLine();
        int number = 0;
        PersonOverride[] persons2 = new PersonOverride[n2];
        for (int i = 0; i < n2; i++) {
            String s1 = sc.nextLine();
            String[] s = s1.split(" ");
            PersonOverride po = new PersonOverride(s[0], Integer.parseInt(s[1]), Boolean.parseBoolean(s[2]));
            boolean duplicated = false;
            for (int j = 0; j < i; j++) {
                if (po.equals(persons2[j])) {
                    duplicated = true;
                    break;
                }
            }
            if (!duplicated) {
                persons2[i] = po;
                number++;
            }
        }
        for (int i = 0; i < n1; i++) {
            System.out.println(persons1[i]);
        }
        for (int i = 0; i < n2; i++) {
            if (persons2[i] != null) {
                System.out.println(persons2[i]);
            }
        }
        System.out.println(number);
        System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
}

首先定义了一个PersonOverride类，该类有私有成员变量name（姓名）、age（年龄）和gender（性别），以及对应的getter和setter方法。还重写了toString()方法和equals()方法。

然后在Main类中的main方法中，通过用户输入获取两个整数n1和n2，分别表示要创建的PersonOverride对象的数量。接下来创建了长度为n1和n2的persons1和persons2数组用于存储PersonOverride对象。

通过循环语句，分别创建了n1个默认的PersonOverride对象，并将其存储到persons1数组中。

然后通过循环语句，根据用户输入的字符串创建PersonOverride对象，并检查是否与之前创建的对象重复。如果未重复，则将其存储到persons2数组中，并递增number计数器。

最后，分别遍历persons1和persons2数组，输出其中的对象。同时输出number的值和PersonOverride类的构造方法列表。

三、采坑心得

在编写日期相关的程序时，需要仔细学习和理解Java API提供的相关类和方法，以确保程序的正确性和稳定性。注意一些特殊情况的处理，输入错误、异常的处理要完善，而且变量名命名要具有可读性，要更加清晰易懂以提高代码可维护性，当输入格式不正确、数组越界等情况需要进行相关判断和处理。使用纯数组来计算，没有进行任何异常处理和错误提示，容易造成数字溢出等错误，需要注意程序在处理字符时要特别小心，防止出现数组越界等问题。