题目集1~3的总结性Blog

前言:
题集题目量少而精,难度递增,涉及的知识点广泛而不交叉.
分析:
耗时三个星期,在PTA这个作业平台上写了三次JAVA编程作业,几乎每次,每道题都有收获.
这三次题集考察的知识点范围广,普适性强,第一次第一题就让我们初步了解了如何正确建立一个类,尽管这些在IDEA里都可以自动补全完成,但我知道PTA平台(由浙江大学创建的教学平台)功能足够强大,为考验学生的独立自主代码能力,将其自动补全功能搞残废,甚至连库都需要学生手动输入,但我相信这一定是浙江大学这所学校的产品的高明之处,一定有我没有发现的不可透露但在潜移默化中对学生受益匪浅之处,
比如第一章第一题:
设计一个名为Fan的类表示一个风扇。这个类包括：

1.三个名为SlOW、MEDIUM和FAST，其值为1、2和3常量表示风扇的速度。

2.一个名为speed的int类型私有数据域表示风扇的速度（默认值为SLOW）。

3.一个名为on的boolean类型私有数据域表示风扇是否打开（默认值为false）。

4.一个名为radius的double类型私有数据域表示风扇的半径（默认值为5）。

5.一个名为color的string类型数据域表示风扇的颜色（默认值为white）。

6.这四个成员变量(数据域)的访问器和修改器。

7.一个无参构造方法;

8.一个有参构造方法 public Fan(int fanSpeed,boolean fanOn,double fanRadius,String fanColor) { ... }，

9.一个名为toString()的方法返回描述风扇的字符串。如果风扇是打开的，那么该方法在一个组合的字符串中返回风扇的速度、颜色和半径。如果风扇没有打开，该方法就会返回一个由"fan is off"和风扇颜色以及半径组合成的字符串。

请在自己的草稿本上画出UML图，养成良好的设计习惯。

要求：创建两个Fan对象：

第一个对象利用无参构造方法构造默认风扇对象Fan1；

第二个对象依据输入的风扇属性，调用有参构造方法构造自定义风扇对象Fan2。

通过调用它们的toString方法显示这些对象。

输入格式:
第二个对象的属性

输出格式:
分别输出默认风扇和自定义风扇的速度、颜色、半径以及风扇是否打开

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

2
True
6
Red
输出样例:
在这里给出相应的输出。例如：
Default
speed 1
color white
radius 5.0
fan is off
My Fan
speed 2
color Red
radius 6.0
fan is on

在Fan类中定义了默认构造函数和带参数的构造函数，用于初始化风扇对象的属性。同时，还提供了获取和设置风扇属性的方法，如getSpeed、setSpeed、isOn、setOn、getRadius、setRadius、getColor、setColor。
最后，Fan类还实现了toString方法，根据风扇的开关状态，返回包含风扇属性信息的字符串。如果风扇是关闭的，则返回"speed x\n color y \n radius z \n fan is off"，如果风扇是打开的，则返回"speed x \n color y \n radius z \n fan is on"。
toString()和showInfo()告诉了我们如何展示类的成员的信息

第一章第二题:
1.创建一个类Student,具体属性和方法如下：
属性：（全部私有,数据类型自己选择使用）
姓名（name）,性别(sex)，学号（studentID），年龄(age)，专业（major）
方法：
（1）定义一个空参数构造器public Student();
（2）定义一个多参数的构造器，用于为所有属性赋值public Student(String name,String sex,String studentID,int age,String major)
（3）由于所有属性私有的，为所有属性提供getter（）和setter（）方法；
（4）public String toString()用于返回学生的所有属性信息；
（5）public void printInfo()用于打印学生的信息
2.定义一个测试类Test，在main方法中创建一个Student对象，根据提示输入学生信息保存在对象中，调用printInfo()方法输出学生信息。
3.输出结果参考“输出样例”
输入格式:
请在这里写输入格式。例如：输入在一行中给出2个绝对值不超过1000的整数A和B。

输出格式:
姓名：Tom，性别：23，学号：20221201234,年龄：23,专业：计算机科学

"public+返回值+名称"即可在类里构建一个属于类的方法
还有了解成员私有化以封装数据.
这题是对创建类的成员的熟练化.

代码主要涉及学生信息的录入和显示。

首先，定义了一个名为Main的主类，包含一个主方法main。在主方法中，首先创建一个Scanner对象in，用于读取输入的信息。
接下来，创建一个长度为5的Student数组students，用于保存学生对象。
然后，通过for循环，依次读取每个学生的信息，并创建Student对象，将其赋值给students数组对应的位置。
每个学生对象的信息包括学生编号(stuID)、姓名(name)、语文成绩(ChiScore)、数学成绩(MatScore)、物理成绩(PhyScore)。

然后，再通过一个循环，依次打印每个学生对象的信息。在循环中，通过调用Student对象的方法getStuID()、getName()、sumScore()、avgScore()，
分别获取学生的学号、姓名、总成绩、平均成绩，并使用System.out.printf()方法格式化输出这些信息。
每个学生对象的信息以空格分隔，每个学生对象的信息在一行上显示，最后通过System.out.println()打印换行符。

接下来，定义了一个内部静态类Student，用于表示学生对象。该类包含了私有的实例变量stuID、name、ChiScore、MatScore、PhyScore，
分别表示学号、姓名、语文成绩、数学成绩、物理成绩。另外，还定义了以下成员方法：

sumScore()：计算学生的总成绩，将语文、数学、物理成绩相加并返回结果。
avgScore()：计算学生的平均成绩，将总成绩除以3.0并返回结果。
构造方法：提供了一个无参构造方法和一个带参数的构造方法，用于初始化学生对象的各个属性值。
getter和setter方法：用于获取和设置学生对象的各个属性值。
toString()方法：将学生对象的信息以字符串的形式返回，包括学号、姓名、总成绩、平均成绩。
总而言之，我的这段代码实现了学生信息的录入和显示功能。通过循环读取输入的学生信息，创建学生对象并保存在数组中，
然后通过循环遍历数组打印每个学生对象的信息。通过这种方式，实现了将学生信息以规范的格式输出的功能。

第一章第三题:
创建学生类，包含

属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）

方法：计算总分、计算平均分

输入5个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365

注意：未用学生类对象封装数据的，本题计0分

输入格式:
5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80

22201312 黄昊 66 82 81

22201313 李少辰 77 76 80

22201314 袁婷 62 79 90

22201315 朱哲一 74 98 94

输出格式:
5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：

22201311 张琳 240 80.00

22201312 黄昊 229 76.33

22201313 李少辰 233 77.67

22201314 袁婷 231 77.00

22201315 朱哲一 266 88.6

这题除了在原有的类的建立的基础上,还学习了集合与结果保留两位小数的四种方法:
4种方法，都是四舍五入，例：

---

** import java.math.BigDecimal;**
** import java.text.DecimalFormat;**
** import java.text.NumberFormat;**
** public class format {**
** double f = 111231.5585;**
** public void m1() {**
** BigDecimal bg = new BigDecimal(f);**
** double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();**
** System.out.println(f1);**
** }**
** /****
** * DecimalFormat转换最简便**
** /*
** public void m2() {**
** DecimalFormat df = new DecimalFormat("#.00");**
** System.out.println(df.format(f));**
** }**
** /****
** * String.format打印最简便**
** /*
** public void m3() {**
** System.out.println(String.format("%.2f", f));**
** }**
** public void m4() {**
** NumberFormat nf = NumberFormat.getNumberInstance();**
** nf.setMaximumFractionDigits(2);**
** System.out.println(nf.format(f));**
** }**
** public static void main(String[] args) {**
** format f = new format();**
** f.m1();**
** f.m2();**
** f.m3();**
** f.m4();**
** }**
** }**
//还有一种直接向上取整数
**//java:Java的取整函数 **

---

---

---

** //Math.floor()、Math.ceil()、BigDecimal都是Java中的取整函数，但返回值却不一样**

---

** Math.floor()**
** 通过该函数计算后的返回值是舍去小数点后的数值**
** 如：Math.floor(3.2)返回3**
** Math.floor(3.9)返回3**
** Math.floor(3.0)返回3**

---

** Math.ceil()**
** ceil函数只要小数点非0，将返回整数部分+1**
** 如：Math.ceil(3.2)返回4**
** Math.ceil(3.9)返回4**
** Math.ceil(3.0)返回3 **
我相信掌这些方法一定能让我受益匪浅.

第一章第四题:
创建成绩类，包含：

属性：平时成绩（int）、期末成绩（int）

方法：计算总成绩（计算规则：平时成绩0.4+期末成绩0.6，保留整数部分，小数部分直接丢弃）

创建学生类，包含：

属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）

方法：计算总分、计算平均分

输入3个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365

注意：未用学生类对象封装数据的，本题计0分

输入格式:
依次输入3个学生的每门课成绩，每个学生成绩信息格式：

学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致

例如：
22201311 张琳 语文 70 80

22201311 张琳 数学 85 89

22201311 张琳 物理 75 83

22201312 黄昊 语文 66 78

22201312 黄昊 数学 76 82

22201312 黄昊 物理 83 82

22201313 李少辰 语文 86 76

22201313 李少辰 数学 78 76

22201313 李少辰 物理 87 76

输出格式:
3个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：

22201311 张琳 242 80.67

22201312 黄昊 234 78.00

22201313 李少辰 236 78.67
这题让我熟练掌握对类内成员的数据处理
输入格式:
程序输入信息分三部分：

1、题目数量

格式：整数数值，若超过1位最高位不能为0，

样例：34

2、题目内容

一行为一道题，可以输入多行数据。

格式："#N:"+题号+" "+"#Q:"+题目内容+" "#A:"+标准答案

格式约束：题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。

样例：#N:1 #Q:1+1= #A:2

     #N:2 #Q:2+2= #A:4

3、答题信息

答题信息按行输入，每一行为一组答案，每组答案包含第2部分所有题目的解题答案，答案的顺序号与题目题号相对应。

格式："#A:"+答案内容

格式约束：答案数量与第2部分题目的数量相同，答案之间以英文空格分隔。

样例：#A:2 #A:78

  2是题号为1的题目的答案
  78是题号为2的题目的答案

答题信息以一行"end"标记结束，"end"之后的信息忽略。

输出格式:
1、题目数量

格式：整数数值，若超过1位最高位不能为0，

样例：34

2、答题信息

一行为一道题的答题信息，根据题目的数量输出多行数据。

格式：题目内容+" ~"+答案

样例：1+1=~2

      2+2= ~4

3、判题信息

判题信息为一行数据，一条答题记录每个答案的判断结果，答案的先后顺序与题目题号相对应。

格式：判题结果+" "+判题结果

格式约束：

 1、判题结果输出只能是true或者false，
 2、判题信息的顺序与输入答题信息中的顺序相同

我的源码:
package Homework;

import java.util.ArrayList;
import java.util.Scanner;

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

    //String Nstyle = "^#N:\\d+ #Q:.+ #A:.+$";
    //String Astyle = "^#A:.+( #A:.+)*$";

    ArrayList<Titles> titles = new ArrayList<>();
    ArrayList<Titles> otitles =new ArrayList<>();
    ArrayList<Response> responses = new ArrayList<>();

    String tempStr = "";
    for (int titileIndex = 0; titileIndex < titileNum; titileIndex++) {
        tempStr = in.nextLine();
        Titles t = new Titles(tempStr);
        t.setSequence(titileIndex+1);
        titles.add(t);
    }
    String[] allTheAnswers = in.nextLine().split(" ");
    for (int allTheAnswersIndex = 0; allTheAnswersIndex < allTheAnswers.length; allTheAnswersIndex++) {
        Response r =new Response(allTheAnswers[allTheAnswersIndex],Integer.parseInt(titles.get(allTheAnswersIndex).getTitle()));
        responses.add(r);
    }
    System.out.println();

    titles = BubbleSortTitle(titles);

    for (int titlesIndex = 0; titlesIndex < titles.size(); titlesIndex++) {
        System.out.println(titles.get(titlesIndex).getQuestionStem()+"~"+responses.get(titlesIndex).getResAnswer());
    }
    for (int titlesIndex = 0; titlesIndex < titles.size(); titlesIndex++) {
        System.out.print(titles.get(titlesIndex).getAnswer().equals(responses.get(titlesIndex).getResAnswer())+" ");
    }

}
//感觉Bubble可以写一个父类继承
public static ArrayList<Response> BubbleSortResponse(ArrayList<Response> r){
    for(int i = 0;i<r.size()-1;i++){
        for(int j=0;j<r.size()-1-i;j++){
            if(r.get(i).getRid()>r.get(i+1).getRid()){
                Response temp = new Response();
                temp = r.get(i);
                r.set(i,r.get(i+1));
                r.set(i+1,temp);
            }
        }
    }
    return r;
}
public static ArrayList<Titles> BubbleSortTitle(ArrayList<Titles> t){
    for(int i = 0;i<t.size()-1;i++){
        for(int j=0;j<t.size()-1-i;j++){
            if(Integer.parseInt(t.get(i).getTitle())>Integer.parseInt(t.get(i+1).getTitle())){
                Titles temp = new Titles();
                temp = t.get(i);
                t.set(i,t.get(i+1));
                t.set(i+1,temp);
            }
        }
    }
return t;
}

}
class Titles{
private String title;
private String questionStem;
private String answer;
private int sequence;

public int getSequence() {
    return sequence;
}

public void setSequence(int sequence) {
    this.sequence = sequence;
}

public String getTitle() {
    return title;
}

public void setTitle(String title) {
    this.title = title;
}

public String getQuestionStem() {
    return questionStem;
}

public void setQuestionStem(String questionStem) {
    this.questionStem = questionStem;
}

public String getAnswer() {
    return answer;
}

public void setAnswer(String answer) {
    this.answer = answer;
}

public Titles() {
}

public Titles(String title, String questionStem, String answer) {
    this.title = title;
    this.questionStem = questionStem;
    this.answer = answer;
}
public Titles(String tempStr){
    String[] parts = tempStr.split(" #");
    this.title = parts[0].substring(3).replace(" ","");
    this.questionStem = parts[1].substring(2).trim();
    this.answer = parts[2].substring(2);
}
public String toString(){
    return title+" "+questionStem+" "+answer;
}

}
class Response{
private String resAnswer;
private int rid;
private int sequence;

public int getSequence() {
    return sequence;
}

public void setSequence(int sequence) {
    this.sequence = sequence;
}

public String getResAnswer() {
    return resAnswer;
}

public void setResAnswer(String resAnswer) {
    this.resAnswer = resAnswer;
}

public int getRid() {
    return rid;
}

public void setRid(int rid) {
    this.rid = rid;
}

public Response() {
}

public Response(String resAnswer, int rid) {
    this.resAnswer = resAnswer.substring(3);
    this.rid = rid;
}
public String toString(){
    return rid +" "+resAnswer;
}

}
**这题考察了我对成员数据的处理能力,稍有不慎就做不出,比如题目类还要再添加一个输入顺序的成员,方便在按题号排序后再与作答进行比较.
在源代码中，主要的类有 Main、Titles 和 Response。Main 类是程序的主类，包含了 main 方法，用于接收用户输入、处理问题和展示结果。Titles 类代表一个题目，包含题目的编号、内容和答案等属性。Response 类表示用户的回答，包含回答的内容和一个标识符。

除了主类外，Main 类还包含了两个静态方法 BubbleSortResponse 和 BubbleSortTitle，分别用于对回答和题目进行冒泡排序。

整个程序我的逻辑是先获取用户输入的题目和回答，然后将题目按照编号升序排列，接着将每个题目和相应的回答输出，最后比较每道题的答案和用户的回答是否一致，并输出比较结果。**

第二章第一题:
编写手机类（MobilePhone），含有type（型号，String类型）、price（价格，int类型）属性，要求该类实现Comparable接口，重写compareTo方法，实现按照price的大小来确定两个手机对象的大小关系。

在链表中添加三个手机对象（从键盘输入），通过Collections类的sort方法对链表中的对象按照price升序排序。输入第四个手机对象的信息，并查找它的price是否与链表中某个对象的price相同。

输入格式:
先输入三部手机的型号、价格信息
再输入要查找的第四部手机的型号、价格信息
每部手机信息的格式如：Redmi9A 599

输出格式:
先输出三部手机排序前的信息
再输出三部手机排序后的信息
最后输出第四部手机是否与前面

**
在Main类的main方法中，首先通过Scanner类获取用户输入的3个手机型号和价格，然后将这些信息存储在ArrayList中。然后再输入一个新手机的型号和价格信息，用于后续比较。

接着对输入的手机信息进行排序，然后输出排序前的手机数据和排序后的手机数据。

最后，通过比较新手机的价格和已有手机列表中的手机是否有相同价格的手机，输出结果，反映是否有价格相同的手机存在于列表中。

在排序的过程中，Collections类中实现了sort方法，使用选择排序算法对手机列表进行排序，根据手机的价格进行升序排列。
额外学习了重写方法和连接接口和抽象类和继承等重要基础知识点.**

第二章第二题:
按要求完成程序的编写。
1、定义圆类Circle，其中包括：
（1）成员变量：private int radius
（2）无参构造方法 ，给radius赋值为2，并输出信息："This is a constructor with no para."；
（2）有参构造方法 ，接收用户给的radius赋值，并输出"This is a constructor with para."（如果给的半径小于等于0,则赋默认值为2）；
（3）为radius添加set方法，接收用户输入的半径，如果用户输入半径为<=0,则让半径的值为2；
（4）为radius半径添加get方法，返回用户输入的半径；
（5）求圆面积方法getArea(), π使用Math.PI代替；
（6）定义toString方法，public String toString( )方法体为：
return "Circle [radius=" + radius + "]";

2、定义Main类，在main方法中，完成下列操作：
（1）定义并创建Circle类对象c1，输出c1对象，求c1的面积并输出；
（2）定义并创建Circle类对象c2，输出c2对象，求c2的面积并输出；
（3）从键盘接收整数半径，赋值给c2的半径，输出c2对象，求c2的面积并输出；
（4）从键盘接收整数半径，用有参构造方法创建Circle类对象c3，输出c3对象，求c3的面积后输出。
输入格式:
输入有多行。每行包括一个整数的圆的半径。

输出格式:
按照题目要求，输出圆构造方法的输出信息、圆对象的字符中描述信息、及圆的面积（其中圆的面积保留2位小数）。上述信息各占一行。
**
我的Java代码定义了一个圆Circle类和一个主类Main。在主类Main中，首先创建了两个默认半径为2的圆对象c1和c2，然后分别打印出它们的信息和面积。接着通过用户输入来设置第二个圆对象c2的半径，并再次打印出其信息和面积。

接着又创建了第三个圆对象c3，通过用户输入设置其半径，并打印出c3的信息和面积。

在Circle类中，定义了无参数构造函数和有参数构造函数，分别用于创建默认半径为2的圆对象和根据用户给定半径创建圆对象。还定义了获取半径、设置半径、获取面积和返回圆信息的方法。主要目的是使用自定义类Circle来实现圆的相关操作，包括创建圆对象、设置半径、计算面积和显示圆信息。
简单的重新复习类的构造**

第二章第四题:
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-1基础上增补或者修改的内容。

要求输入题目信息、试卷信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。

输入格式:

程序输入信息分三种，三种信息可能会打乱顺序混合输入：

1、题目信息

一行为一道题，可输入多行数据（多道题）。

格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案

格式约束：

1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。

样例：#N:1 #Q:1+1= #A:2

     #N:2 #Q:2+2= #A:4

2、试卷信息

一行为一张试卷，可输入多行数据（多张卷）。

格式："#T:"+试卷号+" "+题目编号+"-"+题目分值

 题目编号应与题目信息中的编号对应。

 一行信息中可有多项题目编号与分值。

样例：#T:1 3-5 4-8 5-2

3、答卷信息

答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序与试卷信息中的题目顺序相对应。

格式："#S:"+试卷号+" "+"#A:"+答案内容

格式约束：答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。

样例：#S:1 #A:5 #A:22

   1是试卷号 

   5是1号试卷的顺序第1题的题目答案

   22是1号试卷的顺序第2题的题目答案

答题信息以一行"end"标记结束，"end"之后的信息忽略。

输出格式:

1、试卷总分警示

该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100分，该部分忽略，不输出。

格式："alert: full score of test paper"+试卷号+" is not 100 points"

样例：alert: full score of test paper2 is not 100 points

2、答卷信息

一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。

格式：题目内容+"_"+答案++""+判题结果（true/false）

约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"

样例：3+2=₅true

     4+6=~22~false.

  answer is null

3、判分信息

判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。

格式：题目得分+" "+....+题目得分+"~"+总分

格式约束：

1、没有输入答案的题目计0分

2、判题信息的顺序与输入答题信息中的顺序相同
样例：5 8 0~13

根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。

4、提示错误的试卷号

如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”，参见样例9。
在第一章最后一题的基础上进行了大升级,对数据的梳理难度指数级上升,一下是我的代码:
import java.util.*;

public class ExamSystem {
static class Question {
String id;
String content;
String answer;

    Question(String id, String content, String answer) {
        this.id = id;
        this.content = content;
        this.answer = answer;
    }
}

static class TestPaper {
    String id;
    Map<String, Integer> questions = new LinkedHashMap<>();

    TestPaper(String id) {
        this.id = id;
    }

    void addQuestion(String questionId, int score) {
        questions.put(questionId, score);
    }
}

static class Submission {
    String testPaperId;
    List<String> answers;

    Submission(String testPaperId, List<String> answers) {
        this.testPaperId = testPaperId;
        this.answers = answers;
    }
}

private static final Map<String, Question> questions = new HashMap<>();
private static final Map<String, TestPaper> testPapers = new HashMap<>();
private static final List<Submission> submissions = new ArrayList<>();

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String input;
    while (!(input = scanner.nextLine()).equals("end")) {
        if (input.startsWith("#N:")) {
            parseQuestion(input);
        } else if (input.startsWith("#T:")) {
            parseTestPaper(input);
        } else if (input.startsWith("#S:")) {
            parseSubmission(input);
        }
    }

    // Check and alert for test papers not totaling 100 points
    for (TestPaper paper : testPapers.values()) {
        int totalScore = paper.questions.values().stream().mapToInt(Integer::intValue).sum();
        if (totalScore != 100) {
            System.out.println("alert: full score of test paper" + paper.id + " is not 100 points");
        }
    }

    // Process each submission
    for (Submission submission : submissions) {
        TestPaper paper = testPapers.get(submission.testPaperId);
        if (paper == null) {
            System.out.println("the test paper number does not exist");
            continue;
        }

        List<String> answers = submission.answers;
        List<Integer> scores = new ArrayList<>();
        int totalScore = 0;

        int index = 0;
        for (Map.Entry<String, Integer> entry : paper.questions.entrySet()) {
            Question question = questions.get(entry.getKey());
            int score = 0;
            String submittedAnswer = index < answers.size() ? answers.get(index) : "answer is null";
            boolean correct = submittedAnswer.equals(question.answer);

            if (correct) {
                score = entry.getValue();
                totalScore += score;
            }
            scores.add(score);

            System.out.println(question.content + "~" + submittedAnswer + "~" + correct);
            index++;
        }

        System.out.println(scores.stream().map(String::valueOf).collect(Collectors.joining(" ")) + "~" + totalScore);
    }
}

private static void parseQuestion(String input) {
    String[] parts = input.split(" ");
    String id = parts[0].substring(3);
    String content = parts[1].substring(3);
    String answer = parts[2].substring(3);
    questions.put(id, new Question(id, content, answer));
}

private static void parseTestPaper(String input) {
    String[] parts = input.split(" ");
    String id = parts[0].substring(3);
    TestPaper paper = new TestPaper(id);
    for (int i = 1; i < parts.length; i++) {
        String[] questionInfo = parts[i].split("-");
        paper.addQuestion(questionInfo[0], Integer.parseInt(questionInfo[1]));
    }
    testPapers.put(id, paper);
}

private static void parseSubmission(String input) {
    String[] parts = input.split(" ");
    String testPaperId = parts[0].substring(3);
    List<String> answers = new ArrayList<>();
    for (int i = 1; i < parts.length; i++) {
        if (parts[i].startsWith("#A:")) {
            answers.add(parts[i].substring(3));
        }
    }
    submissions.add(new Submission(testPaperId, answers));
}

}
**在主函数main中，通过Scanner获取用户输入的信息，并根据以#N:、#T:和#S:开头的不同输入来解析问题、试卷和提交信息。然后对于每份试卷，检查其包含的问题总分是否为100分，如果不是则输出警告信息。接着处理每份考生的答题情况，逐个问题进行评分，并输出每题得分以及总分。

parseQuestion方法用来解析问题信息，包括问题的id、内容和答案，并将问题添加到questions映射中。parseTestPaper方法用来解析试卷信息，包括试卷id和包含的问题及每题的分值，并将试卷添加到testPapers映射中。parseSubmission方法用来解析考生的提交信息，包括试卷id和每道题的答案，然后将提交信息添加到submissions列表中。

整体流程是先解析所有问题和试卷信息，然后处理考生的提交信息，最后按照评分规则进行打分和统计总分，并输出评分结果。**

第三章第一题:

Student类具体要求如下：
私有成员变量：学号(sid，String类型)，姓名(name，String类型)，年龄(age，int类型)，专业(major，String类型) 。
提供无参构造和有参构造方法。（注意：有参构造方法中需要对年龄大小进行判定）
普通成员方法：print()，输出格式为“学号：6020203100，姓名：王宝强，年龄：21，专业：计算机科学与技术”。
普通成员方法：提供setXxx和getXxx方法。（注意：setAge()方法中需要对年龄进行判定）
注意：
年龄age不大于0，则不进行赋值。
print()中的“：”和“，”为均为中文冒号和逗号。

public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//调用无参构造方法，并通过setter方法进行设值
String sid1 = sc.next();
String name1 = sc.next();
int age1 = sc.nextInt();
String major1 = sc.next();
Student student1 = new Student();
student1.setSid(sid1);
student1.setName(name1);
student1.setAge(age1);
student1.setMajor(major1);
//调用有参构造方法
String sid2 = sc.next();
String name2 = sc.next();
int age2 = sc.nextInt();
String major2 = sc.next();
Student student2 = new Student(sid2, name2, age2, major2);
//对学生student1和学生student2进行输出
student1.print();
student2.print();
}
}

/* 请在这里填写答案 */

输入格式:
无

输出格式:
学号：6020203110，姓名：王宝强，年龄：21，专业：计算机科学与技术
学号：6020203119，姓名：张三丰，年龄：23，专业：软件工程

**考察了对格式的一模一样的要求,比如中文逗号不能用英文逗号(这时候最好直接复制案例的输出)
代码实现了一个学生信息管理系统。首先，程序会创建一个Scanner对象sc，用于获取用户输入。接下来，程序会要求用户输入第一个学生的学号、姓名、年龄和专业信息，并通过调用Student类的setter方法，将这些属性值设置给第一个学生对象student1。

然后，程序会要求用户再次输入第二个学生的学号、姓名、年龄和专业信息，并通过调用Student类的有参构造方法，创建一个新的学生对象student2，并将输入的属性值设置给该对象。

最后，程序会分别调用两个学生对象的print方法，将学生的信息输出到控制台。print方法会将学生对象的学号、姓名、年龄和专业信息以一定格式进行输出。**

第三章第二题:
给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串，格式为"YYYY-MM-dd"
第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。

输出格式:
如果第一行日期字符串非法，输出自定义的错误信息。
如果第一行日期有效，输出相关信息，如果是闰年要输出是闰年。
如果第二行两个日期，只要有一个无效。就输出相关错误信息。
如果第二行两个日期有效且结束日期不早于开始日期，输出相关信息。

**JAVA中强大的时间类让我清楚的了解再也不用自己写方法计算年与年之间的差距的日期差和某年的某天是星期几.
在Java中，时间处理是一个常见的任务，Java提供了多个类来处理日期和时间。以下是一些主要的时间类：

java.util.Date：

这是Java最早的日期时间类，用于表示特定的时间点，以毫秒为单位。
java.util.Calendar：

Calendar类是一个抽象类，用于处理日期和时间操作。
它提供了对日期和时间字段的访问和操作，但使用起来比较麻烦。
java.util.GregorianCalendar：

GregorianCalendar是Calendar的一个具体子类，提供了标准的日历系统的实现。
java.time包：

Java 8引入了新的日期时间API，位于java.time包中，这个API设计更加清晰、简洁，并且线程安全。
一些重要的类包括：
LocalDate：表示日期，没有时间和时区信息。
LocalTime：表示时间，没有日期和时区信息。
LocalDateTime：表示日期和时间，没有时区信息。
ZonedDateTime：表示带时区的日期和时间。
Instant：表示时间戳。
Duration：表示时间间隔。
Period：表示日期间隔。
等等。
java.sql包：

Java中用于处理数据库的时间类，如java.sql.Date、java.sql.Time、java.sql.Timestamp等。
java.text.SimpleDateFormat：

这个类用于格式化日期，可以将日期对象转换为特定格式的字符串，也可以将特定格式的日期字符串解析为日期对象。
java.time.format.DateTimeFormatter：

Java 8引入的日期时间格式化类，用于格式化和解析日期时间对象。
**

第三章第三题:
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-2基础上增补或者修改的内容，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。

输入格式:

程序输入信息分五种，信息可能会打乱顺序混合输入。

1、题目信息
题目信息为独行输入，一行为一道题，多道题可分多行输入。

格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案

格式约束：
1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4

2、试卷信息

试卷信息为独行输入，一行为一张试卷，多张卷可分多行输入数据。
格式："#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...

格式约束：
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例：#T:1 3-5 4-8 5-2

3、学生信息

学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名，格式如下。

格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名

格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：
#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
4、答卷信息

答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序号与试 卷信息中的题目顺序相对应。答卷中：

格式："#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...

格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
答案内容可以为空，即””。
答案内容中如果首尾有多余的空格，应去除后再进行判断。
样例：
#T:1 1-5 3-2 2-5 6-9 4-10 7-3
#S:1 20201103 #A:2-5 #A:6-4
1是试卷号
20201103是学号
2-5中的2是试卷中顺序号，5是试卷第2题的答案，即T中3-2的答案
6-4中的6是试卷中顺序号，4是试卷第6题的答案，即T中7-3的答案
注意：不要混淆顺序号与题号

5、删除题目信息

删除题目信息为独行输入，每一行为一条删除信息，多条删除信息可分多行输入。该信息用于删除一道题目信息，题目被删除之后，引用该题目的试卷依然有效，但被删除的题目将以0分计，同时在输出答案时，题目内容与答案改为一条失效提示，例如：”the question 2 invalid~0”

格式："#D:N-"+题目号

格式约束：

   题目号与第一项”题目信息”中的题号相对应，不是试卷中的题目顺序号。

   本题暂不考虑删除的题号不存在的情况。      

样例：

N:1 #Q:1+1= #A:2

N:2 #Q:2+2= #A:4

T:1 1-5 2-8

X:20201103 Tom-20201104 Jack

S:1 20201103 #A:1-5 #A:2-4

D:N-2

end

输出
alert: full score of test paper1 is not 100 points
1+1=₅false
the question 2 invalid~0
20201103 Tom: 0 0~0
答题信息以一行"end"标记结束，"end"之后的信息忽略。

输出格式:

1、试卷总分警示

该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100 分，该部分忽略，不输出。

格式："alert: full score of test paper"+试卷号+" is not 100 points"

样例：alert: full score of test paper2 is not 100 points

2、答卷信息

一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。

格式：题目内容+"_"+答案++""+判题结果（true/false）

约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"
样例：
3+2=₅true
4+6=₂₂false.
answer is null

3、判分信息

判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。

格式：**学号+" "+姓名+": "**+题目得分+" "+....+题目得分+"~"+总分

格式约束：

 1、没有输入答案的题目、被删除的题目、答案错误的题目计0分
 2、判题信息的顺序与输入答题信息中的顺序相同
样例：20201103 Tom: 0 0~0

   根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。

4、被删除的题目提示信息

当某题目被试卷引用，同时被删除时，答案中输出提示信息。样例见第5种输入信息“删除题目信息”。

5、题目引用错误提示信息

试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。例如：

输入：

N:1 #Q:1+1= #A:2

T:1 3-8

X:20201103 Tom-20201104 Jack-20201105 Www

S:1 20201103 #A:1-4

end

输出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案输出时，一道题目同时出现答案不存在、引用错误题号、题目被删除，只提示一种信息，答案不存在的优先级最高，例如：
输入：

N:1 #Q:1+1= #A:2

T:1 3-8

X:20201103 Tom-20201104 Jack-20201105 Www

S:1 20201103

end

输出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0

6、格式错误提示信息

输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。

  例如：wrong format:2 #Q:2+2= #4

7、试卷号引用错误提示输出

如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出，参见样例8。

8、学号引用错误提示信息

如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。参见样例9。
**
对试卷的编号与题目应该在哪张试卷上是个极大的误解,没有解决这个问题就无法正确地解答,一下是我的代码:

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
//删除信息库
ArrayList removeNum = new ArrayList<>();
//输入信息分流
String input ="";
//学生信息库
ArrayList stu = new ArrayList<>();
//试卷类的整体
NN paper = new NN();
//试卷类的题库部分
ArrayList Nbank = new ArrayList<>();
do{
input = in.nextLine();
String tempStr = input.substring(0,2);
if(tempStr.equals("#N")){////#N:1 #Q:1+1= #A:2
N n = new N(input);
Nbank.add(n);

            }//#T:1(试卷号) 1-5(题目-分数) 2-8
            //有分值但是没有题干答案的题要打印
            //(按着顺序打)non-existent question~0
            else if(tempStr.equals("#T")){
                input = input.substring(3);
                paper.setNid(input.charAt(0)+"");
                String[] score = input.substring(2).split(" ");
                paper.setPerScore(score);



            }//#X:20201103(学号) Tom(姓名)-(分隔符)20201104 Jack-20201104 Www
            else if(tempStr.equals("#X")){
                input = input.substring(3);
                String[] students = input.split("-");
                for (int i= 0;i<students.length;i++) {
                    X student = new X(students[i]);
                    stu.add(student);
                }



            }//#S:1 20201103 #A:1-5 #A:2-4
            else if(tempStr.equals("#S")){
                input = input.substring(3);
                if(input.charAt(0)=='1'){
                    String[] returnPaper = input.split(" ");
                    for (int i = 0; i < stu.size(); i++) {
                        if(stu.get(i).getSid().equals(returnPaper[1])){
                            stu.get(i).setResponse(returnPaper);
                            break;
                        }
                    }
                }
            }//#D:N-2
            else if(tempStr.equals("#D")){
                input = input.substring(3);
                String[] inputParts = input.split(" ");
                for (int i = 0; i < inputParts.length; i++) {
                    removeNum.add(inputParts[i]);
                }
            }
        }while(!input.equals("end"));

        //给每道题赋分值,这里还得考虑给没有题号的Nbank集合创建一个新的N类
        for (int paperIndex = 0;paperIndex<paper.getPerScore().length;paperIndex++) {
            boolean isFind = false;
            for(int NbankIndex = 0; NbankIndex < Nbank.size(); NbankIndex++){
                String[] parts = paper.getPerScore()[paperIndex].split("-");
                //parts[0]是标题,part[1]是分值

                if(parts[0].equals(Nbank.get(NbankIndex).getNname().substring(3))){
                    Nbank.get(NbankIndex).setScore(Integer.parseInt(parts[1]));
                    isFind = true;
                    break;
                }
            }
            if(!isFind){
                N wrongN = new N("");
                wrongN.setNname("#N:"+paper.getPerScore()[paperIndex].split("-")[0]);
                wrongN.setScore(Integer.parseInt(paper.getPerScore()[paperIndex].split("-")[1]));
                Nbank.add(wrongN);
            }
        }
        /*
        * for(每道记录了分数的题){
        *       //遍历题库找到要赋分的题目
        *       boolean isFind = false;
        *      for(题库里的每道题){
        *
        *           if(找到题目编号){
        *               赋分;
        *               isFind = true;
        *
        *           }
        *
        *       }
        *       if(!isFind){
        *       //这个时候的情况是有题号没题干,题库中没有,就是调用出错了
        *       N wrongN = new N("");
        *       Nbank.add(wrongN);
        *       }
        *
        *
        *
        * }
        *
        *
        *
        * */

/* for (int paperIndex = 0;paperIndex<paper.getPerScore().length;paperIndex++) {
for(int NbankIndex = 0; NbankIndex < Nbank.size(); NbankIndex++){

                String[] parts = paper.getPerScore()[paperIndex].split("-");
                //parts[0]是标题,part[1]是分值

                if(parts[0].equals(Nbank.get(NbankIndex).getNname().substring(3))){
                    Nbank.get(NbankIndex).setScore(Integer.parseInt(parts[1]));
                }
            }
        }*/


        //用字符串数组确定有哪些是错误引用的题目
        ArrayList<String> wrongQuote =new ArrayList<>();
        for (int NbankIndex = 0; NbankIndex < Nbank.size(); NbankIndex++) {
            if(Nbank.get(NbankIndex).getScore()!=0&&Nbank.get(NbankIndex).getQstem()==""){
                String wrongNum = Nbank.get(NbankIndex).getNname().substring(3);
                wrongQuote.add(wrongNum);
            }
        }
        //添加移除标签
        for (int removeIndex = 0; removeIndex < removeNum.size(); removeIndex++) {
            for (int NbankIndex = 0; NbankIndex < Nbank.size(); NbankIndex++) {String title = removeNum.get(removeIndex).substring(2);
                if(title.equals(Nbank.get(NbankIndex).getNname().substring(3))){
                   Nbank.get(NbankIndex).setRemove(true);
                }
            }
        }
        //确立试卷
        paper.setNnum(Nbank);


        //先判断试卷的总分是否等于100,没有则警告
        //alert: full score of test paper1 is not 100 points
        if(paper.getTotalScore()!=100){
            System.out.println("alert: full score of test paper"+paper.getNid()+" is not 100 points");
        }


        //接着对学生的作答进行审判
        //需要的数据:学生的各道题目的对错(一题一行),最后一行打印学生的学号和姓名和
        // 得分:每一题的得分(空格隔开)~总分
        //1+1=~5~false
        //20201103 Tom: 0~0
        //以学生数进行遍历

        for (int stuNum = 0; stuNum < stu.size(); stuNum++) {
            if(stu.get(stuNum).getResponse().size()!=0){
                ArrayList<perN> per = stu.get(stuNum).getResponse();
                ArrayList<String> responseSituation = new ArrayList<>();
                int score = 0;
                //当遇到
                for (int perNindex = 0; perNindex < per.size(); perNindex++) {//以学生的作答情况进行遍历
                    //以试卷的题库进行核对

                    //将1-5 分为 1 和 5
                    String[] parts = per.get(perNindex).getRespond().split("-");

                    //parts[0]是题号 part[1]是答案

                    //试卷题号遍历题库
                    boolean isFind = false;
                    for (int paperNnum = 0; paperNnum < paper.getNnum().size(); paperNnum++) {
                        //getNnum 获得的是试卷上的题库
                        isFind = false;
                        String sid = paper.getNnum().get(paperNnum).getNname().substring(3);
                        //这个是消去'#N:'后的题号,可以与parts[0]直接对比
                                //题目的编号存在
                                if(parts[0].equals(sid)){
                                    if(paper.getNnum().get(paperNnum).getAnswer().equals("")){
                                        isFind = true;
                                        System.out.println("non-existent question~0");
                                        responseSituation.add("0");

                                    }
                                    else if (!paper.getNnum().get(paperNnum).isRemove()) {
                                        isFind = true;
                                        System.out.print(paper.getNnum().get(paperNnum).getQstem().substring(3)+"~"+parts[1]+"~");
                                        String answer = paper.getNnum().get(paperNnum).getAnswer().substring(3);
                                        String strScore = "0";

                                        if(parts[1].equals(answer)){
                                            System.out.println(true);
                                            //记录每次的分与总分,每次得分存在responseSituation,总分存在score里
                                            responseSituation.add(paper.getNnum().get(paperNnum).getScore()+"");
                                            score += Integer.parseInt(paper.getPerScore()[paperNnum]);

                                        }
                                        else {
                                            System.out.println(false);
                                        }
                                    }
                                else {
                                    //题目存在但是被删除了
                                        int ifRemoveIndex = Integer.parseInt(parts[0]);
                                        if(ifRemoveIndex<paper.getNnum().size()){
                                            if(paper.getNnum().get(ifRemoveIndex).isRemove()) {
                                                System.out.println("the question "+paper.getNnum().get(ifRemoveIndex).getNname().substring(3)+" invalid~0");
                                            }
                                        }


                                }

                                }
                            else {
                                //换下一个看看
                            }


                    }


                    if(isFind==false){
                        responseSituation.add("0");
                    }

                }

                //成绩打印部分

                stu.get(stuNum).setResponseSituation(responseSituation);
                if(paper.getNnum().size()- wrongQuote.size()>per.size()){
                    System.out.println("answer is null");
                }
                System.out.print(stu.get(stuNum).getSid()+" "+stu.get(stuNum).getSname()+":");
                for (int i1 = 0; i1 < responseSituation.size(); i1++) {
                    System.out.print(" "+responseSituation.get(i1));
                }
                System.out.print("~"+score);
            }
            else {
                continue;
            }
        }

        //          for(每个学生){

// for (int stuNum = 0; stuNum < stu.size(); stuNum++) {
// // for(题库中的每一题){
// ArrayList responseSituation = new ArrayList<>();
// ArrayList per = stu.get(stuNum).getResponse();
// int score =0;
//
// for (int paperNumIndex = 0; paperNumIndex < paper.getNnum().size(); paperNumIndex++) {
//// if(只有题号和分值,没有题干){
// //
// if(paper.getNnum().get(paperNumIndex).getScore()!=0&&paper.getNnum().get(paperNumIndex).getAnswer().equals("")){
// System.out.println("non-existent question~0");
// responseSituation.add("0");
// }
// else{
// if(stu.get(stuNum).getResponse().size()!=0){
//// for(该学生的所有作答)
//
//// if(学生对该题做了答){
// boolean isFind = false;
//
// for (int perNindex = 0; perNindex < per.size(); perNindex++) {
//
// String[] parts = per.get(perNindex).getRespond().split("-");
// String sid = paper.getNnum().get(paperNumIndex).getNname();
//
// if(parts[0].equals(sid)){
// if(!paper.getNnum().get(paperNumIndex).isRemove()){
// isFind = true;
// System.out.print(paper.getNnum().get(paperNumIndex).getQstem().substring(3)+"_"+parts[1]+"");
// String answer = paper.getNnum().get(paperNumIndex).getAnswer().substring(3);
// if(parts[1].equals(answer)){
// System.out.println(true);
// //记录每次的分与总分,每次得分存在responseSituation,总分存在score里
// responseSituation.add(paper.getNnum().get(paperNumIndex).getScore()+"");
// score += Integer.parseInt(paper.getPerScore()[paperNumIndex].split("-")[1]);
// }
// else {
// System.out.println(false);
// }
//
// }
// else {
// int ifRemoveIndex = Integer.parseInt(parts[0]);
// if(ifRemoveIndex<paper.getNnum().size()) {
// if (paper.getNnum().get(ifRemoveIndex).isRemove()) {
// System.out.println("the question " + paper.getNnum().get(ifRemoveIndex).getNname().substring(3) + " invalid~0");
// }
// }
// }
// }
// else {
// //不对题,换下一个
// }
// }
// if(isFind==false){
// responseSituation.add("0");
// }
// stu.get(stuNum).setResponseSituation(responseSituation);
// if(paper.getNnum().size()- wrongQuote.size()>per.size()){
// System.out.println("answer is null");
// }
// System.out.print(stu.get(stuNum).getSid()+" "+stu.get(stuNum).getSname()+"😊;
// for (int responseSituationIndex = 0; responseSituationIndex < responseSituation.size(); responseSituationIndex++) {
// System.out.print(" "+responseSituation.get(responseSituationIndex));
// }
// System.out.print("~"+score);
//
// }
// else {
// //没有作答,换下一个学生
// }
//
// }
//
// }
//
//
//
// }

    }

/*

•   for(学生数量){
  

•     if(学生作答了)
  

•       for(该学生的每道题){
                for(题库){
                    if(题号存在){
                      if(该题目的分值存在但是题干不存在){
                      else if(题目没有被删除){
  
  
  
                   打印non-existent question~0,并计0分,且该判断必须发生在删除题目的提示之前
                        }
                        else{
  
  
  
                          if(答案正确){
                              加对应分值
  
                          }
                          else{
                              加0分
                          }
  
  
                       }
                      else{
                       直接打印the question 2 invalid~0,并计0分
  
  
                      }
  
  
  
  
  
  
  
                         }
  
  
                  }
                  else{
  
  
  
                    }
  

•           }
  

•       }
  

•   }
  

• /
  /

N:1 #Q:1+1= #A:2

N:2 #Q:2+2= #A:4

T:1 1-5 3-8

X:20201103 Tom-20201104 Jack-20201104 Www

S:1 20201103 #A:1-5 #A:2-4

D:N-2

end

alert: full score of test paper1 is not 100 points
1+1=₅false
non-existent question~0
20201103 Tom: 0 0~0

• */

  }
  //建立题目类:#N (单个题目信息)
  class N{
  private String Nname;//题号
  private String Qstem;//题干
  private String Answer;//正确答案
  private int score;//分值
  private boolean isRemove;

  public boolean isRemove() {
  return isRemove;
  }

  public void setRemove(boolean remove) {
  isRemove = remove;
  }

  public int getScore() {
  return score;
  }

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

  public String getNname() {
  return Nname;
  }

  public void setNname(String nname) {
  Nname = nname;
  }

  public String getQstem() {
  return Qstem;
  }

  public void setQstem(String qstem) {
  Qstem = qstem;
  }

  public String getAnswer() {
  return Answer;
  }

  public void setAnswer(String answer) {
  Answer = answer;
  }

  public N() {
  }

  public N(String N) {
  String[] n =N.split(" ");
  if(n.length==3){
  Nname = n[0];
  Qstem = n[1];
  Answer = n[2];
  }
  else {

            Nname = "";
            Qstem = "";
            Answer = "";
        }
  

  }

  public String toString(){
  return Nname+" "+Qstem+" "+Answer+" "+score;
  }
  }
  //建立试卷类:#N[] (整套试卷信息)
  class NN{
  private String Nid;//试卷编号
  private ArrayList Nnum;//试卷全部题目
  private String[] perScore;//试卷的每道题的题号与分值(形式: 1-5 )
  private int totalScore;//试卷总分值

  public String[] getPerScore() {
  return perScore;
  }

  public void setPerScore(String[] perScore) {
  this.perScore = perScore;
  calculateTotal();
  }

  public int getTotalScore() {
  return totalScore;
  }

  public void setTotalScore(int totalScore) {
  this.totalScore = totalScore;
  }

  public String getNid() {
  return Nid;
  }

  public void setNid(String nid) {
  Nid = nid;
  }

  public ArrayList getNnum() {
  return Nnum;
  }

  public void setNnum(ArrayList nnum) {
  Nnum = nnum;
  }

  public NN(String nid, ArrayList nnum) {
  Nid = nid;
  Nnum = nnum;
  }

  public NN() {
  }

  public void calculateTotal(){
  //1-5 2-8
  int ret =0;
  for (int i = 0; i < this.perScore.length; i++) {
  ret += Integer.parseInt(perScore[i].substring(2));
  }
  totalScore = ret;
  }
  }

//建立答卷类:#X (学生的信息)
class X{
private String sname;//学生姓名
private String sid;//学生考号
private ArrayList response;//学生的作答情况
private int score;//学生的总分
private ArrayList responseSituation;

public ArrayList<String> getResponseSituation() {
    return responseSituation;
}

public void setResponseSituation(ArrayList<String> responseSituation) {
    this.responseSituation = responseSituation;
}

////1 20201103 #A:1-5 #A:2-4
public void setResponse(String[] response) {
    String[] strings = new String[response.length-2];
    for (int i = 0; i < strings.length; i++) {
        strings[i] = response[i+2];
        perN pn =new perN(response[i+2].substring(3),false,0);
            this.response.add(pn);
    }
}

public ArrayList<perN> getResponse() {
    return response;
}

public void setResponse(ArrayList<perN> response) {
    this.response = response;
}

public int getScore() {
    return score;
}

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

public X() {
}

public X(String str) {
    //20201103(学号) Tom(姓名)-(分隔符)20201104 Jack-20201104 Www
    String[] s = str.split(" ");
    this.sname = s[1];
    this.sid = s[0];
    ArrayList<perN> p = new ArrayList<>();
    this.setResponse(p);
}

public String getSname() {
    return sname;
}

public void setSname(String sname) {
    this.sname = sname;
}

public String getSid() {
    return sid;
}

public void setSid(String sid) {
    this.sid = sid;
}

}
class perN{
private String respond;
private boolean isRight;
private int score;

public String getRespond() {
    return respond;
}

public void setRespond(String respond) {
    this.respond = respond;
}

public boolean isRight() {
    return isRight;
}

public void setRight(boolean right) {
    isRight = right;
}

public int getScore() {
    return score;
}

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

public perN() {
}

public perN(String respond, boolean isRight, int score) {
    this.respond = respond;
    this.isRight = isRight;
    this.score = score;
}

}
首先，代码开始通过导入必要的类和创建一些变量和数据结构。
然后，在一个do-while循环中，程序接受用户输入的信息，根据不同的信息类型进行不同的处理：
如果输入信息以"#N"开头，表示这是一个题目信息，创建一个N类的对象，并将其添加到题库Nbank中。
如果输入信息以"#T"开头，表示这是试卷信息，解析信息并设置试卷的相关属性。
如果输入信息以"#X"开头，表示这是学生信息，创建学生对象X，并将其添加到学生信息库stu中。
如果输入信息以"#S"开头，表示这是学生的答题情况，根据学生学号将答题情况记录在学生对象中。
如果输入信息以"#D"开头，表示需要删除某些信息，将需要删除的信息编号记录在removeNum中。
接着，程序对试卷中的题目进行处理，为每道题赋分值，并检查是否有未定义的题目，将其记录下来。
然后，程序检查哪些题目是错误引用的，并标记需要移除的题目。
接下来，程序对试卷进行最终确认，检查试卷总分是否为100分，如果不是则输出警告信息。
最后，程序对每位学生的答题情况进行评分和打印：
遍历每位学生的答题情况，与试卷的题库进行核对，计算得分。
输出每位学生的学号、姓名、答题情况和得分。
**
总结:Java习题涉及的范围广泛，涵盖了Java语言的各个方面以及与其他领域的结合数据结构与算法等。通过解决这些习题，我不仅加深了对Java本身的了解，还拓展了自己的知识面。在解决各种Java习题的过程中，我不断锻炼和提升了自己的编程技能，包括逻辑思维能力、代码优化能力、调试技巧等。这些技能对于日后的编程工作和项目实践都将大有裨益。
通过大量练习和实践，我对自己的编程能力有了更大的信心。解决了许多看似困难的问题，让我相信只要努力，就能够克服各种挑战。编写大量Java习题让我积累了丰富的实践经验，这对于将来的项目开发和工作中遇到的问题都将起到积极的促进作用。实践是最好的老师，通过实践才能更好地理解和掌握知识。在编写Java习题的过程中，我不断学习和进步，发现自己的不足之处并努力改进。这种持续的学习和进步态度将成为我在未来发展道路上的宝贵财富。
提议:题目集出的很好,一定要多出