1.前言

一、知识点
关于类
1：类似于C语言的结构体，但比C语言中的结构体作用更多，且适用范围更广
2：懂得封装和公开的区别，即private和public的区别，用private可以防止数据的泄露
3：用类把题目分解，以便更好的解决题目，创立多个类，来分解题目。
4：在Java开发中，类是实现功能的基础。通过定义类，我们可以组织和管理代码，实现各种复杂的功能和逻辑。
5:此外，类还可以作为数据类型使用，用于创建和操作对象。因此，掌握Java中的类及其相关特性，对于编写高质量、可维护的Java代码至关重要。
关于列表
1：ArrayList：基于动态数组实现，查询效率高，但插入和删除操作可能会涉及元素的移动，效率相对较低
2:使用列表能更好的存储题目数据，且能更好的访问其中的元素
3：懂得这些函数的用法add(）remove()......
关于哈希表
1：哈希表通过哈希函数将键（Key）映射到存储桶（Bucket）中，从而实现对数据的快速查找。
2：使用哈希表能简便代码，更好的解题。
3：懂得这些函数put(K key, V value)get(Object key)remove(Object key)....用法
二、作业
第一次作业
难度不大，题量适中
第二次作业
难度不大，题量适中
第二次作业
难度大，题量适中

2.第一次作业的设计与分析

7-5 答题判题程序-1
输入格式:
程序输入信息分三部分：


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、判题信息的顺序与输入答题信息中的顺序相同
   样例：true false true

输入样例1:
单个题目。例如：

1
#N:1 #Q:1+1= #A:2
#A:2
end
输出样例1:
在这里给出相应的输出。例如：

1+1=~2
true
输入样例2:
单个题目。例如：

1
#N:1 #Q:1+1= #A:2
#A:4
end
输出样例2:
在这里给出相应的输出。例如：

1+1=~4
false
输入样例3:
多个题目。例如：

2
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#A:2 #A:4
end
输出样例3:
在这里给出相应的输出。例如：

1+1=~2
2+2=~4
true true
输入样例4:
多个题目。例如：

2
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#A:2 #A:2
end
输出样例4:
在这里给出相应的输出。例如：

1+1=~2
2+2=~2
true false
输入样例5:
多个题目，题号顺序与输入顺序不同。例如：

2
#N:2 #Q:1+1= #A:2
#N:1 #Q:5+5= #A:10
#A:10 #A:2
end
输出样例5:
在这里给出相应的输出。例如：

5+5=~10
1+1=~2
true true
输入样例6:
含多余的空格符。例如：

1
#N:1 #Q: The starting point of the Long March is #A:ruijin
#A:ruijin
end
输出样例6:
在这里给出相应的输出。例如：

The starting point of the Long March is~ruijin
true

输入样例7:
含多余的空格符。例如：

1
#N: 1 #Q: 5 +5= #A:10
#A:10
end
输出样例7:
在这里给出相应的输出。例如：

5 +5=~10
true

题目代码

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.*;
import java.util.ArrayList;  
import java.util.List;  
class Issue
{
    private int num;
    private String s;
    private String std;
    public Issue(int num, String s, String std)
    {
        this.num = num;
        this.s = s;
        this.std = std;
    }
    public int getNum()
    {
        return num;
    }
    public String getS()
    {
        return s;
    }
    public String getStd()
    {
        return std;
    }
    public boolean checkAnswer(String answer)
    {
        return std.equals(answer);
    }
}
public class Main
{
    public static void main(String[] args)
    {
        Scanner input=new Scanner(System.in);
        int sum = input.nextInt();
        input.nextLine();
        Issue a[] = new Issue [sum];
        Pattern pN = Pattern.compile("#N:\\s*(\\d+)");
        Pattern pQ = Pattern.compile("#Q:(.+)#A:");
        Pattern pA = Pattern.compile("#A:(.+)");
        for (int i = 0; i < sum; i++) 
        {  
            String c = input.nextLine();  
            Matcher mN = pN.matcher(c);  
            Matcher mQ = pQ.matcher(c);  
            Matcher mA = pA.matcher(c);  
            if (mN.find()) 
            {  
                int number = Integer.parseInt(mN.group(1));  
                String question = "";  
                String answer = "";  
                if (mQ.find()) 
                {  
                    question = mQ.group(1).trim();  
                }
                if (mA.find())    
                {  
                    answer = mA.group(1).trim();  
                }
                if (number >= 1 && number <= sum) 
                {  
                    a[number - 1] = new Issue(number, question, answer);  
                }
            }
        }
        List<String> texts = new ArrayList<>(); 
        while(true)
        {
            String b = input.nextLine();
            if (b.equalsIgnoreCase("end")) 
            {
                break;
            }
            Pattern pattern = Pattern.compile("#A:([^\\s]+)");
            Matcher matcher = pattern.matcher(b);  
            while (matcher.find()) 
            {  
                String text = matcher.group(1);
                texts.add(text);
            }
        }
        String[] textArray = texts.toArray(new String[0]);
        for(int i=0;i<sum;i++)
        {
            System.out.printf("%s~%s\n",a[i].getS(),textArray[i]);
        }
        for(int i=0;i<sum;i++)
        {
            if(i==sum-1)
            {
                if(a[i].checkAnswer(textArray[i]))
                {
                    System.out.printf("true");
                }
                else
                {
                    System.out.printf("false");
                }
            }
            else
            {
                if(a[i].checkAnswer(textArray[i]))
                {
                    System.out.printf("true ");
                }
                else
                {
                    System.out.printf("false ");
                }
            }
        }
    }
}

设计思路：
我建立了一个类用来存储题目数据,题目编号，试卷编号等，创立一个循环，并用正则表达式来获取题目数据
并用列表来存储题目，然后转成数组用循环进行比较，来判断题目对错，并且输出题目，答案和得分情况
采坑心得：
1：要正确使用正则表达式来获取题目数据，表达式的正确决定了你的获取。
2：合理运用循环，且浅显易懂
改进建议：
多用列表存储，可以不转数组，列表中有很多函数，可以减少循环，简化代码

3.第二次作业的设计与分析

题目2
7-4 答题判题程序-2
分数 73
困难
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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=~5~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。


设计建议：

参考答题判题程序-1，建议增加答题类，类的内容以及类之间的关联自行设计。

输入样例1:
一张试卷一张答卷。试卷满分不等于100。例如：

#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#S:1 #A:5 #A:22
end
输出样例1:
在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
1+1=~5~false
2+2=~22~false
0 0~0
输入样例2:
一张试卷一张答卷。试卷满分不等于100。例如：

#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-70 2-30
#S:1 #A:5 #A:22
end
输出样例2:
在这里给出相应的输出。例如：

1+1=~5~false
2+2=~22~false
0 0~0
输入样例3:
一张试卷、一张答卷。各类信息混合输入。例如：

#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-70 2-30
#N:3 #Q:3+2= #A:5
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：

1+1=~5~false
2+2=~4~true
0 30~30
输入样例4:
试卷题目的顺序与题号不一致。例如：

#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 2-70 1-30
#N:3 #Q:3+2= #A:5
#S:1 #A:5 #A:22
end
输出样例:
在这里给出相应的输出。例如：

2+2=~5~false
1+1=~22~false
0 0~0
输入样例5:
乱序输入。例如：

#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-70 2-30
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
end
输出样例:
在这里给出相应的输出。例如：

3+2=~5~true
2+2=~22~false
70 0~70
输入样例6:
乱序输入+两份答卷。例如：

#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-70 2-30
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：

3+2=~5~true
2+2=~22~false
70 0~70
3+2=~5~true
2+2=~4~true
70 30~100
输入样例7:
乱序输入+分值不足100+两份答卷。例如：

#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-7 2-6
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
3+2=~5~true
2+2=~22~false
7 0~7
3+2=~5~true
2+2=~4~true
7 6~13
输入样例8:
乱序输入+分值不足100+两份答卷+答卷缺失部分答案。例如：

#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-7 2-6
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
#T:2 2-5 1-3 3-2
#S:2 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
3+2=~5~true
2+2=~22~false
7 0~7
2+2=~5~false
1+1=~4~false
answer is null
0 0 0~0
输入样例9:
乱序输入+分值不足100+两份答卷+无效的试卷号。例如：

#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-7 2-6
#S:3 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
The test paper number does not exist

题目代码

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
class Issue
{
    public String number;
    public String question;
    public String answer;
    public Issue(String number, String question, String answer)
    {
        this.number = number;
        this.question = question;
        this.answer = answer;
    }
}
class Issue1
{
    public String score;
    public String question;
    public String answer;
    public Issue1(String score, String question, String answer)
    {
        this.score = score;
        this.question = question;
        this.answer = answer;
    }
}
class Question
{
    String number;//题目序号
    String score;//题目分值
    public Question(String number, String score)
    {
        this.number = number;
        this.score = score;
    }
}
class ExamPaper
{
    public String examNumber;
    public List<Question> questions;
    public ExamPaper(String examNumber)
    {
        this.examNumber = examNumber;
        this.questions = new ArrayList<>();
    }
    public void addQuestion(Question question)
    {
        questions.add(question);
    }
}
class Paper
{
    public String Papernumber;
    public List<String> answers;
    public Paper(String Papernumber)
    {
        this.Papernumber = Papernumber;
        this.answers = new ArrayList<>();
    }
    public void addAnswer(String answer)
    {
        answers.add(answer);
    }
}
public class Main
{
    public static void main(String[] args)
    {
        List<Issue> Issues = new ArrayList<>();
        List<ExamPaper> ExamPapers = new ArrayList<>();
        List<Paper> Papers = new ArrayList<>();
        Scanner input = new Scanner(System.in);
        while (true)
        {
            String line = input.nextLine();
            if (line.equalsIgnoreCase("end"))
            {
                break;
            }
            if (line.charAt(1) == 'N')
            {
                Pattern pattern = Pattern.compile("#(N|Q|A):(\\S+)");
                Matcher matcher = pattern.matcher(line);
                Issue issue = null;
                while (matcher.find())
                {
                    String tag = matcher.group(1);
                    String value = matcher.group(2);
                    switch (tag)
                    {
                        case "N":
                            if (issue != null)
                            {
                                Issues.add(issue);
                            }
                            issue = new Issue(value, null, null);
                            break;
                        case "Q":
                            if (issue != null)
                            {
                                issue.question = value;
                            }
                            break;
                        case "A":
                            if (issue != null)
                            {
                                issue.answer = value;
                                Issues.add(issue);
                                issue = null;
                            }
                            break;
                    }
                }
            }
            if (line.charAt(1) == 'T')
            {
                Question a = null;
                ExamPaper a1 = null;
                Pattern p1 = Pattern.compile("#T:(\\d+)");
                Matcher m1 = p1.matcher(line);
                if (m1.find())
                {
                    a1 = new ExamPaper(m1.group(1));
                }
                line = line.replaceFirst("#T:\\d+\\s+", "");
                Pattern p2 = Pattern.compile("(\\d+)-(\\d+)");
                Matcher m2 = p2.matcher(line);
                while (m2.find())
                {
                    a = new Question(m2.group(1), m2.group(2));
                    a1.addQuestion(a);
                    a = null;
                }
                ExamPapers.add(a1);
                a1 = null;
            }
            if (line.charAt(1) == 'S')
            {
                Paper a = null;
                Pattern p1 = Pattern.compile("#S:(\\d+)");
                Matcher m1 = p1.matcher(line);
                if (m1.find())
                {
                    a = new Paper(m1.group(1));
                }
                line = line.replaceFirst("#S:\\d+\\s+", "");
                Pattern p2 = Pattern.compile("#A:(\\S+)");
                Matcher m2 = p2.matcher(line);
                while (m2.find())
                {
                    a.addAnswer(m2.group(1));
                }
                Papers.add(a);
                a = null;
            }
        }
        Issue [] IssuesArray = Issues.toArray(new Issue [0]);//题目
        ExamPaper [] ExamPapersArray = ExamPapers.toArray(new ExamPaper[0]);//试卷
        Paper [] PapersArray = Papers.toArray(new Paper [0]);//答卷
        for(int i = 0 ;i<ExamPapersArray.length; i++)//输出试卷总分是否为100
        {
            Question [] a = ExamPapersArray[i].questions.toArray(new Question[0]);
            int sum=0;
            for(int j =0 ;j<a.length;j++)
            {
                int number = Integer.parseInt(a[j].score);
                sum = number + sum;
            }
            if(sum!=100)
            {
                System.out.println("alert: full score of test paper"+ExamPapersArray[i].examNumber+" is not 100 points");
            }
        }
        for(int s=0;s<PapersArray.length;s++)
        {
            int i=0,m=0;
            if(PapersArray[s].answers!= null && PapersArray[s].answers.size() != 0)
            {
                for( i = 0 ;i<ExamPapersArray.length; i++)
                {
                    if(PapersArray[s].Papernumber.equals(ExamPapersArray[i].examNumber))
                    {
                        Question [] a = ExamPapersArray[i].questions.toArray(new Question[0]);//题目序号和分值
                        Issue1 [] b = new Issue1[a.length];
                        for(int j=0;j<a.length;j++)//排序
                        {
                            for (int q = 0; q < IssuesArray.length; q++)
                            {
                                if (a[j].number.equals(IssuesArray[q].number))
                                {
                                    b[j] = new Issue1(a[j].score,IssuesArray[q].question,IssuesArray[q].answer);
                                    break;
                                }
                            }
                        }
                        String [] c= PapersArray[s].answers.toArray(new String[0]);//题目答案
                        for(int l=0;l< c.length;l++)//打印题目
                        {

                            if(c[l].equals(b[l].answer))
                            {
                                System.out.println(b[l].question+"~"+c[l]+"~"+"true");
                            }
                            else
                            {
                                System.out.println(b[l].question+"~"+c[l]+"~"+"false");
                            }
                        }
                        for(int t=0;t<(b.length-c.length);t++)
                        {
                            System.out.println("answer is null");
                        }
                        int sum=0;
                        for(int l=0;l<b.length;l++)//打印得分情况
                        {
                            int number = Integer.parseInt(b[l].score);
                            if(l<=c.length-1)
                            {
                                if(c[l].equals(b[l].answer))
                                {
                                    sum = number + sum;
                                    System.out.print(b[l].score);
                                }
                                else
                                {
                                    sum = sum+0;
                                    System.out.print("0");
                                }
                            }
                            else
                            {
                                System.out.print("0");
                            }
                            if(l!=b.length-1)
                            {
                                System.out.print(" ");
                            }
                        }
                        System.out.println("~"+sum);
                    }
                    else
                    {
                        m++;
                    }
                }
            }
            else
            {

                Question [] b = ExamPapersArray[i].questions.toArray(new Question[0]);//题目序号和分值
                for(int t=0;t<b.length;t++)
                {
                    System.out.println("answer is null");
                }
                int sum=0;
                for(int l=0;l<b.length;l++)//打印得分情况
                {
                    System.out.print("0");
                    if(l!=b.length-1)
                    {
                        System.out.print(" ");
                    }
                    else
                    {
                        System.out.println("~0");
                    }
                }
            }
            if(m==(ExamPapersArray.length))
            {
                System.out.println("The test paper number does not exist");
            }
        }
    }
}

设计与分析：
我创立了三个类，用来存储题目，答卷，试卷，且用列表来存储数据。
答卷类中有个列表，用来存储答案，用来保证答卷号和答案对应
试卷类中也创立了个列表，用来存储题目和题目分值
使用一个循环，来获取每一行的数据，用if语句来判断这个数据是试卷，答卷或题目
然后用正则表达式获取数据并存到列表中，然后列表转数组，用循环比较每个题目是否正确，并输出最后的得分情况
踩坑心得：
有两个得分点一直过不去，可能是正则表达式的问题
或者是循环嵌套的问题，应多测试正则表达式的正确性
改进建议：
使用哈希表，能减少循环的嵌套，且哈希表能迅速获取题目数据。

4.第三次作业的设计与分析

题目三
输入格式:

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

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=~5~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=~5~true
     4+6=~22~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。


本题暂不考虑出现多张答卷的信息的情况。


输入样例1:
简单输入，不含删除题目信息。例如：

#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201103 Tom
#S:1 20201103 #A:1-5
end
输出样例1:
在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
1+1=~5~false
20201103 Tom: 0~0
输入样例2:
简单输入，答卷中含多余题目信息（忽略不计）。例如：

#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201103 Tom
#S:1 20201103 #A:1-2 #A:2-3
end
输出样例3
简单测试，含删除题目信息。例如：

alert: full score of test paper1 is not 100 points
1+1=~2~true
20201103 Tom: 5~5
输入样例3:
简单测试，含删除题目信息。例如：

#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-20201105 Www
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出样例3:
在这里给出相应的输出，第二题由于被删除，输出题目失效提示。例如：

alert: full score of test paper1 is not 100 points
1+1=~5~false
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例4:
简单测试，含试卷无效题目的引用信息以及删除题目信息（由于题目本身无效，忽略）。例如：

#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-20201105 Www
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出样例4:
输出不存在的题目提示信息。例如：

alert: full score of test paper1 is not 100 points
1+1=~5~false
non-existent question~0
20201103 Tom: 0 0~0
输入样例5:
综合测试，含错误格式输入、有效删除以及无效题目引用信息。例如：

#N:1 +1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出样例5:
在这里给出相应的输出。例如：

wrong format:#N:1 +1= #A:2
alert: full score of test paper1 is not 100 points
non-existent question~0
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例6:
综合测试，含错误格式输入、有效删除、无效题目引用信息以及答案没有输入的情况。例如：

#N:1 +1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-5
#D:N-2
end
输出样例6:
答案没有输入的优先级最高。例如：

wrong format:#N:1 +1= #A:2
alert: full score of test paper1 is not 100 points
non-existent question~0
answer is null
20201103 Tom: 0 0~0
输入样例7:
综合测试，正常输入，含删除信息。例如：

#N:2 #Q:2+2= #A:4
#N:1 #Q:1+1= #A:2
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:2-4 #A:1-5
#D:N-2
end
输出样例7:
例如：

alert: full score of test paper1 is not 100 points
1+1=~5~false
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例8:
综合测试，无效的试卷引用。例如：

#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201103 Tom
#S:2 20201103 #A:1-5 #A:2-4
end
输出样例8:
例如：

alert: full score of test paper1 is not 100 points
The test paper number does not exist
输入样例9:
无效的学号引用。例如：

#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201106 Tom
#S:1 20201103 #A:1-5 #A:2-4
end
输出样例9:
答案照常输出，判分时提示错误。例如：

alert: full score of test paper1 is not 100 points
1+1=~5~false
20201103 not found

输入样例10:
信息可打乱顺序输入：序号不是按大小排列，各类信息交错输入。但本题不考虑引用的题目在被引用的信息之后出现的情况（如试卷引用的所有题目应该在试卷信息之前输入），所有引用的数据应该在被引用的信息之前给出。例如：

#N:3 #Q:中国第一颗原子弹的爆炸时间 #A:1964.10.16
#N:1 #Q:1+1= #A:2
#X:20201103 Tom-20201104 Jack-20201105 Www
#T:1 1-5 3-8
#N:2 #Q:2+2= #A:4
#S:1 20201103 #A:1-5 #A:2-4
end
输出样例10:
答案按试卷中的题目顺序输出。例如：

alert: full score of test paper1 is not 100 points
1+1=~5~false
中国第一颗原子弹的爆炸时间~4~false
20201103 Tom: 0 0~0

题目代码

import javax.swing.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.Collections;
import java.util.Comparator;
class Issue//题目类
{
    public int number;
    public String question;
    public String answer;//标准答案
    public Issue(int number, String question, String answer)
    {
        this.number = number;
        this.question = question;
        this.answer = answer;
    }

    public Issue()
    {
    }
    public Boolean check(String answer)
    {
        if(this.answer.equals(answer))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    public String toString(String answer)
    {
        if(this.answer.equals(answer))
        {
            if(answer.equals("null"))
            {
                return this.question+"~"+""+"~true";
            }
            else
            {
                return this.question+"~"+answer+"~true";
            }

        }
        else
        {
            if(answer.equals("null"))
            {
                return this.question+"~"+""+"~true";
            }
            else
            {
                return this.question+"~"+answer+"~false";
            }

        }
    }
}
class Question
{
    int number;//题目序号
    int score;//题目分值
    public Question(int number, int score)
    {
        this.number = number;
        this.score = score;
    }
}
class ExamPaper//试卷类
{
    public int examnumber;//试卷号
    public List<Question> questions;
    public ExamPaper(int examnumber)
    {
        this.examnumber = examnumber;
        this.questions = new ArrayList<>();
    }
    public void addQuestion(Question question)
    {
        questions.add(question);
    }
    public String toString()
    {
        int sum=0;
        for (Question question:this.questions)
        {
            sum=sum+question.score;
        }
        if(sum!=100)
        {
            return "alert: full score of test paper"+this.examnumber+" is not 100 points";
        }
        else
        {
            return " ";
        }
    }
}
class AnswerPaper//答卷类
{
    public int papernumber;
    public String num;//学号
    public HashMap<Integer,String> answers;//试卷序号和题目答案
    public AnswerPaper(int papernumber,String num)
    {
        this.papernumber = papernumber;
        this.num=num;
        this.answers = new HashMap<Integer,String>();
    }
    public void addAnswer(int number,String answer)
    {
        answers.put(number,answer);
    }
}
class Student
{
    public String num;//学号
    public String name;//姓名
    public Student(String num,String name)
    {
        this.num=num;
        this.name=name;
    }
}
public class Main
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        HashMap<Integer,Issue> Issues= new HashMap<Integer, Issue>();//题目类哈希表
        HashMap<Integer,ExamPaper> ExamPapers= new HashMap<Integer, ExamPaper>();//试卷类哈希表
        List<AnswerPaper> AnswerPapers = new ArrayList<>();//答卷类列表
        HashMap<String,Student> Students= new HashMap<String,Student>();//学生类哈希表
        List<Integer> del = new ArrayList<>();//删除题目列表
        List<String> wrong = new ArrayList<>();//错误格式列表
        while (true)
        {
            String line = input.nextLine();
            if (line.equalsIgnoreCase("end"))
            {
                break;
            }
            if (line.startsWith("#N:"))//存储题目类
            {
                Pattern pattern = Pattern.compile("#N:(\\d+) #Q:(.+) #A:");
                Pattern pattern1 = Pattern.compile("#A:(.+)");
                Matcher matcher = pattern.matcher(line);
                Matcher matcher1 = pattern1.matcher(line);
                Issue issue = new Issue();;
                if(matcher.find())
                {
                    issue.number = Integer.parseInt(matcher.group(1));
                    issue.question = matcher.group(2);
                    if(matcher1.find())
                    {
                        issue.answer = matcher1.group(1);
                    }
                    else
                    {
                        issue.answer="null";
                    }
                    Issues.put(issue.number,issue);
                    issue = null;
                }
                else
                {
                    wrong.add("wrong format:"+line);
                }

            }
            else if (line.startsWith("#T:"))//试卷类
            {
                Question a = null;
                ExamPaper a1 = null;
                Pattern p = Pattern.compile("#T:(\\d) (\\d+)-");//试卷编号
                Matcher m = p.matcher(line);
                if(m.find())
                {
                    Pattern p1 = Pattern.compile("#T:(\\d+)");//试卷编号
                    Matcher m1 = p1.matcher(line);
                    if (m1.find())
                    {
                        a1 = new ExamPaper(Integer.parseInt(m1.group(1)));
                        line = line.replaceFirst("#T:\\d+\\s+", "");
                        Pattern p2 = Pattern.compile("(\\d+)-(\\d+)");//获取题目序号和分值
                        Matcher m2 = p2.matcher(line);
                        while (m2.find())
                        {
                            a = new Question(Integer.parseInt(m2.group(1)), Integer.parseInt(m2.group(2)));
                            a1.addQuestion(a);
                            a = null;
                        }
                        ExamPapers.put(a1.examnumber,a1);
                        a1 = null;
                    }
                }
                else
                {
                    wrong.add("wrong format:"+line);
                }

            }
            else if (line.startsWith("#S:"))//获取答卷信息
            {
                AnswerPaper a = null;
                Pattern p1 = Pattern.compile("#S:(\\d+)\\s(\\S+)");
                Matcher m1 = p1.matcher(line);
                if (m1.find())
                {
                    a = new AnswerPaper(Integer.parseInt(m1.group(1)),m1.group(2));
                    line = line.replaceFirst("#S:\\d+\\s\\S+\\s+", "");
                    Pattern p2 = Pattern.compile("#A:(\\S+)");
                    Pattern p3 = Pattern.compile("#A:(\\S+)-(\\S+)");
                    Matcher m2 = p2.matcher(line);
                    Matcher m3 = p3.matcher(line);
                    while (m2.find())
                    {
                        if(m3.find())
                        {
                            a.addAnswer(Integer.parseInt(m3.group(1)), m3.group(2));//存入试卷题目序号和题目答案
                        }
                        else
                        {
                            a.addAnswer(Integer.parseInt(m2.group(1)), "null");//存入试卷题目序号和题目答案
                        }
                    }
                }
                else
                {
                    wrong.add("wrong format:"+line);
                }
                AnswerPapers.add(a);
                a = null;
            }
            else if(line.startsWith("#X:"))
            {
                Student a = null;
                line = line.replaceFirst("#X:", "");
                Pattern p1 = Pattern.compile("(\\d+)\\s(\\w+)");
                Matcher m1 = p1.matcher(line);
                while(m1.find())
                {
                    a = new Student(m1.group(1),m1.group(2));
                    Students.put(a.num,a);
                    a = null;
                }
            }
            else if(line.startsWith("#D:"))
            {
                Pattern p1 = Pattern.compile("N-(\\d+)");
                Matcher m1 = p1.matcher(line);
                while(m1.find())
                {
                    del.add(Integer.parseInt(m1.group(1)));
                }
            }
            else
            {
                if(line != null&&!line.isEmpty())
                {
                    wrong.add("wrong format:"+line);
                }
            }
        }
        for(String a : wrong)
        {
            System.out.println(a);
        }
        for (Map.Entry<Integer,ExamPaper> entry : ExamPapers.entrySet())//打印是否试卷有100分
        {
            if(!entry.getValue().toString().equals(" "))
            {
                System.out.println(entry.getValue().toString());
            }
        }
        for (AnswerPaper answerpaper : AnswerPapers)//答卷列表
        {
            int sum=0;
            StringBuilder sb = new StringBuilder();
            if(ExamPapers.containsKey(answerpaper.papernumber))//找到匹配的试卷
            {
                int t=1;//用t来表示试卷中题目顺序
                for(Question question : ExamPapers.get(answerpaper.papernumber).questions)//试卷中题目顺序
                {
                    if(answerpaper.answers.containsKey(t))//这个题目是否在答卷中存在
                    {
                        if(Issues.containsKey(question.number))//是否引用错误题号
                        {
                            if(del.contains(question.number))//是否题号被删除
                            {
                                sb.append("0 ");
                                System.out.println("the question "+ question.number+" invalid~0");
                            }
                            else
                            {
                                if(Issues.get(question.number).check(answerpaper.answers.get(t)))
                                {
                                    sum=sum+question.score;
                                    sb.append(question.score+" ");
                                }
                                else
                                {
                                    sb.append("0 ");
                                }
                                System.out.println(Issues.get(question.number).toString(answerpaper.answers.get(t)));
                            }
                        }
                        else
                        {
                            sb.append("0 ");
                            System.out.println("non-existent question~0");
                        }
                    }
                    else//这个题目答案为空
                    {
                        sb.append("0 ");
                        System.out.println("answer is null");
                    }
                    t++;//指向下一题
                }
                if(Students.containsKey(answerpaper.num))//判断是否存在这个学号
                {
                    String sb1=sb.toString().trim();
                    System.out.println(answerpaper.num+" "+Students.get(answerpaper.num).name+": "+sb1+"~"+sum);
                }
                else
                {
                    System.out.println(answerpaper.num+" not found");
                }
            }
            else//没找到这个答卷
            {
                System.out.println("The test paper number does not exist");
            }
        }
    }
}

设计与分析：
我设计了四个类，用来存储题目，答卷，试卷，
试卷类中创立了一课用来存储类的哈希表，这个类中包含题目序号和题目分值，这就是第四个类的作用
答卷类中也创立了一个哈希表用来存储题目序号和题目答案
我用创立了三个哈希表用来存储题目，答卷，试卷。
哈希表的键值，表示题目序号，答卷号，试卷号这样可以更快的匹配答卷和试卷，也能快速的获取题目
使用一个循环，来获取每一行的数据，用if语句来判断这个数据是试卷，答卷或题目
然后用正则表达式获取数据并存到哈希表中，使用哈希表中自带的函数，来判断题目的正确
最后输出得分情况
踩坑心得：
没有考虑答案为空的情况，和题目的乱序输出
改进建议：
使用继承来减少类的数量，多使用哈希表

5.总结

本阶段三次题目集综合性总结

在本阶段的三次题目集完成过程中，我深入学习了Java类的定义与使用、Java列表（List）的基本操作、Java哈希表（HashMap）的数据结构以及Java正则表达式的应用。通过实践，我对这些知识点有了更为深刻的理解。

学到的内容

Java类：我学会了如何定义Java类，包括类的属性、构造方法、成员方法等的编写。通过创建对象，我能够调用类中的方法来执行特定的任务。此外，我还学习了类的继承、封装和多态等面向对象编程的基本概念。

Java列表：我掌握了Java中List接口及其实现类（如ArrayList、LinkedList）的使用。我学会了如何添加、删除、查找和遍历列表中的元素，以及如何使用迭代器对列表进行迭代操作。

Java哈希表：通过本阶段的学习，我了解了HashMap的工作原理，包括其存储键值对的方式以及哈希函数的应用。我能够使用HashMap来存储和检索数据，提高了数据处理的效率。

Java正则表达式：我学习了正则表达式的语法和Java中Pattern和Matcher类的使用。通过正则表达式，我能够匹配、查找和替换字符串中的特定模式，为文本处理提供了强大的工具。

需要进一步学习及研究的地方

Java集合框架：虽然我已经学习了List和HashMap，但Java集合框架还包括其他许多有用的接口和类，如Set、Queue等。我计划进一步学习这些集合类的使用场景和特性。

Java泛型：泛型是Java提供的一种类型安全的数据结构，能够避免类型转换时的ClassCastException。我将继续深入学习泛型在Java集合框架中的应用。

Java I/O流：本阶段并未涉及Java的输入输出流操作，这是Java编程中非常重要的一部分。我计划学习如何使用Java的I/O流进行文件读写和网络通信。

对教师、课程、作业、实验等方面的建议

教师：教师在授课过程中能够结合实例进行讲解，多回答学生的问题。

课程：课程内容安排合理，难度适中。建议课程能够增加一些前沿技术的介绍，让学生了解Java在当今技术发展中的最新应用。

作业与实验：作业和实验的设计能够很好地检验学生对知识点的掌握情况。建议增加一些具有挑战性的题目，激发学生的探索欲望和解决问题的能力。

课上及课下组织方式：课上互动氛围良好，学生能够积极参与讨论。建议课下能够提供一些学习资源和辅导材料，方便学生进行自主学习和巩固知识。

总的来说，本阶段的学习让我对Java编程有了更深入的了解，也为我后续的学习打下了坚实的基础。我将继续努力，不断提升自己的编程能力。