标签：题目 String 第六 System 第八次课程成绩 public 输入

第六到第八次题目集总结

一、题目集六

课程成绩统计程序-1

第一题

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

public class Grade {
    private final CourseGrade courseGrade;
    private final SubGrade subGrade;

    public Grade(CourseGrade courseGrade, SubGrade subGrade) {
        this.courseGrade = courseGrade;
        this.subGrade = subGrade;
    }

    // getters and setters
}
public class SubGrade {
    private int gradeScore;
    private double weight;

    public SubGrade(int gradeScore, double weight) {
        this.gradeScore = gradeScore;
        this.weight = weight;
    }

    // getters and setters
}
import java.util.List;

public class CourseGrade {
    private List<SubGrade> subGrades;

    public CourseGrade(List<SubGrade> subGrades) {
        this.subGrades = subGrades;
    }

    // getters and setters
}
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        ArrayIntegerStack stack = new ArrayIntegerStack(n);
        
        int m = scanner.nextInt();
        for (int i = 0; i < m; i++) {
            Integer pushed = scanner.nextInt();
            System.out.println(stack.push(pushed));
        }
        
        System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
        System.out.println(Arrays.toString(stack.getElements()));
        
        int x = scanner.nextInt();
        for (int i = 0; i < x; i++) {
            System.out.println(stack.pop());
        }
        
        System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
        System.out.println(Arrays.toString(stack.getElements()));

        scanner.close();
    }
}

总结：

某大学学科分为必修课和选修课，评估方法包括考试和评估。考试总分计算方法为日常分数和期末分数的加权平均，如每日分数权重为 0.3，期末分数权重为 0.7，总分等于每日分数 * 0.3 + 期末分数 * 0.7。评估课程的总分直接等同于最终成绩。必修课须采用考试评估，选修课可选考试或评估评估方式。

输入: 课程信息和成绩信息。课程信息包括课程名称、课程性质和评估方法。成绩信息包括学生学号、姓名、课程名称、平时成绩和期末成绩。
输出: 输出包括学生所有课程总分平均分数，单个课程的成绩平均分数，整个班级的所有课程成绩平均分数三部分。
首先，需要创建一个课程类（Course），其中包含课程名称、课程性质（必修课或选修课）以及评估方法（考试或评估，如果为必修课则为考试）。
其次，创建一个学生类（Student），包含学生ID、姓名、课程及其对应的分数。
创建一个班级类（Class），包含班级编号、课程列表和学生列表。
对于输入部分，请创建一个解析输入数据的方法，将输入数据解析为课程和成绩信息，然后将这些信息添加到相应的对象中，例如添加课程到课程列表，添加学生到学生列表等。
创建一个计算平均分数的方法，用以计算三个关键数据：a) 学生所有课程成绩的平均分数；b) 各个课程的平均分数；c) 整个班级所有课程成绩的平均分数。
考虑到处理异常情况，对输入的数据检查课程名称、评估方式、课程性质等是否合规。
最后，在主函数中，从输入中获取信息，然后将解析后的数据存储在相应的对象中。利用存储的数据，计算三个关键数据，并将结果打印出来。
异常情况:
1. 当解析某个成绩信息时，如果课程名称不存在于输入的课程列表中，输出："该课程不存在"
2. 当解析某个成绩信息时，如果输入的成绩与课程评估方式不匹配，输出："评估方式不匹配"
3. 当解析某个课程信息时，如果输入的课程性质和评估方法不匹配，输出："课程类型和评估方式不匹配" 4) 格式错误和其他信息异常（如成绩超出范围）将作为格式错误处理，并输出"格式错误" 5) 如果出现重复的课程/成绩信息，仅保留第一个课程信息，忽略后续输入。信息约束: 1) 成绩平均分的小数部分被舍弃，仅保留整数部分总之，此问涉及大学课程分为必修课和选修课两种，评估方法包括考试和评估。要求输入课程信息和成绩信息，输出包含三部分内容：学生所有课程成绩的平均分数、单个课程成绩的平均分数以及整个班级所有课程成绩的平均分数。此外，还需处理各种异常情况。

二、题目集七

题目集总述

第一题

题目内容：容器-HashMap-检索

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

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

        //System.out.println("请输入学生的成绩信息（按照以下格式输入：学号+空格+姓名+空格+成绩，以“end”为输入结束标志）：");

        while (scanner.hasNextLine()) {
            String input = scanner.nextLine();

            if ("end".equalsIgnoreCase(input)) {
                break;
            }

            String[] info = input.split(" ");
            if (info.length == 3) {
                studentMap.put(info[0], info[1] + " " + info[2]);
            } else {
                System.out.println("输入格式错误，请重新输入！");
            }
        }

        //System.out.println("请输入查询的学号：");
        String searchId = scanner.nextLine();

        String studentInfo = studentMap.get(searchId);

        if (studentInfo != null) {
            System.out.println(searchId + " " + studentInfo);
        } else {
            System.out.println("The student " + searchId + " does not exist");
        }

        scanner.close();
    }
}

总结：这个示例的Java程序用于接收、存储和通过学生ID查询学生信息。以下是程序执行过程的详细解释： 1. 首先，我们导入java.util.HashMap和java.util.Scanner类，它们分别用于存储学生信息和获取用户输入。 2. 程序的主体位于StudentInfo类中，我们在main方法创建一个Scanner对象（名为scanner）用来从控制台读取输入。 3. 使用HashMap<Integer, String>创建一个名为students的HashMap对象，用于存储学生信息，其中键（Key）为学生ID（整数类型），值（Value）为学生姓名和成绩的字符串。 4. 向用户提示输入学生信息格式，接收用户输入的信息。当用户输入"end"时，停止读取学生信息。 5. 对于每个输入的学生信息，我们使用split(" ")方法将其拆分为三个部分：学生ID、姓名和成绩。然后，将学生ID转换为整数，并将姓名和成绩作为字符串连接在一起。 6. 使用students.put(id, name + " " + score)将学生信息存入students HashMap，以学生ID作为键。 7. 读取所有学生信息后，程序提示用户输入要查询的学生ID。 8. 使用students.containsKey(queryId)检查students HashMap中是否包含查询的学生ID。如果存在，输出相应的学生信息；若不存在，输出提示信息"学生" 加上学生ID 加上 "不存在"。 9. 关闭scanner对象，结束程序。通过这个Java程序，我们实现了一个简单的系统来接收、存储和根据学生ID查询学生信息。

第二题

题目内容：容器-HashMap-排序

import java.util.*;

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

        //System.out.println("请输入学生的成绩信息（按照以下格式输入：学号+空格+姓名+空格+成绩，以“end”为输入结束标志）：");

        while (scanner.hasNextLine()) {
            String input = scanner.nextLine();

            if ("end".equalsIgnoreCase(input)) {
                break;
            }

            String[] info = input.split(" ");
            if (info.length == 3) {
                studentMap.put(info[0], info[1] + " " + info[2]);
            } else {
                System.out.println("输入格式错误，请重新输入！");
            }
        }

        List<String> sortedIds = new ArrayList<>(studentMap.keySet());
        Collections.sort(sortedIds, Collections.reverseOrder());

        for (String id : sortedIds) {
            System.out.println(id + " " + studentMap.get(id));
        }

        scanner.close();
    }
}

总结：这个Java程序的目的是接收多个学生的成绩信息（包括学生ID、姓名和成绩），将学生信息存储在HashMap中，并按照学生ID降序输出所有学生信息。以下是程序执行过程的详细解释： 1. 首先，我们导入java.util.HashMap、java.util.Scanner和java.util.TreeMap类，它们分别用于存储学生信息、获取用户输入和排序学生信息。 2. 程序的主体位于StudentScoreInfo类中，我们在main方法创建一个Scanner对象（名为scanner）用来从控制台读取输入。 3. 使用HashMap<Integer, String>创建一个名为students的HashMap对象，用于存储学生信息，其中键（Key）为学生ID（整数类型），值（Value）为学生姓名和成绩的字符串。 4. 向用户提示输入学生信息格式，接收用户输入的信息。当用户输入"end"时，停止读取学生信息。 5. 对于每个输入的学生信息，我们使用split(" ")方法将其拆分为三个部分：学生ID、姓名和成绩。然后，将学生ID转换为整数，并将姓名和成绩作为字符串连接在一起。 6. 使用students.put(id, name + " " + score)将学生信息存入students HashMap，以学生ID作为键。 7. 为了按学生ID降序输出所有学生信息，我们创建一个名为sortedStudents的TreeMap对象，并将students HashMap的数据填充到sortedStudents对象中。由于TreeMap会自动按照键值对进行排序，这样我们就获得了一个根据学生ID升序排列的TreeMap。 8. 使用sortedStudents.descendingMap()方法，我们获得一个根据学生ID降序排列的TreeMap。接着，使用forEach方法遍历整个TreeMap，并按照格式输出学生ID、姓名和成绩。 9. 关闭scanner对象，结束程序。通过这个Java程序，我们实现了一个简单的系统，可以接收、存储学生信息，并按照学生ID降序输出所有学生信息。

第三题

题目内容：课程成绩统计程序-2

public class Grade {
    private final CourseGrade courseGrade;
    private final SubGrade subGrade;

    public Grade(CourseGrade courseGrade, SubGrade subGrade) {
        this.courseGrade = courseGrade;
        this.subGrade = subGrade;
    }

    // getters and setters
}
public class SubGrade {
    private int gradeScore;
    private double weight;

    public SubGrade(int gradeScore, double weight) {
        this.gradeScore = gradeScore;
        this.weight = weight;
    }

    // getters and setters
}
import java.util.List;

public class CourseGrade {
    private List<SubGrade> subGrades;

    public CourseGrade(List<SubGrade> subGrades) {
        this.subGrades = subGrades;
    }

    // getters and setters
}
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        ArrayIntegerStack stack = new ArrayIntegerStack(n);
        
        int m = scanner.nextInt();
        for (int i = 0; i < m; i++) {
            Integer pushed = scanner.nextInt();
            System.out.println(stack.push(pushed));
        }
        
        System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
        System.out.println(Arrays.toString(stack.getElements()));
        
        int x = scanner.nextInt();
        for (int i = 0; i < x; i++) {
            System.out.println(stack.pop());
        }
        
        System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
        System.out.println(Arrays.toString(stack.getElements()));

        scanner.close();
    }
}

总结：某大学学科分为必修课和选修课，评估方法包括考试和评估。考试总分计算方法为日常分数和期末分数的加权平均，如每日分数权重为 0.3，期末分数权重为 0.7，总分等于每日分数 * 0.3 + 期末分数 * 0.7。评估课程的总分直接等同于最终成绩。必修课须采用考试评估，选修课可选考试或评估评估方式。

输入: 课程信息和成绩信息。课程信息包括课程名称、课程性质和评估方法。成绩信息包括学生学号、姓名、课程名称、平时成绩和期末成绩。
输出: 输出包括学生所有课程总分平均分数，单个课程的成绩平均分数，整个班级的所有课程成绩平均分数三部分。
首先，需要创建一个课程类（Course），其中包含课程名称、课程性质（必修课或选修课）以及评估方法（考试或评估，如果为必修课则为考试）。
其次，创建一个学生类（Student），包含学生ID、姓名、课程及其对应的分数。
创建一个班级类（Class），包含班级编号、课程列表和学生列表。
对于输入部分，请创建一个解析输入数据的方法，将输入数据解析为课程和成绩信息，然后将这些信息添加到相应的对象中，例如添加课程到课程列表，添加学生到学生列表等。
创建一个计算平均分数的方法，用以计算三个关键数据：a) 学生所有课程成绩的平均分数；b) 各个课程的平均分数；c) 整个班级所有课程成绩的平均分数。
考虑到处理异常情况，对输入的数据检查课程名称、评估方式、课程性质等是否合规。
最后，在主函数中，从输入中获取信息，然后将解析后的数据存储在相应的对象中。利用存储的数据，计算三个关键数据，并将结果打印出来。
异常情况:
1. 当解析某个成绩信息时，如果课程名称不存在于输入的课程列表中，输出："该课程不存在"
2. 当解析某个成绩信息时，如果输入的成绩与课程评估方式不匹配，输出："评估方式不匹配"
3. 当解析某个课程信息时，如果输入的课程性质和评估方法不匹配，输出："课程类型和评估方式不匹配" 4) 格式错误和其他信息异常（如成绩超出范围）将作为格式错误处理，并输出"格式错误" 5) 如果出现重复的课程/成绩信息，仅保留第一个课程信息，忽略后续输入。信息约束: 1) 成绩平均分的小数部分被舍弃，仅保留整数部分总之，此问涉及大学课程分为必修课和选修课两种，评估方法包括考试和评估。要求输入课程信息和成绩信息，输出包含三部分内容：学生所有课程成绩的平均分数、单个课程成绩的平均分数以及整个班级所有课程成绩的平均分数。此外，还需处理各种异常情况。

第四题

题目内容：动物发声模拟器（多态）

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.println(animal.getAnimalClass() + "的叫声：" + animal.shout());
    }
}

// 定义抽象类Animal
abstract class Animal {
    public abstract String getAnimalClass();

    public abstract String shout();
}

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

    public String shout() {
        return "喵喵";
    }
}

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

    public String shout() {
        return "汪汪";
    }
}

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

    public String shout() {
        return "咩咩";
    }
}

总结：这个问题要求我们设计一个动物模拟器，用于模拟不同动物的叫声，如狮子吼叫、老虎咆哮、狗汪汪叫，猫喵喵叫等。需要定义一个抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()和动物叫声shout()。接着，基于抽象类Animal，定义狗、猫和山羊Goat 类。在AnimalShoutTest2类里，我们需要使用speak(Animal animal) {}方法输出动物的叫声，并在main()方法中调用speak()来分别输出猫、狗和山羊对象的叫声。以下是程序执行过程的详细解释： 1. 首先，我们定义一个抽象类Animal，它包含两个抽象方法：获取动物类别getAnimalClass()和动物叫声shout()。 2. 然后，基于抽象类Animal，我们创建了猫、狗和山羊这三个动物类。它们都继承了Animal抽象类，并实现了相应的抽象方法。在这些具体的动物类中，我们提供了描述动物类别的方法getAnimalClass()和描述叫声的方法shout()。 3. 接着，我们在AnimalShoutTest2类中定义了一个静态方法speak()，它接收一个Animal对象。在speak()方法中，我们调用传入的Animal对象的getAnimalClass()和shout()方法，以此来输出该动物的叫声。 4. 在AnimalShoutTest2的main()方法中，我们实例化猫、狗和山羊对象，然后调用speak()方法分别输出这些对象的叫声。通过这个程序，我们可以模拟不同动物的叫声，并通过抽象类和继承的方式实现了代码的简洁性和可扩展性。可以根据需要轻松地添加更多动物及其叫声。

三、题目集八

第一题

题目内容：容器-ArrayList-排序

import java.util.ArrayList;
import java.util.Scanner;
import java.util.stream.Collectors;

class Student {
    String id;
    String name;
    int mathScore;
    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 int getTotalScore() {
        return this.mathScore + this.physicsScore;
    }

    @Override
    public String toString() {
        return this.id + " " + this.name + " " + getTotalScore();
    }
}

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

        while (true) {

            String line = input.nextLine();
            if (line.equalsIgnoreCase("end")) {
                break;
            }

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

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

        //System.out.println("Displaying student information sorted by total score:");
        students.stream()
                .sorted((s1, s2) -> Integer.compare(s2.getTotalScore(), s1.getTotalScore()))
                .forEach(System.out::println);
    }
}

总结：这个问题要求我们编写一个Java程序来输入多个学生的表现信息，包括学生ID、姓名、数学成绩和物理成绩。学生ID是每个学生的唯一识别号，互不相同，而姓名可能有重复。程序需求使用ArrayList来存储学生信息。输入格式：输入多个学生的成绩信息，每个学生的成绩信息格式为：学生ID+英文空格+姓名+英文空格+数学成绩+英文空格+物理成绩。使用'end'作为输入结束标志。输出格式：根据数学和物理成绩总分从高到低排序输出所有学生信息。每个学生信息的输出格式为：学生ID+英文空格+姓名+英文空格+数学和物理成绩总和。如果成绩相同，按照输入顺序输出。程序执行过程的详细解释： 1. 首先，我们创建一个Student类来表示学生信息，包括ID、姓名、数学成绩和物理成绩。Student类还提供了一个返回数学和物理成绩总和的方法。 2. 然后，我们在主函数main()中使用Scanner来接收用户输入的学生信息。同时，我们创建一个ArrayList类型的列表students来存储学生对象。 3. 提示用户输入学生信息，当用户输入"end"时停止输入。对于每一个学生，我们使用split()方法根据空格将输入的字符串拆分为四部分：学生ID、姓名、数学成绩和物理成绩。 4. 我们将这些信息转换成相应的数据类型（如将学生ID和成绩转换为整数），然后创建一个新的Student对象，并添加到students列表中。 5. 输入完毕后，我们使用Collections.sort()方法对students列表进行排序。这里我们使用Lambda函数自定义排序规则，按照数学和物理成绩总分从高到低排序。 6. 最后，遍历students列表，按照指定格式输出学生信息。通过这个程序，我们可以实现输入多个学生的成绩信息，并基于数学和物理成绩总分从高到低排序输出学生列表。这个程序可以很容易地扩展以支持更多的学生信息和成绩科目。

第二题

题目内容：课程成绩统计程序-3

public class Grade {
    private final CourseGrade courseGrade;
    private final SubGrade subGrade;

    public Grade(CourseGrade courseGrade, SubGrade subGrade) {
        this.courseGrade = courseGrade;
        this.subGrade = subGrade;
    }

    // getters and setters
}
public class SubGrade {
    private int gradeScore;
    private double weight;

    public SubGrade(int gradeScore, double weight) {
        this.gradeScore = gradeScore;
        this.weight = weight;
    }

    // getters and setters
}
import java.util.List;

public class CourseGrade {
    private List<SubGrade> subGrades;

    public CourseGrade(List<SubGrade> subGrades) {
        this.subGrades = subGrades;
    }

    // getters and setters
}
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        ArrayIntegerStack stack = new ArrayIntegerStack(n);
        
        int m = scanner.nextInt();
        for (int i = 0; i < m; i++) {
            Integer pushed = scanner.nextInt();
            System.out.println(stack.push(pushed));
        }
        
        System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
        System.out.println(Arrays.toString(stack.getElements()));
        
        int x = scanner.nextInt();
        for (int i = 0; i < x; i++) {
            System.out.println(stack.pop());
        }
        
        System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
        System.out.println(Arrays.toString(stack.getElements()));

        scanner.close();
    }
}

输入: 课程信息和成绩信息。课程信息包括课程名称、课程性质和评估方法。成绩信息包括学生学号、姓名、课程名称、平时成绩和期末成绩。
输出: 输出包括学生所有课程总分平均分数，单个课程的成绩平均分数，整个班级的所有课程成绩平均分数三部分。
首先，需要创建一个课程类（Course），其中包含课程名称、课程性质（必修课或选修课）以及评估方法（考试或评估，如果为必修课则为考试）。
其次，创建一个学生类（Student），包含学生ID、姓名、课程及其对应的分数。
创建一个班级类（Class），包含班级编号、课程列表和学生列表。
对于输入部分，请创建一个解析输入数据的方法，将输入数据解析为课程和成绩信息，然后将这些信息添加到相应的对象中，例如添加课程到课程列表，添加学生到学生列表等。
创建一个计算平均分数的方法，用以计算三个关键数据：a) 学生所有课程成绩的平均分数；b) 各个课程的平均分数；c) 整个班级所有课程成绩的平均分数。
考虑到处理异常情况，对输入的数据检查课程名称、评估方式、课程性质等是否合规。
最后，在主函数中，从输入中获取信息，然后将解析后的数据存储在相应的对象中。利用存储的数据，计算三个关键数据，并将结果打印出来。
异常情况:
1. 当解析某个成绩信息时，如果课程名称不存在于输入的课程列表中，输出："该课程不存在"
2. 当解析某个成绩信息时，如果输入的成绩与课程评估方式不匹配，输出："评估方式不匹配"
3. 当解析某个课程信息时，如果输入的课程性质和评估方法不匹配，输出："课程类型和评估方式不匹配" 4) 格式错误和其他信息异常（如成绩超出范围）将作为格式错误处理，并输出"格式错误" 5) 如果出现重复的课程/成绩信息，仅保留第一个课程信息，忽略后续输入。信息约束: 1) 成绩平均分的小数部分被舍弃，仅保留整数部分总之，此问涉及大学课程分为必修课和选修课两种，评估方法包括考试和评估。要求输入课程信息和成绩信息，输出包含三部分内容：学生所有课程成绩的平均分数、单个课程成绩的平均分数以及整个班级所有课程成绩的平均分数。此外，还需处理各种异常情况。

第三题

题目内容： jmu-Java-02基本语法-03-身份证排序

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

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        List<String> ids = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            ids.add(scanner.next());
        }

        while (scanner.hasNext()) {
            String command = scanner.next();
            if (command.equals("sort1")) {
                List<String> sortedIds = sortByIdDate(ids);
                for (String id : sortedIds) {
                    System.out.println(formatIdDate(id));
                }
            } else if (command.equals("sort2")) {
                List<String> sortedIds = sortById(ids);
                for (String id : sortedIds) {
                    System.out.println(id);
                }
            } else {
                System.out.println("exit");
                break;
            }
        }
    }

    /**
     * Sorts a list of IDs by the date they represent (the 7th-14th digits).
     * Returns a new list, leaving the original list untouched.
     */
    private static List<String> sortByIdDate(List<String> ids) {
        List<String> sortedIds = new ArrayList<>(ids);
        Collections.sort(sortedIds, (id1, id2) -> {
            String date1 = id1.substring(6, 14);
            String date2 = id2.substring(6, 14);
            return date1.compareTo(date2);
        });
        return sortedIds;
    }

    /**
     * Sorts a list of IDs by their natural order (string comparison).
     * Returns a new list, leaving the original list untouched.
     */
        private static List<String> sortById(List<String> ids) 
        {
        List<String> sortedIds = new ArrayList<>(ids);
        Collections.sort(sortedIds, (id1, id2) -> {
        String id1Substring = id1.substring(6);
        String id2Substring = id2.substring(6);
        return id1Substring.compareTo(id2Substring);
    });
    return sortedIds;
}

    /**
     * Formats an ID string to a year-month-day format (YYYY-MM-DD).
     * Assumes that the ID string is valid and has at least 14 characters.
     */
    private static String formatIdDate(String id) {
        String year = id.substring(6, 10);
        String month = id.substring(10, 12);
        String day = id.substring(12, 14);
        return year + "-" + month + "-" + day;
    }
}

总结：这个问题的需求是编写一个Java程序，首先输入n，然后顺序输入n个身份证号码。根据输入的sort1或sort2执行不同的功能。如果输入既不是sort1，也不是sort2，则输出“exit”并退出程序。输入sort1，需要提取每个身份证号码的年份、月份和日期，然后以年月日的格式组合这些数据，并按升序输出组合后的年月日。输入sort2，需要按照年、月、日的顺序输出所有升序排列的身份证号码。注意：在处理输入时，使用Scanner的nextLine()方法来避免错误。程序执行过程的详细解释： 1. 使用Scanner获取用户输入的信息，包括n、n个身份证号码和操作选项（sort1或sort2）。将输入的身份证号码存储在ArrayList类型的列表idNumbers中。 2. 根据用户输入的操作选项进行不同的操作： - 如果输入为sort1，需要提取每个身份证号码的出生年、月、日。我们使用substring()方法从身份证号码中获取出生日期部分。然后分别提取年、月、日，并重新组合成一个新的字符串，存储在一个新的ArrayList类型的列表dates中。按照升序对dates列表进行排序，并输出排序后的年、月、日。 - 若输入为sort2，我们需要根据身份证号码的出生年月日字段对身份证号码进行排序。我们可以使用Collections.sort()方法并使用Lambda表达式对idNumbers列表进行排序。在Lambda表达式中，我们提取两个身份证号码的出生年月日字段，然后进行比较。最后遍历idNumbers列表并输出排序后的身份证号码。 - 如果输入既不是sort1，也不是sort2，那么我们输出“exit”并退出程序。 3. 关闭Scanner对象。通过这个程序，我们可以实现输入n个身份证号码，并在输入sort1或sort2的情况下执行不同的操作。程序可以很容易地扩展以支持更多的排序功能和其他相关处理。

第四题

题目内容：jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack

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

interface IntegerStack {
    public Integer push(Integer item);
    public Integer pop();
    public Integer peek();
    public boolean empty();
    public int size();
}

class ArrayIntegerStack implements IntegerStack {
    private Integer[] elements;
    private int top;

    public ArrayIntegerStack(int n) {
        elements = new Integer[n];
        top = -1;
    }

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

    @Override
    public Integer pop() {
        if (empty()) {
            return null;
        }
        return elements[top--];
    }

    @Override
    public Integer peek() {
        if (empty()) {
            return null;
        }
        return elements[top];
    }

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

    @Override
    public int size() {
        return top + 1;
    }
    
    public Integer[] getElements() {
        return elements;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        ArrayIntegerStack stack = new ArrayIntegerStack(n);
        
        int m = scanner.nextInt();
        for (int i = 0; i < m; i++) {
            Integer pushed = scanner.nextInt();
            System.out.println(stack.push(pushed));
        }
        
        System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
        System.out.println(Arrays.toString(stack.getElements()));
        
        int x = scanner.nextInt();
        for (int i = 0; i < x; i++) {
            System.out.println(stack.pop());
        }
        
        System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
        System.out.println(Arrays.toString(stack.getElements()));

        scanner.close();
    }
}

总结：这个问题要求我们定义一个IntegerStack接口，该接口用于声明一个用于存储整数元素的栈的通用方法。然后定义一个名为ArrayIntegerStack的实现类，内部使用数组来实现 IntegerStack。主方法描述了需要的功能，如创建一个具有指定数组大小的ArrayIntegerStack对象，入栈、出栈操作，输出栈顶元素，判断栈是否为空和输出栈的大小等。程序执行过程： 1. 首先创建了一个IntegerStack接口，声明了栈的通用方法（push, pop, peek, empty 和size）。 2. 接下来，定义了一个ArrayIntegerStack实现类。在这个类中，使用数组实现IntegerStack接口。当创建一个ArrayIntegerStack对象时，可以指定内部数组的大小。此外，定义了toString()方法用于输出内部数组的值。 3. 最后，编写了一个名为StackDemo的主方法。主方法中，使用Scanner从用户获取输入，根据输入创建一个ArrayIntegerStack对象并进行入栈、出栈操作。同时，会输出栈顶元素、栈是否为空以及栈大小内部数组的值。通过这个程序，我们实现了一个使用整数数组实现的栈，并通过主方法实现了栈的各种操作。在ArrayIntegerStack类中，我们可以轻松地调用栈的操作以满足其他需求。

第五题

题目内容：jmu-Java-03面向对象基础-05-覆盖

import java.util.ArrayList;
import java.util.Objects;
import java.util.Scanner;
import java.lang.reflect.Constructor;

class PersonOverride {
    private String name;
    private int age;
    private boolean gender;

    public PersonOverride(String name, int age, boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public PersonOverride() {
        this("default", 1, true);
    }

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

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

    @Override
    public int hashCode() {
        return Objects.hash(name, age, gender);
    }
}

public class Main {
    public static void main(String[] args) throws NoSuchMethodException {
        Scanner scanner = new Scanner(System.in);
        int n1 = scanner.nextInt();
        ArrayList<PersonOverride> persons1 = new ArrayList<>();
        for (int i = 0; i < n1; i++) {
            persons1.add(new PersonOverride());
        }

        int n2 = scanner.nextInt();
        ArrayList<PersonOverride> persons2 = new ArrayList<>();
        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);
            if (!persons2.contains(person)) {
                persons2.add(person);
            }
        }

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

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

        System.out.println(persons2.size());
        
       Constructor<?> constructor1 = PersonOverride.class.getConstructor();
        Constructor<?> constructor2 = PersonOverride.class.getConstructor(String.class, int.class, boolean.class);
        ArrayList<Constructor> constructors=new ArrayList<>();
        constructors.add(constructor1);
        constructors.add(constructor2);
        System.out.println(constructors);
    }
}

总结：这个问题要求我们定义一个名为PersonOverride的类，并重写其toString和equals方法。创建一个含有属性name、age和gender的PersonOverride类，实现一个带参数的构造方法和一个不带参数的构造方法。toString方法返回name、age和gender的组合格式，equals方法需要对name、age和gender进行比较，所有属性相同才返回true。接下来，我们需要编写一个包含以下功能的主方法： 1. 输入n1，使用无参数构造方法创建n1个对象，并将它们放入数组persons1。 2. 输入n2，并指定name、age和gender。每次创建对象时，使用equals方法将它与数组中已有对象进行比较。如果对象在数组中不存在，则将新对象放入persons2数组。 3. 输出persons1数组中的所有对象。 4. 输出persons2数组中的所有对象。 5. 输出persons2数组中实际包含的对象数量。 6. 输出PersonOverride类的所有构造方法。首先，我们定义PersonOverride类，并重写其toString和equals方法。然后，创建一个主方法来实现任务功能。在主方法中，首先通过Scanner获取用户输入，然后根据输入使用构造方法创建PersonOverride对象并进行比较。最后输出所需的信息，包括所有对象和类的构造方法。

标签：题目,String,第六,System,第八次,课程,成绩,public,输入
From： https://www.cnblogs.com/arcticquality/p/17512458.html

第六到第八次题目集总结

第六到第八次题目集总结

一、题目集六

第一题

二、题目集七

题目集总述

第一题

第二题

第三题

第四题

三、题目集八

第一题

第二题

第三题

第四题

第五题

相关文章

赞助商

阅读排行

第六到第八次题目集总结

第六到第八次题目集总结

一 、题目集六

第一题

二 、题目集七

题目集总述

第一题

第二题

第三题

第四题

三 、题目集八

第一题

第二题

第三题

第四题

第五题

相关文章

赞助商

阅读排行

一、题目集六

二、题目集七

三、题目集八