blog1

1前言

1.1知识点总结

（1）在题目集1里分别有类与对象的使用（包括方法的定义（void方法，int类型返回等等）与属性的定义（例如整形，布尔型的定义等等），如何对类与对象进行引用（使用new创建一个新类，并进行有参构造或无参构造对类里的属性进行赋值））
（2）类与类之间的引用，包括方法之间的互相调用（包括一个类里的方法之间的互相调用和两个类中方法的互相调用）
（3）类之间的关系（关联，依赖，聚合，组合的体现）
（4）正则表达式的使用（例如匹配字符数字字母，反向引用，以及一些基础语法（[]，{}，+，*，\的作用等等）），Pattern和Matcher的方法使用。
（5）一些泛型的使用（如ArrayList,LinkedList,HashMap等等），而在其中用的最多的又有(用new创建一个泛型，并使用add，remove，sort，get等方法)，还有Comparable接口等。

1.2题量总结
（1）对于我来说，题目数还算可以，而题目集一的小题目的代码行数在50-70行之间，最后一题代码为100行。
（2）题目集二的小题目代码在80-100行之间，最后一道题目的代码行数为280行
（3）题目集三的第一题为70行，而第二题（日期类的使用）为250行，最后一道题目为520行.

1.3难度总结
（1）题目集一的难度不算难，只是关于熟悉类的基本操作。
（2）题目集二的难度中等，进行更深层次的类操作。
（3）题目集三的难度在题目集二的基础上增加一点，第二题的日期使用逻辑关系比较复杂，需要考虑多种情况，第三题则考率的情况更多，需要更为清晰的逻辑。

2.设计与分析
2.1题目集1最后一题

设计思路：将一整行题目信息存入到每个题目类中，并在将答卷内容存在答卷类中，并在答卷类中判断每道题目的正确性，最后输出全部
答卷类需要引用题目类
`
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class SubjectContent{
private String inputContent;
private String subjectNumber;
private String subjectContent;
private String subjectInAnswer;
public void getInputContent(String str){
this.inputContent=str;
}
public void setSubject(){
Pattern pattern1=Pattern.compile("(?<=#N:\s)\d+"); //使用正则表达式将题号，题目内容，标准答案存入到类中
Matcher matcher1=pattern1.matcher(this.inputContent);
if(matcher1.find()){
this.subjectNumber=matcher1.group();
// System.out.println(subjectNumber);
}
Pattern pattern2=Pattern.compile("(?<=#Q:\s).(?=\s#A)");
Matcher matcher2=pattern2.matcher(this.inputContent);
if(matcher2.find()){
this.subjectContent=matcher2.group();
}
Pattern pattern3=Pattern.compile("(?<=#A:).*");
Matcher matcher3=pattern3.matcher(this.inputContent);
if(matcher3.find()){
this.subjectInAnswer=matcher3.group();
}
}
public String getSubjectNumber(){ //获取题号
return this.subjectNumber;
}
public String getSubjectContent(){ //获取内容
return this.subjectContent;
}
public String getSubjectInAnswer(){ //获取标准答案
return this.subjectInAnswer;
}
}
class SubjectAnswer{
private String[] correctAnswer=new String[100];
public void getAnswer(String str){ //将输入答案存到该类中的字符串数组中
int i=0;
Pattern pattern=Pattern.compile("(?<=#A:)\w+");
Matcher matcher=pattern.matcher(str);
while(matcher.find()){
this.correctAnswer[i]=matcher.group();
i++;
}
}
public String getCorrectAnswer(int i){ //获取某题号的输入答案
return this.correctAnswer[i];
}
public String checkAnswer(SubjectContent sub){
if(sub.getSubjectInAnswer().equals(this.correctAnswer[Integer.parseInt(sub.getSubjectNumber())-1])) //将输入答案与标准答案进行对比，如果相等，则返回true，反之则返回false。
return "true";
else
return "false";
}
}
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
SubjectContent[] subject=new SubjectContent[100];
String[] content=new String[100];
String str;
int i,j,k=0,subjectNumber=in.nextInt();
in.nextLine();
while(!"end".equals(str=in.nextLine())){
content[k]=str;
k++;
}
SubjectAnswer answer=new SubjectAnswer();
answer.getAnswer(content[k-1]);
for(i=0;i<k-1;i++){ //将从题目中获取的信息存入
subject[i]=new SubjectContent();
subject[i].getInputContent(content[i]);
subject[i].setSubject();
}
for(i=0;i<k-1;i++){//输出每道题目的内容与答卷答案
for(j=0;j<k-1;j++){ //进行题号匹配
if(Integer.parseInt(subject[j].getSubjectNumber())=i+1){
System.out.println(subject[j].getSubjectContent().trim()+"~"+answer.getCorrectAnswer(i).trim());
}
}
}
for(i=0;i<subjectNumber;i++){输出每道题目的结果
for(j=0;j<k-1;j++){
if(Integer.parseInt(subject[j].getSubjectNumber())=i+1){
if(i!=subjectNumber-1)
System.out.print(answer.checkAnswer(subject[j]).trim()+" ");
else
System.out.print(answer.checkAnswer(subject[j]).trim());
}
}
}
}
}

2.2题目集2最后一题

设计思路：先将每行信息存入到一个字符串数组中通过遍历该字符串数组来分别将题目信息，试卷信息，答卷信息存入到各个类中。
先判断答卷号是否能从试卷号中找到，能的话则正常判断，否则输出The test paper number does not exist。
再根据答卷里是否有试卷信息中相同的作答题号信息，有的话则正常判断是否正确，否则输出Answer is null。
判断答题是否正确详情请看题目集1最后一题。
`
import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.LinkedList;
import java.util.ArrayList;
class Question{
private String allquestion;
private int questionNum;
private String content;
private int modelAnswer;
public Question(String all){
this.allquestion=all;
}
public void setAll(){
Pattern pattern1=Pattern.compile("(?<=#N:)\d+(?=\s+#)");
Matcher matcher1=pattern1.matcher(this.allquestion);
if(matcher1.find()){
this.questionNum=Integer.parseInt(matcher1.group());
}
Pattern pattern2=Pattern.compile("(?<=#Q:).(?=\s+#A)");
Matcher matcher2=pattern2.matcher(this.allquestion);
if(matcher2.find()){
this.content=matcher2.group();
}
Pattern pattern3=Pattern.compile("(?<=#A:)\d+(?=\s)");
Matcher matcher3=pattern3.matcher(this.allquestion);
if(matcher3.find()){
this.modelAnswer=Integer.parseInt(matcher3.group());
}
}
public int getQuestionNum(){
return this.questionNum;
}
public String getContent(){
return this.content;
}
public int getModelAnswer(){
return this.modelAnswer;
}
}
class Paper{
public LinkedList questionList=new LinkedList<>();
private String allPaper;//存放每个问题
private int paperNum;
public ArrayList numList=new ArrayList<>();//存放题号
public ArrayList scoreList=new ArrayList<>();//存放分数
public Paper(String all){
this.allPaper=all;
}
public Paper(){

}
public void setAll(){//使用正则表达式存储每个信息
    Pattern pattern1=Pattern.compile("(?<=#T:)\\d+(?=\\s+)");
    Matcher matcher1=pattern1.matcher(this.allPaper);
    if(matcher1.find()){
        this.paperNum=Integer.parseInt(matcher1.group());
    }
    Pattern pattern2=Pattern.compile("(?<=\\s)\\d+(?=\\-)");
    Matcher matcher2=pattern2.matcher(this.allPaper);
    while(matcher2.find()){
        this.numList.add(Integer.parseInt(matcher2.group()));
    }
    Pattern pattern3=Pattern.compile("(?<=\\-)\\d+");
    Matcher matcher3=pattern3.matcher(this.allPaper);
    while(matcher3.find()){
        this.scoreList.add(Integer.parseInt(matcher3.group()));
    }
}
public int getPaperNum(){
    return this.paperNum;
}
public int getQusetionNum(int i){
    return this.numList.get(i);
}
public int getScore(int i){
    return this.scoreList.get(i);
}
public void setQuestion(Question question){
    this.questionList.add(question);
}

}
class inputAnswer{
private String allinput;
public ArrayList inputList=new ArrayList<>();
private int inPaperNum;
public inputAnswer(String all){
this.allinput=all;
}
public void setInput(){
Pattern pattern1=Pattern.compile("(?<=#S:)\d+");
Matcher matcher1=pattern1.matcher(this.allinput);
if(matcher1.find()){
this.inPaperNum=Integer.parseInt(matcher1.group());
}
Pattern pattern2=Pattern.compile("(?<=#A:)\d+");
Matcher matcher2=pattern2.matcher(this.allinput);
while(matcher2.find()){
this.inputList.add(Integer.parseInt(matcher2.group()));
}
}
public int getInPaperNum(){
return this.inPaperNum;
}
public int getInputAnswer(int i){
return this.inputList.get(i);
}
}
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
ArrayList str=new ArrayList<>();
LinkedList paper0=new LinkedList<>();
LinkedList inAnswer0=new LinkedList<>();
int i=0,j=0,k=0,m=0,score=0,n=0,l=0,p=0,c=0;
boolean check;
while(true){
String str1=in.nextLine();
if(str1.equals("end")){
break;
}else{
str.add(str1);
}
}
in.close();
for(i=0;i<str.size();i++){//判断有几张答卷
if(str.get(i).startsWith("#S")){
p++;
}
}
for(i=0;i<str.size();i++){//判断有几张试卷
if(str.get(i).startsWith("#T")){
n++;
}
}
if(n==1&&p>1){//判断是否有一张试卷两张答卷的情况，并将试卷类存到一个ArrayList里
for(i=0;i<str.size();i++){
if(str.get(i).startsWith("#T")){
Paper paper=new Paper(str.get(i));
paper.setAll();
Paper paper11=new Paper(str.get(i));
paper11.setAll();
paper0.add(paper);
paper0.add(paper11);
}
}
}else{
for(i=0;i<str.size();i++){
if(str.get(i).startsWith("#T")){
Paper paper=new Paper(str.get(i));
paper.setAll();
paper0.add(paper);
}
}
}

for(m=0;m<p;m++){//将Question存到一个ArrayList里
for(j=0;j<paper0.get(m).numList.size();j++){
for(i=0;i<str.size();i++){
if(str.get(i).startsWith("#N")){
Question question=new Question(str.get(i));
question.setAll();
if(question.getQuestionNum()paper0.get(m).numList.get(j)){
paper0.get(m).setQuestion(question);
break;
}}
}
}
}
if(n1){
for(i=0;i<str.size();i++){
if(str.get(i).startsWith("#S")){
inputAnswer inAnswer=new inputAnswer(str.get(i));
inAnswer.setInput();
if(inAnswer.getInPaperNum()==paper0.get(l).getPaperNum()){
inAnswer0.add(inAnswer);
}
}
}
}
if(n>1){
for(i=0;i<str.size();i++){
if(str.get(i).startsWith("#S")){
inputAnswer inAnswer=new inputAnswer(str.get(i));
inAnswer.setInput();

        inAnswer0.add(inAnswer);
        l++;
        
    }
}

}
if(inAnswer0.size()==0){//正常输出有关分数的内容
for(m=0;m<n;m++){
score=0;
for(i=0;i<paper0.get(m).numList.size();i++){
score=score+paper0.get(m).scoreList.get(i);
}
if(score!=100)
System.out.println("alert: full score of test paper"+paper0.get(m).getPaperNum()+" is not 100 points");
}
System.out.println("The test paper number does not exist");
}else{
for(m=0;m<n;m++){
score=0;
for(i=0;i<paper0.get(m).numList.size();i++){
score=score+paper0.get(m).scoreList.get(i);
}
if(score!=100)
System.out.println("alert: full score of test paper"+paper0.get(m).getPaperNum()+" is not 100 points");
}

if(n==1&&p>1)//正常输出所有的内容，结果，分数
{
for(m=0;m<p;m++){

for(i=0;i<inAnswer0.get(m).inputList.size();i++){
    if(paper0.get(m).questionList.get(i).getModelAnswer()==inAnswer0.get(m).inputList.get(i)){
        check=true;
    }else{
        check=false;
        paper0.get(m).scoreList.set(i,0);
    }
    System.out.println(paper0.get(m).questionList.get(i).getContent()+"~"+inAnswer0.get(m).inputList.get(i)+"~"+check);
    }
    score=0;
    for(j=0;j<inAnswer0.get(m).inputList.size();j++){
        score=score+paper0.get(m).scoreList.get(j);
    }
for(j=0;j<paper0.get(m).numList.size();j++){
        if(j==paper0.get(m).numList.size()-1){
            System.out.println(paper0.get(m).scoreList.get(j)+"~"+score);
        }else{
            System.out.printf(paper0.get(m).scoreList.get(j)+" ");
        }
   }
}

}else{
for(m=0;m<p;m++){
if(inAnswer0.get(m).getInPaperNum()!=paper0.get(m).getPaperNum())
{System.out.println("The test paper number does not exist");}else{
for(i=0;i<inAnswer0.get(m).inputList.size();i++)
{
if(paper0.get(m).questionList.get(i).getModelAnswer()inAnswer0.get(m).inputList.get(i)){
check=true;
}else{
check=false;
paper0.get(m).scoreList.set(i,0);
}
System.out.println(paper0.get(m).questionList.get(i).getContent()+"_{"+inAnswer0.get(m).inputList.get(i)+"}"+check);
}
for(j=0;j<(paper0.get(m).numList.size()-inAnswer0.get(m).inputList.size());j++){
System.out.println("answer is null");
}
score=0;
for(j=0;j<inAnswer0.get(m).inputList.size();j++){
score=score+paper0.get(m).scoreList.get(j);
}
if(paper0.get(m).numList.size()-inAnswer0.get(m).inputList.size()>0){
for(j=0;j<inAnswer0.get(m).inputList.size();j++){
System.out.print(paper0.get(m).scoreList.get(j)+" ");
}
for(j=0;j<paper0.get(m).numList.size()-inAnswer0.get(m).inputList.size();j++){
if(jpaper0.get(m).numList.size()-inAnswer0.get(m).inputList.size()-1){
System.out.println("0~"+score);
}else{
System.out.printf("0 ");
}
}
}else{
for(j=0;j<paper0.get(m).numList.size();j++){
if(j==paper0.get(m).numList.size()-1){
System.out.println(paper0.get(m).scoreList.get(j)+"~"+score);
}else{
System.out.printf(paper0.get(m).scoreList.get(j)+" ");
}
}
}
}
}
}
}
}
}

2.3题目集3最后一题

设计思路：
1.先判断每行的输入格式，将格式不正确的输出，并将格式正确的存入到一个字符串数组中。
2.读取被删除的题号，并将之存到一个ArrayList里，没有则不需要判断。
3.再读取到题目信息时，判断该题是否被删除，不被删除的话则正常将每个信息存入，并放到一个ArrayList中，否则将内容换成the question num invalid~0。
4.读取试卷信息，根据试卷信息将从questionList中提取相应题号存入到该paper中的questiongList中。
5.读取学生信息。
6.读取答卷信息，先判断该答卷号能否找到相应的试卷，不能的话则输出The test paper number does not exist；反之则正常判断。
空：判断答卷答案是否小于试卷上的题目数量，小于的话则证明有空的答案；（answer is null）
不存在：判断试卷信息上题号是否在questionList中找的到，找不到的话则说明不存在；（non-existent question）
找学号：在学生信息中找，没找到的话则输出（is Not found），找到的话则正常输出学号，姓名，分数，总分。
7.情况判定
（1）.该题为空，直接输出answer is null。
（2）.该题存在，判断是否存在，存在则判断是否正确。不存在则输出non-existent question。
`
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
ArrayList paperlist=new ArrayList<>();
ArrayList answerpaperlist=new ArrayList<>();
Delete delete=new Delete();
StuMessage stu=new StuMessage();
AnswerPaper answerpaper;
Question question;
int i=0,m=0;
ArrayList str=new ArrayList<>();
while(true) {
String str1=in.nextLine();
if(str1.equals("end")) {
break;
}else {
Pattern pattern1=Pattern.compile("#N:\d+\s#Q:\d+\+\d+\=\s#A:\d+");
Matcher matcher1=pattern1.matcher(str1);
Pattern pattern2=Pattern.compile("#T:\d+(\s\d\-\d)");
Matcher matcher2=pattern2.matcher(str1);
Pattern pattern3=Pattern.compile("#X:(\d{8}\s[a-zA-Z]+\-{0,2})");
Matcher matcher3=pattern3.matcher(str1);
Pattern pattern4=Pattern.compile("#D:(N\-\d+\s{0,2})");
Matcher matcher4=pattern4.matcher(str1);
Pattern pattern5=Pattern.compile("#S:\d\s\d{8}\s(#A:\d+\-\d+\s{0,2})");
Matcher matcher5=pattern5.matcher(str1);
if(!matcher1.find()&&!matcher2.find()&&!matcher3.find()&&!matcher4.find()&&!matcher5.find()){
System.out.println("wrong format:"+str1);
}else{
str.add(str1);
}
}
}
for(String str2:str) {
if(str2.startsWith("#T")) {
Paper paper=new Paper(str2);
paper.setAll();
paperlist.add(paper);
}
}
for(String str3:str) {
if(str3.startsWith("#D")) {
delete.setall(str3);
delete.setAll();
}
}
for(String str4:str) {
if(str4.startsWith("#X")) {
stu.setALLmes(str4);
stu.setAll();
}
}
for(String str5:str) {
if(str5.startsWith("#N")) {
question=new Question(str5,delete);
question.setAll();
question.deleted();
for(Paper paper:paperlist) {
paper.setQuestionPaper(question);
}

	}
}
for(String str6:str) {
	m=0;
	if(str6.startsWith("#S")) {
		answerpaper=new AnswerPaper(str6,stu);
		answerpaper.setMes();
		for(Paper paper:paperlist) {
			if(paper.getPaperNum()==answerpaper.getInPaperNum()) {
				answerpaper.setPaper(paper);
				m=1;
				break;
			}
		}
		if(m==1) {
		answerpaper.setInput();
		}
		answerpaperlist.add(answerpaper);
}
}
for(Paper paper:paperlist) {
	paper.print();
}
in.close();
for(AnswerPaper answer:answerpaperlist) {
	i=0;
	for(Paper paper:paperlist) {
		if(answer.getInPaperNum()==paper.getPaperNum()) {
			i=1;
			break;
		}
	}
	if(i==1) {
		answer.checkAnswerRight();
		answer.checkNull();
		answer.confirmScore();
		answer.printAllContent();
		answer.printStuMes();
		if(answer.findSid()) {
			answer.printScore();
		}
	}else {
		System.out.println("The test paper number does not exist");
	}
}

}
}
class Question {
private String allquestion;
private int questionNum;
private String content;
private int modelAnswer;
Delete delete;
public Question(String all,Delete delete){
this.allquestion=all;
this.delete=delete;
}
public void setAll(){

    Pattern pattern1=Pattern.compile("(?<=#N:)\\d+(?=\\s+)");
    Matcher matcher1=pattern1.matcher(this.allquestion);
    if(matcher1.find()){
        this.questionNum=Integer.parseInt(matcher1.group());
    }
    Pattern pattern2=Pattern.compile("(?<=#Q:).*(?=\\s+#A)");
    Matcher matcher2=pattern2.matcher(this.allquestion);
    if(matcher2.find()){
        this.content=matcher2.group();
    }
    
    Pattern pattern3=Pattern.compile("(?<=#A:)\\d+(?=\\s*)");
    Matcher matcher3=pattern3.matcher(this.allquestion);
    if(matcher3.find()){
        this.modelAnswer=Integer.parseInt(matcher3.group());
    }
	
}
    public int getQuestionNum(){
        return this.questionNum;
    }
    public String getContent(){
        return this.content;
    }
    public void setContent(String str){
        this.content=str;
    }
    public int getModelAnswer(){
        return this.modelAnswer;
    }
    public boolean checkDelete() {//检查是否被删除
    	for(Integer deletenum:this.delete.deleteList) {
    		if(this.getQuestionNum()==deletenum) {
    			return false;
    		}
    	}
    	return true;
    }
    public void deleted() {
    	if(!this.checkDelete()) {
    		this.content="the question "+this.getQuestionNum()+" invalid";
    	}
    }

}
class Paper {
private String allPaper;
private int paperNum;
public ArrayList numList=new ArrayList();
public ArrayList scoreList=new ArrayList();
public HashMap<Integer,Question> questionList=new HashMap<Integer,Question>();

    public void setQuestionPaper(Question question) {//设置hashmap的题目数组，（题号，题目类）
    	for(Integer num:this.numList) {
    		if(question.getQuestionNum()==num) {
    	questionList.put(question.getQuestionNum(),question);
            break;
    		}
    	}	
    }
    public Paper(String all){
        this.allPaper=all;
    }
     public Paper(){
        
    }
    public void setAll(){
        Pattern pattern1=Pattern.compile("(?<=#T:)\\d+(?=\\s+)");
        Matcher matcher1=pattern1.matcher(this.allPaper);
        if(matcher1.find()){
            this.paperNum=Integer.parseInt(matcher1.group());
        }
        Pattern pattern2=Pattern.compile("(?<=\\s)\\d+(?=\\-)");
        Matcher matcher2=pattern2.matcher(this.allPaper);
        while(matcher2.find()) {
        	numList.add(Integer.parseInt(matcher2.group()));
        }
        Pattern pattern3=Pattern.compile("(?<=\\-)\\d+");
        Matcher matcher3=pattern3.matcher(this.allPaper);
        while(matcher3.find()){
        	scoreList.add(Integer.parseInt(matcher3.group()));
        }
    }
    public int getPaperNum(){
        return this.paperNum;
    }
    public int getScore() {
    	int i=0,score=0;
    	while(i<scoreList.size()) {
    		score+=scoreList.get(i);
    		i++;
    	}
    	return score;
    }
    public void print() {
    	if(this.getScore()!=100)
    	System.out.println("alert: full score of test paper"+this.getPaperNum()+" is not 100 points");
    }

}
class StuMessage {
private String allmes;
public HashMap<String,String> sidlist=new HashMap<String,String>();
private String sid;
private String name;
public StuMessage() {
}
public StuMessage(String str) {
this.allmes=str;
}
public void setAll() {
Pattern pattern1=Pattern.compile("\d{8}");
Matcher matcher1=pattern1.matcher(allmes);
Pattern pattern2=Pattern.compile("[a-zA-z]{3,}");
Matcher matcher2=pattern2.matcher(allmes);
while(matcher1.find()&&matcher2.find())
{
sidlist.put(matcher1.group(),matcher2.group() );
}
}
public String getSid() {
return sid;
}
public String getName() {
return name;
}
public void setALLmes(String str) {
this.allmes=str;
}
}
class Delete {
private String all;
public ArrayList deleteList=new ArrayList<>();
public Delete() {

}
public Delete(String str) {
this.all=str;
}
public void setAll() {
Pattern pattern=Pattern.compile("(?<=N\-)\d+");
Matcher matcher=pattern.matcher(this.all);
while(matcher.find()) {
deleteList.add(Integer.parseInt(matcher.group()));
}
}
public void setall(String str) {
this.all=str;
}
}
class AnswerPaper {
private String allinput;
public HashMap<Integer,Integer> numInanswerList=new HashMap<Integer,Integer>();
public HashMap<Integer,Boolean> rightList=new HashMap<Integer,Boolean>();
public ArrayList nullList=new ArrayList();
public ArrayList nonullList=new ArrayList();
public ArrayList scoreList=new ArrayList();
private int inPaperNum;
private String sid;
private Paper paper;
private StuMessage stu;
public HashMap<Integer,Question> questionList=new HashMap<Integer,Question>();
public void setPaper(Paper paper) {
this.paper=paper;
for(Integer num:paper.questionList.keySet()) {
this.questionList.put(num,paper.questionList.get(num));
}
//for(Question question:paper.questionList.values()) {
// System.out.println(question.getQuestionNum());
// }
for(Integer score:paper.scoreList)
this.scoreList.add(score);
}
public AnswerPaper(String all,StuMessage stu){//paper为匹配到的试卷
this.allinput=all;
this.stu=stu;
}
public void setMes() {
Pattern pattern1=Pattern.compile("(?<=#S:)\d+");
Matcher matcher1=pattern1.matcher(this.allinput);
if(matcher1.find()){
this.inPaperNum=Integer.parseInt(matcher1.group());
}
Pattern pattern4=Pattern.compile("\d{8}");
Matcher matcher4=pattern4.matcher(this.allinput);
if(matcher4.find()) {
this.sid=matcher4.group();
}
}
public void setInput(){
int i=0;
Pattern pattern2=Pattern.compile("(?<=#A:)\d+");
Matcher matcher2=pattern2.matcher(this.allinput);
Pattern pattern3=Pattern.compile("(?<=\-)\d+");
Matcher matcher3=pattern3.matcher(this.allinput);
while(matcher2.find()&&matcher3.find()&&i<this.paper.numList.size()){
numInanswerList.put(this.paper.numList.get(Integer.parseInt(matcher2.group())-1),Integer.parseInt(matcher3.group()));
i++;
}

}
public int getInPaperNum(){
    return this.inPaperNum;
}
public String getSid(){
    return this.sid;
}
public boolean checkAnswer() {//检查格式
	Pattern pattern=Pattern.compile("#S:\\d\\s\\d{8}\\s(#A:\\d+\\-\\d+\\s{0,2})*");
	Matcher matcher=pattern.matcher(this.allinput);
	if(matcher.find()) {
		return true;
	}else {
		return false;
	}
}
public boolean findSid() {//查找学号
	for(String sid:this.stu.sidlist.keySet()) {
		if(sid.equals(this.sid))
			return true;
	}
	return false;
}
public void printStuMes() {//打印学生信息
	if(this.findSid()) {
	System.out.printf(this.sid+" "+this.stu.sidlist.get(this.sid)+":");
	}else
	{
		System.out.println(this.sid+" not found");
	}
}
public void checkAnswerRight() {
	for(Integer num1:this.numInanswerList.keySet()) {//输入答案
		for(Integer num2:this.paper.questionList.keySet()){//标准答案
			if(num1==num2) {
				if(this.numInanswerList.get(num1)==this.paper.questionList.get(num2).getModelAnswer())
					this.rightList.put(num1,true);
				else
					this.rightList.put(num1,false);
			}
		}
	}
}
public void checkNull() {//判断answer is null
	int j=0;
	for(Integer num:this.numInanswerList.keySet()) {
		if(num>0) {
		j++;
		}
	}
	if(j<this.paper.numList.size()) {
	int i=0;
	for(Integer num2:this.paper.numList) {
		i=0;
		for(Integer num1:this.numInanswerList.keySet()) {
			if(num2==num1) {
				i=1;
				break;
			}
		}
		if(i==0) {
			this.nullList.add(num2);
		}
	}
	}
}
public void checkNoNull() {//判断no exist
	int j=0;
	for(Question question:this.paper.questionList.values()) {

question.checkDelete();
j++;
}
if(j<this.paper.numList.size()){
int i=0;
for(Integer num1:this.numInanswerList.keySet()) {
i=0;
for(Integer num2:this.paper.questionList.keySet() ) {
if(num2num1) {
i=1;
break;
}
}
if(i0) {
this.nonullList.add(num1);
}
}
}
}
public void confirmScore(){//确定所有输出分数（题目内容和分数）
int i=0,j=0,k=0,m=0;
for(i=0;i<this.scoreList.size();i++) {
j=0;
k=0;
m=0;
for(int num:this.nullList) {
if(this.paper.numList.get(i)num) {
j=1;
break;
}
}
for(int num:this.nonullList) {
if(this.paper.numList.get(i)num) {
k=1;
break;
}
}
for(Question question:this.questionList.values()) {
if(question.getQuestionNum()this.paper.numList.get(i)) {
if(j0&&k==0) { //判断存在且exist //没被删除
if(this.questionList.get(this.paper.numList.get(i)).checkDelete()) {
if(!this.rightList.get(this.paper.numList.get(i)))
this.scoreList.set(i,0);
}else {
this.scoreList.set(i,0);
}

	   }else {
		   this.scoreList.set(i,0);   
	   }
	   m=1;
	   break;
	   }
   }
	   if(m==0) {
		   this.scoreList.set(i,0);  
	   }
   }

}
public void printAllContent() {//输出所有内容
int i=0,j=0,k=0,m=0;
for(i=0;i<this.scoreList.size();i++) {
j=0;
k=0;
m=0;
for(int num:this.nullList)
{
if(this.paper.numList.get(i)num)
{
j=1;
break;
}
}
for(int num:this.nonullList) {
if(this.paper.numList.get(i)num) {
k=1;
break;
}
}
for(Question question:this.questionList.values()) {
if(question.getQuestionNum()this.paper.numList.get(i)) {
if(j0&&k0) { //判断存在 且exist //判断格式正确且没被删除
if(this.questionList.get(this.paper.numList.get(i)).checkDelete()) {
System.out.println(this.questionList.get(this.paper.numList.get(i)).getContent()+"_{"+this.numInanswerList.get(this.paper.numList.get(i))+"}"+this.rightList.get(this.paper.numList.get(i)));
}else {
System.out.println(this.questionList.get(this.paper.numList.get(i)).getContent()+"~"+this.scoreList.get(i));
}
}else {
if(j1) {
System.out.println("answer is null");
}else {
System.out.println("non-existent question~0");
}
}
m=1;
break;
}
}
if(m0&&j0) {
System.out.println("non-existent question~0");
}else if(m0&&j1)
{
System.out.println("answer is null");
}
}
}
public void printScore() {//打印分数
int allscore=0;
int i=0;
for(i=0;i<this.scoreList.size();i++)
{
allscore+=this.scoreList.get(i);
System.out.printf(" "+this.scoreList.get(i));
}
System.out.printf("~"+allscore);
}
}
`

3.踩坑心得

3.1在题目集2中的一张试卷两张答卷情况判定时，并为考虑到在判定第一张答卷时该试卷里的scoreList中存储的分数已经被改动了，导致两张答卷输出的答案内容几乎一样
例如样例六

实际上第二张答卷输出分数跟第一张答卷一样
心得：在新建一个类时，如果后续存在修改该类的情况下时应开辟两个空间，这两个空间中的内容一致，一个供参考，一个供修改，以便后续其他类调用该类时方便操作。

3.2在题目集3中在判定格式是否错误时在各个类中分别判断，导致代码繁琐。最后改成在主函数中判断，也方便了每行信息遍历，存入到相应的类中。

心得：在进行具有公共性的一个作用设计时，可以考虑将该方法写入到主函数中，分条逐类的将其拆分到各个类中反而会让代码更复杂

3.3在题目集3中在判定空时并未考虑到答卷中答案的数量应该小于试卷中分数的数量，导致存在很多数组超出范围的情况，以致其他答案输出不出来。
逻辑关系没有把握清除

3.4在题目集中在判定题目是空时没有考虑到题目存在的情况，导致输出为（non-existent question~0）；

正确答案answer is null实际上是错误答案non-existent question~0；

在if（m0）中没有加入j0的情况
心得：逻辑关系应该先搞清除，不应该直接上手写代码，这样会导致后续找错时很难找到自己的错误；

3.5并未考虑到如果格式不存在时，不能将该行信息存入到类中，如题目集三最后一题样例5。实际上是将错误格式的内容换成了non-existent question；

虽然输出结果是根标准答案一样，但是如果存在其他情况的话在questionList中会有第一题的存在，则该题就并不是不存在的

4.改进建议
1.在题目集1中最后一题中，我只是简单的在类中设计了如何将获取的字符串转化，存入，设置一下set和get函数，其余方法都在主函数中进行，导致主函数代码过长，不利于后续检查。
而且我应该将判断题目对错的函数（方法）在类中设计，并在主函数中调用该类方法。这样才符合单一职责原则。cuowu

2.在题目集二的最后一题当中，我在上一个的基础上对类做了一小部分的修改，其余方法判断均在主函数中进行，严重不符合单一职责原则。经过后续思考改进，我认为一些特殊情况（在判断一张试卷两张答卷的情况下时应在答卷中设计相关方法，既不会改掉试卷上的相应信息，也可以让后面相同答卷号的信息得到匹配）【具体做法是用一个循环来确定相同答卷号的答卷的数量，将其存到一个ArrayList中，再分别遍历该数组，在各个答卷类中也设置scoreList的泛型，通过匹对答案来确定每道题目的分数】

3.（3.2的改进）将各个类中有关格式判断的方法汇总到一起，用正则表达式来判断该行是否符合格式要求，如果符合，再将每行信息存入到相应的类中，否则输出错误，改进如下；

4.（3.3的改进）在原有基础上加个if判断，如果在题目类中中找到了相应的题号，则进行后续操作，这样就只需要进行已有题目的判断是否为空的操作。改进如下：

5.（3.5的改进）在主函数中设置正则表达式判断将正确格式的内容存到一个str的泛型中，通过将str遍历，就不会将带有错误格式的信息存入类中。

6.对于AnswerPaper类的改进，我认为是需要对该类中的所有信息进行判断从而来输出相关内容，所以很多方法我都在该类完成（例如空答案的题目，不存在的题目，该试卷号没有找到，该学号没有找到等特殊情况进行判断，虽然原先是将各个方法在题目类和试卷类中完成，但是我个人感觉不如放在答卷类中更加直观，通过输出内容我能更加容易找到错误的出处，虽然该类比较庞大，但是我将判断方法，输出方法，设置，获取等方法分块放就也可以很快地找到，并不觉得麻烦了多少）。

5.总结
1.我学到了如何将单一职责原则在类与类中使用体现地更加突出，如何正确使用泛型（ArrayList，LinkedList，HashMap）及其方法，还有正则表达式的基础用法，类设计（封装）更加合理，类与类之间的调用更合理，使代码更具可读性和复用性，同时也对一些调试过程更加的清晰，如何在一些错误情况下找到出处。同时类与类的关系我也更好的把握，到底是组合，聚合或者是依赖等。
2.进一步学习和研究：我认为正则表达式还需要我花很多时间去学习，现在只是懂得了一些基础方法的使用，在面对更加复杂的字符串判断时又该如何高效快速的找到我们所需要的内容。同时对于泛型的更多具体方法我也需要花时间去搞清楚，不止步与一些基础用法。对于类的使用也仅限于8个以内的相互调用，面对更多的类设计可能会把握不准逻辑关系导致面向对象很难完成。
3.对于教师：老师上课对于一些复杂的算法，基础的新方法的运用都会进行讲解，考虑到学生的一个全面编程能力，锻炼学生的逻辑思维能力，请学生上课互动，进行一些新内容的掌握地锻炼，这些对于我来说还算够，更多的建议就是希望老师将一些上课的ppt发到群里，我可以将老师上课的内容进行再次学习和消化。老师也及时让我们做出反馈，让我们在教学过程中能更加高效地学习课程内容，并且开发我们对于该课程的更多想法。同时一些健康编码方式和规则教师也让我们进行规范练习，让我们的代码更具可读性。希望老师能更仔细教一些课外有关Java的软件的使用。
4.对于课程：教学进行线上线下的方式来让我们学习，在一些基础知识上老师要求我们独自掌握，也通过发布一些大作业来加强我们的实践操作能力，同时会让我们同学之间进行讨论，加强我们地沟通能力，以便在未来的工作中让我们更好地与团队合作。课程也要求我们去熟悉开发工具的使用流程，提高开发效率。同时也有一些社区的运用，例如csdn，博客等，我们可在这上面发表文章，学习更多内容。课程包含的方面涵盖很多，我希望在未来的课程学习中能有更多的简单高效的技术学习，在PTA大作也中能有一些关于测试点的解释，让我们知道错误具体在哪里。
5.作业的难度对于我来说还算好，但每次花的时间还是很多，希望得到更多提示，PTA上的一些测试点怎么都找不到错误真的很痛苦。
6.对于实验课来说，是让我们对一些方法和运用更加熟练，加强我们的实践能力，让我们在作业的完成上不会对于一些基础语法方面产生错误，实验是必要的，多的建议就是实验是一个星期两节课就已经足够。