答题判题系统的三次优化

qianliji3498741082 / 2024-04-21 / 原文

目录：
一）前言
二）设计与分析
三）踩坑心得
四）改进建议
五）总结
一.前言
（1）答题判题程序-1：
【1】知识点：charAt()的运用，正则表达式，数据形式转换
【2】题量：较少
【3】难度：较易
（2）答题判题程序-2:
【1】知识点：charAt()的运用，正则表达式，ArrayList的运用
【2】题量：中等
【3】难度：中等
（3）答题判题程序-3:
【1】知识点：charAt()的运用，正则表达式，数据结构的初步运用
【2】题量：较多
【3】难度：困难
二.设计与分析
Sourcemonitor结果（以答题判题程序-3为准）：
（1）
（2）
（3）
（4）
Poweresigner结果（以答题判题程序-3为准）：

答题判题程序-1：
（1）类的设计思路图：

（2）设计具体思路：
1.首先，创建一个整形数组，用于接收从键盘输入的问题数量的数据。
Scanner sc = new Scanner(System.in); int i=sc.nextInt();
2.接收步骤1所记录的问题数的数量的字符串。
while(information[line_num].compareTo("end")!=0) { line_num++; information[line_num]=sc.nextLine(); }

3.创建一个Question类对象，并使用正则表达式对每条进行截取得到题号num，题目question，标准答案standardanswer以此对Question类对象进行实例化。
if(matcher1.matches()) { String squestion_num=information[j].substring(information[j].indexOf("#N:")+3,information[j].indexOf("#Q:")); String question=information[j].substring(information[j].indexOf("#Q:")+3,information[j].indexOf("#A:")); String standardanswer=information[j].substring(information[j].indexOf("#A:")+3); squestion_num=squestion_num.trim(); int question_num=Integer.parseInt(squestion_num); question=question.trim(); standardanswer=standardanswer.trim(); my_test.test_question[j]=new Question(); my_test.test_question[j].question_num=question_num; my_test.test_question[j].question=question; my_test.test_question[j].standardanswer=standardanswer; }

4.接受一个装载着回答的信息的字符，以'#'出现的次数对回答数进行统计，接受一个装载着回答的信息的字符串，运用正则表达式对字符串进行截取得到回答answer，创建回答个数个的Answer类对象，并用所截取的字符串对这些对象进行实例化。
for(int k=0;k<information[i].length();k++) { if(information[i].charAt(k)=='A') { answer_number++; } }
answer_number=answer_number+1; Sheet my_sheet=new Sheet(); my_sheet.answer_inition(answer_number); String []sheet_answer=information[i].split("#A:"); for(int k=1;k<answer_number;k++) { my_sheet.sheet_answer[k]=new Answer(); } for(int k=1;k<answer_number;k++) { String []num_and_answer=sheet_answer[k].split("-"); my_sheet.sheet_answer[k].answer_num=Integer.parseInt(num_and_answer[0]); my_sheet.sheet_answer[k].answer=num_and_answer[1].trim(); }

5.按照题号的大小，对Qusetion类进行排序（从小到大）
`for(int j=0;j<question_number-1;j++)
{
for(int k=0;k<question_number-1-j;k++)
{
if(my_test.test_question[k].question_num>my_test.test_question[k+1].question_num)
{
int change_num=my_test.test_question[k].question_num;
String change_question=my_test.test_question[k].question;
String change_standardanswer= my_test.test_question[k].standardanswer;
int change_score=my_test.test_question[k].score;
my_test.test_question[k].question_num=my_test.test_question[k+1].question_num;
my_test.test_question[k].question=my_test.test_question[k+1].question;
my_test.test_question[k].standardanswer=my_test.test_question[k+1].standardanswer;
my_test.test_question[k].score=my_test.test_question[k+1].score;
my_test.test_question[k+1].question_num=change_num;
my_test.test_question[k+1].question=change_question;
my_test.test_question[k+1].standardanswer=change_standardanswer;

        }
        }
    }//题目按照题号排序`

6.在对Question类对象的循环遍历中用Answer[]类对象进行匹配，先输出该题目，再输出回答。若有能匹配的，输出"true ",否则输出“false ”.
for(j=0;j<i;j++) { System.out.println(Question[j].toString()); }//结果输出
if(Question[j].answer.compareTo(Question[j].my_answer)==0) { System.out.printf("%s ",true); } else { System.out.printf("%s ",false); }
答题判题程序-2：
（1）类的设计思路图

（2）设计具体思路：
1.创建一个足够大的字符串数组，用于接收所有的字符串直至字符串为"end"为止；
String []information=new String[100]; int line_num=0; Scanner sc = new Scanner(System.in); information[0]=sc.nextLine(); while(information[line_num].compareTo("end")!=0) { line_num++; information[line_num]=sc.nextLine(); }
2.根据该字符串数组中的每个字符串中的第二个字符即charAt(1)在对整个字符串数组information[]进行遍历的循环中来判断该字符串属于哪个类型的信息（答题操作），并据此进行后续操作（判题操作）。
【1】charAt(1)='N'，该字符串为题目信息
[1]使用正则表达式判断字符串是否符合格式，若符合进行操作[2]，
否则System.out.printf("wrong format%s\n",该字符串);
[2]将该字符串使用正则表达式进行截取，获得题号，题目，标准答案。
[3]创建一个题目类my_question，并用上述获得的信息实例化一个题目对象。
if(j<question_number) { if(matcher1.matches()) { String squestion_num=information[j].substring(information[j].indexOf("#N:")+3,information[j].indexOf("#Q:")); String question=information[j].substring(information[j].indexOf("#Q:")+3,information[j].indexOf("#A:")); String standardanswer=information[j].substring(information[j].indexOf("#A:")+3); squestion_num=squestion_num.trim(); int question_num=Integer.parseInt(squestion_num); question=question.trim(); standardanswer=standardanswer.trim(); my_test.test_question[j]=new Question(); my_test.test_question[j].question_num=question_num; my_test.test_question[j].question=question; my_test.test_question[j].standardanswer=standardanswer; } else { my_test.test_question[j]=new Question(); my_test.test_question[j].question_num=-1; my_test.test_question[j].question="none_question"; my_test.test_question[j].standardanswer="none_standardanswer"; System.out.printf("wrong format:%s\n",information[j]); } }
【2】charAt(1)='T'，该字符串为试卷信息
[1]使用正则表达式判断字符串是否符合格式，若符合进行操作[2]，
否则System.out.printf("wrong format%s\n",该字符串);
[2]将该字符串使用正则表达式进行截取，获得题号，题分。
[3]将此处得到的题号与实例化的题目类的对象my_answer[]的题号进行匹配，若一致则题分为该题目对象的题分。
` if(information[i].charAt(1)=='T')
{
Test my_test=new Test();
my_test.inition(question_number);
int total_grade=0;
for(int j=0;j<=question_number;j++)
{
String sentence1 = information[j];
String regex1 = "#N:\s\d+\s#Q:.\s#A:.";
Pattern pattern1 = Pattern.compile(regex1);
Matcher matcher1 = pattern1.matcher(sentence1);
if(j<question_number)
{
if(matcher1.matches())
{
String squestion_num=information[j].substring(information[j].indexOf("#N:")+3,information[j].indexOf("#Q:"));
String question=information[j].substring(information[j].indexOf("#Q:")+3,information[j].indexOf("#A:"));
String standardanswer=information[j].substring(information[j].indexOf("#A:")+3);
squestion_num=squestion_num.trim();
int question_num=Integer.parseInt(squestion_num);
question=question.trim();
standardanswer=standardanswer.trim();
my_test.test_question[j]=new Question();
my_test.test_question[j].question_num=question_num;
my_test.test_question[j].question=question;
my_test.test_question[j].standardanswer=standardanswer;
}
else
{
my_test.test_question[j]=new Question();
my_test.test_question[j].question_num=-1;
my_test.test_question[j].question="none_question";
my_test.test_question[j].standardanswer="none_standardanswer";
System.out.printf("wrong format:%s\n",information[j]);
}
}
else
{
String sentence2 = information[j];
String regex2 = "#T:\s(\d)\s(\s\d+-\d+\s)*";
Pattern pattern2 = Pattern.compile(regex2);
Matcher matcher2 = pattern2.matcher(sentence2);
if(matcher2.matches())
{
String stest_num=information[j].substring(information[j].indexOf("#T:")+3,information[j].indexOf("-")-1);
stest_num=stest_num.trim();
int test_num=Integer.parseInt(stest_num);
my_test.test_num=test_num;
String c[]=information[j].split("( )");
for(int k=1;k<c.length;k++)
{
String []score=c[k].split("\s+|(-)");
score[1]=score[1].trim();
int question_score=Integer.parseInt(score[1]);
my_test.test_question[k-1].score=question_score;
}
}
}
}//试卷类中的题目类的题号、题目、标准答案、分值的赋值
if(total_grade!=100)
{
System.out.printf("alert: full score of test paper%d is not 100 points\n",my_test.test_num);
}

            for(int j=0;j<question_number;j++)
            {
                total_grade=total_grade+my_test.test_question[j].score;
            }
            test_number++;
        }//试卷类的创建并赋值`

【3】charAt(1)='S'，该字符串为答卷信息
[1]使用正则表达式判断字符串是否符合格式，若符合进行操作[2]，
否则System.out.printf("wrong format%s\n",该字符串);
[2]将该字符串使用正则表达式进行截取，获得试卷号回答。
[3]先根据'-'出现的次数统计答题的数量，创建一个答题类数组my_answer[]，使用题目号与回答对答题类进行初始化。
再创建一个答卷类数组my_sheet[]，从my_sheet[0]开始用试卷号与答题类数组对答卷类进行初始化，每当有一个information[]的charAt(1)=='S'，my_sheet[]的数组序号加1，题目数重置为0，以便多个答卷的操作。
if(information[i].charAt(1)=='S') { String sentence5 = information[i]; String regex5 = "#S:\\s*(\\d+)\\s+(\\w*)\\s*(#A:\\s*(\\d+-?[^#]*))*"; Pattern pattern5 = Pattern.compile(regex5); Matcher matcher5 = pattern5.matcher(sentence5); if(matcher5.matches()) { Test my_test=new Test(); my_test.inition(question_number); for(int j=0;j<question_number;j++) { my_test.test_question[j]=new Question(); } for(int j=0;j<=question_number;j++) { if(j<question_number) { String sentence1 = information[j]; String regex1 = "#N:\\s*\\d+\\s*#Q:.*\\s*#A:.*"; Pattern pattern1 = Pattern.compile(regex1); Matcher matcher1 = pattern1.matcher(sentence1); if(matcher1.matches()) { String squestion_num=information[j].substring(information[j].indexOf("#N:")+3,information[j].indexOf("#Q:")); String question=information[j].substring(information[j].indexOf("#Q:")+3,information[j].indexOf("#A:")); String standardanswer=information[j].substring(information[j].indexOf("#A:")+3); squestion_num=squestion_num.trim(); int question_num=Integer.parseInt(squestion_num); question=question.trim(); standardanswer=standardanswer.trim(); my_test.test_question[j]=new Question(); my_test.test_question[j].question_num=question_num; my_test.test_question[j].question=question; my_test.test_question[j].standardanswer=standardanswer; } else { my_test.test_question[j]=new Question(); my_test.test_question[j].question_num=-1; my_test.test_question[j].question="none_question"; my_test.test_question[j].standardanswer="none_standardanswer"; } } else { String sentence2 = information[j]; String regex2 = "#T:\\s*(\\d*)\\s*(\\s*\\d+-\\d+\\s*)*"; Pattern pattern2 = Pattern.compile(regex2); Matcher matcher2 = pattern2.matcher(sentence2); if(matcher2.matches()) { String stest_num=information[j].substring(information[j].indexOf("#T:")+3,information[j].indexOf("-")-1); stest_num=stest_num.trim(); int test_num=Integer.parseInt(stest_num); my_test.test_num=test_num; String c[]=information[j].split("( )"); for(int k=1;k<c.length;k++) { String []score=c[k].split("\\s+|(-)"); score[1]=score[1].trim(); int question_score=Integer.parseInt(score[1]); my_test.test_question[k-1].score=question_score; my_test.test_question[k-1].question_num2=Integer.parseInt(score[0]); }my_test.test_question[k+1].score=change_score; } else { System.out.printf("wrong format:%s\n",information[j]); } } }//试卷类中的题目类的题号、题目、标准答案、分值的赋值
【4】进行判题操作
[1]创建一个整形数据grade为0；
[1]首先根据题目对象的题号根据题号大小对整个题目类数组进行排序（从小到大）。
[2]在对试卷类的题目类进行循环遍历操作是用所有答卷类的答题类进行匹配，如果匹配，则输出该题目并输出"true\n"，grade+该题的题分，否则输出该题目并输出"false\n"，grade加0。
[3]输出每一题的题分，最后输出该张卷子的总分。

答题判题程序-3：
（1）类的设计思路图：

Question与Test类为结合关系，Answer类与Sheet类也为结合关系，主要是对Test类和Sheet类进行操作
（2）程序设计具体思路：
1.首先创建一个字符串数组information[]，将所有的字符串都输入进这个字符串数组中，直至字符串为"end",则停止，以此对所有字符串进行储存并进行统计。
String []information=new String[100]; int line_num=0; Scanner sc = new Scanner(System.in); information[0]=sc.nextLine(); while(information[line_num].compareTo("end")!=0) { line_num++; information[line_num]=sc.nextLine(); }
2.根据该字符串数组中的每个字符串中的第二个字符即charAt(1)在对整个字符串数组information[]进行遍历的循环中来判断该字符串属于哪个类型的信息（答题操作），并据此进行后续操作（判题操作）。
【1】charAt(1)='N'，该字符串为题目信息
[1]使用正则表达式判断字符串是否符合格式，若符合进行操作[2]，
否则System.out.printf("wrong format%s\n",该字符串);
[2]将该字符串使用正则表达式进行截取，获得题号，题目，标准答案。
[3]创建一个题目类my_question，并用上述获得的信息实例化一个题目对象。
if(j<question_number) { if(matcher1.matches()) { String squestion_num=information[j].substring(information[j].indexOf("#N:")+3,information[j].indexOf("#Q:")); String question=information[j].substring(information[j].indexOf("#Q:")+3,information[j].indexOf("#A:")); String standardanswer=information[j].substring(information[j].indexOf("#A:")+3); squestion_num=squestion_num.trim(); int question_num=Integer.parseInt(squestion_num); question=question.trim(); standardanswer=standardanswer.trim(); my_test.test_question[j]=new Question(); my_test.test_question[j].question_num=question_num; my_test.test_question[j].question=question; my_test.test_question[j].standardanswer=standardanswer; } else { my_test.test_question[j]=new Question(); my_test.test_question[j].question_num=-1; my_test.test_question[j].question="none_question"; my_test.test_question[j].standardanswer="none_standardanswer"; System.out.printf("wrong format:%s\n",information[j]); } }
【2】charAt(1)='T'，该字符串为试卷信息
[1]使用正则表达式判断字符串是否符合格式，若符合进行操作[2]，
否则System.out.printf("wrong format%s\n",该字符串);
[2]将该字符串使用正则表达式进行截取，获得题号，题分。
[3]将此处得到的题号与实例化的题目类的对象my_answer[]的题号进行匹配，若一致则题分为该题目对象的题分 else
{
String sentence2 = information[j];
String regex2 = "#T:\s(\d)\s(\s\d+-\d+\s)";
Pattern pattern2 = Pattern.compile(regex2);
Matcher matcher2 = pattern2.matcher(sentence2);
if(matcher2.matches())
{
String stest_num=information[j].substring(information[j].indexOf("#T:")+3,information[j].indexOf("-")-1);
stest_num=stest_num.trim();
int test_num=Integer.parseInt(stest_num);
my_test.test_num=test_num;
String c[]=information[j].split("( )");
for(int k=1;k<c.length;k++)
{
String []score=c[k].split("\s+|(-)");
score[1]=score[1].trim();
int question_score=Integer.parseInt(score[1]);
my_test.test_question[k-1].score=question_score;
}
}
}。
``
【3】charAt(1)='X'，该字符串为学生信息
[1]使用正则表达式判断字符串是否符合格式，若符合进行操作[2]，
否则System.out.printf("wrong format%s\n",该字符串);
[2]将该字符串使用正则表达式进行截取，获得学生姓名，学生学号。
[3]根据字符串中'-'出现的次数来对学生数进行统计，并创建容量为此的学生对象数组student[]，并使用所获得的姓名与学号对学生对象进行初始化。
if(information[i].charAt(1)=='X') { String sentence3 = information[i]; String regex3 = "#X:\\s*(\\d+)\\s*(.*)(-(\\d+)\\s*(.*))*"; Pattern pattern3 = Pattern.compile(regex3); Matcher matcher3 = pattern3.matcher(sentence3); if(matcher3.matches()) { for(int k=0;k<information[i].length();k++) { if(information[i].charAt(k)=='-') { student_number++; } } } else { System.out.printf("wrong format:%s\n",information[i]); } }
【4】charAt(1)='S'，该字符串为答卷信息
[1]使用正则表达式判断字符串是否符合格式，若符合进行操作[2]，
否则System.out.printf("wrong format%s\n",该字符串);
[2]将该字符串使用正则表达式进行截取，获得试卷号，答题人，题目号，回答。
[3]先根据'-'出现的次数统计答题的数量，创建一个答题类数组my_answer[]，使用题目号与回答对答题类进行初始化。
再创建一个答卷类my_sheet，用试卷号与答题类数组对答卷类进行初始化。
【5】charAt(1)='D'，该字符串为删除信息
[1]使用正则表达式判断字符串是否符合格式，若符合进行操作[2]，
[2]将该字符串使用正则表达式进行截取，获得删除的题目号delete_num；
否则System.out.printf("wrong format%s\n",该字符串);
【6】求整个题目类数组的题分的总和total_grade，如果total<100，则输出“alert: full score of test paper试卷号 is not 100 points”
【7】进行判题操作
`if(information[i].charAt(1)=='S')
{
String sentence5 = information[i];
String regex5 = "#S:\s(\d+)\s+(\w)\s(#A:\s(\d+-?[^#]))";
Pattern pattern5 = Pattern.compile(regex5);
Matcher matcher5 = pattern5.matcher(sentence5);
if(matcher5.matches())
{
Test my_test=new Test();
my_test.inition(question_number);
for(int j=0;j<question_number;j++)
{
my_test.test_question[j]=new Question();
}
for(int j=0;j<=question_number;j++)
{
if(j<question_number)
{
String sentence1 = information[j];
String regex1 = "#N:\s\d+\s#Q:.\s#A:.";
Pattern pattern1 = Pattern.compile(regex1);
Matcher matcher1 = pattern1.matcher(sentence1);
if(matcher1.matches())
{
String squestion_num=information[j].substring(information[j].indexOf("#N:")+3,information[j].indexOf("#Q:"));
String question=information[j].substring(information[j].indexOf("#Q:")+3,information[j].indexOf("#A:"));
String standardanswer=information[j].substring(information[j].indexOf("#A:")+3);
squestion_num=squestion_num.trim();
int question_num=Integer.parseInt(squestion_num);
question=question.trim();
standardanswer=standardanswer.trim();
my_test.test_question[j]=new Question();
my_test.test_question[j].question_num=question_num;
my_test.test_question[j].question=question;
my_test.test_question[j].standardanswer=standardanswer;
}
else
{
my_test.test_question[j]=new Question();
my_test.test_question[j].question_num=-1;
my_test.test_question[j].question="none_question";
my_test.test_question[j].standardanswer="none_standardanswer";
}
}
else
{
String sentence2 = information[j];
String regex2 = "#T:\s(\d)\s(\s\d+-\d+\s)*";
Pattern pattern2 = Pattern.compile(regex2);
Matcher matcher2 = pattern2.matcher(sentence2);
if(matcher2.matches())
{
String stest_num=information[j].substring(information[j].indexOf("#T:")+3,information[j].indexOf("-")-1);
stest_num=stest_num.trim();
int test_num=Integer.parseInt(stest_num);
my_test.test_num=test_num;
String c[]=information[j].split("( )");
for(int k=1;k<c.length;k++)
{
String []score=c[k].split("\s+|(-)");
score[1]=score[1].trim();
int question_score=Integer.parseInt(score[1]);
my_test.test_question[k-1].score=question_score;
my_test.test_question[k-1].question_num2=Integer.parseInt(score[0]);
}my_test.test_question[k+1].score=change_score;
}
else
{
System.out.printf("wrong format:%s\n",information[j]);
}
}
}//试卷类中的题目类的题号、题目、标准答案、分值的赋值

for(int j=0;j<question_number-1;j++)
{
for(int k=0;k<question_number-1-j;k++)
{
if(my_test.test_question[k].question_num>my_test.test_question[k+1].question_num)
{
int change_num=my_test.test_question[k].question_num;
String change_question=my_test.test_question[k].question;
String change_standardanswer= my_test.test_question[k].standardanswer;
int change_score=my_test.test_question[k].score;
my_test.test_question[k].question_num=my_test.test_question[k+1].question_num;
my_test.test_question[k].question=my_test.test_question[k+1].question;
my_test.test_question[k].standardanswer=my_test.test_question[k+1].standardanswer;
my_test.test_question[k].score=my_test.test_question[k+1].score;
my_test.test_question[k+1].question_num=change_num;
my_test.test_question[k+1].question=change_question;
my_test.test_question[k+1].standardanswer=change_standardanswer;

        }
        }
    }//题目按照题号排序
                        
            student_number=student_number+1;
        Student []student=new Student[student_number+1];
            for(int w=0;w<i;w++)
            {
                if(information[w].charAt(1)=='X')
                {
            String c[]=information[w].split("(#X:)");
            String []all_information=c[1].split("-");
            for(int k=0;k<all_information.length;k++)
            {
            student[k]=new Student();
            String []student_information=all_information[k].split(" ");
            student[k].id=student_information[0];
            student[k].name=student_information[1];
            }
                }
            }//学生数统计与学生类的创建于实例化
            int answer_number=0;
            String student_information=information[i].substring(information[i].indexOf("#S:")+3,information[i].indexOf("#A:"));
            String []test_num_id=student_information.split(" ");
            for(int k=0;k<information[i].length();k++)
            {
                if(information[i].charAt(k)=='A')
                {
                    answer_number++;
                }
            }
            answer_number=answer_number+1;
            Sheet my_sheet=new Sheet();
            my_sheet.answer_inition(answer_number);
            String []sheet_answer=information[i].split("#A:");
            for(int k=1;k<answer_number;k++)
            {
                my_sheet.sheet_answer[k]=new Answer();
            }
            for(int k=1;k<answer_number;k++)
            {
            String []num_and_answer=sheet_answer[k].split("-");
            my_sheet.sheet_answer[k].answer_num=Integer.parseInt(num_and_answer[0]);
            my_sheet.sheet_answer[k].answer=num_and_answer[1].trim();
            }

for(int j=1;j<answer_number;j++)
{
for(int k=1;k<answer_number-j;k++)
{
if(my_sheet.sheet_answer[k].answer_num>my_sheet.sheet_answer[k+1].answer_num)
{
int change_num=my_sheet.sheet_answer[k].answer_num;
String change_answer= my_sheet.sheet_answer[k].answer;
my_sheet.sheet_answer[k].answer_num=my_sheet.sheet_answer[k+1].answer_num;
my_sheet.sheet_answer[k].answer=my_sheet.sheet_answer[k+1].answer;
my_sheet.sheet_answer[k+1].answer_num=change_num;
my_sheet.sheet_answer[k+1].answer=change_answer;
}
}
}//题目按照题号排序

            int sheet_answer_num=Integer.parseInt(test_num_id[0]);
            String answer_man=test_num_id[1];
            if(sheet_answer_num==my_test.test_num)
            {
                                int delete_one=-1;
 if(information[i+1].charAt(1)=='D')
           {
               String sentence = information[i+1];
                  String regex = "#D:\\s*N-\\d+";
                  Pattern pattern = Pattern.compile(regex);
                  Matcher matcher = pattern.matcher(sentence);
                   if(matcher.matches())
                   {
               String []delete_num=information[i+1].split("#D:N-");
               delete_one=Integer.parseInt(delete_num[1]);
                   }
                   else
                   {
                       System.out.printf("wrong format%s\n",information[i+1]);
                   }
           }
            for(int p=0;p<student_number;p++)
            {
                if(answer_man.compareTo(student[p].id)==0)
                {
                    
                    for(int q=0;q<question_number;q++)
                    {
                        if(delete_one!=my_test.test_question[q].question_num&&my_sheet.sheet_answer[q+1].answer_num==my_test.test_question[q].question_num)
                        {
                        System.out.printf("%s",my_test.test_question[q].question);
                        }
                        if(my_test.test_question[q].standardanswer.compareTo( my_sheet.sheet_answer[q+1].answer)==0&&delete_one!=my_test.test_question[q].question_num&&my_sheet.sheet_answer[q+1].answer_num==my_test.test_question[q].question_num)
                        {
                            System.out.printf("~%s~true\n",my_test.test_question[q].standardanswer);
                        }
                        else if(my_test.test_question[q].standardanswer.compareTo( my_sheet.sheet_answer[q+1].answer)!=0&&delete_one!=my_test.test_question[q].question_num&&my_sheet.sheet_answer[q+1].answer_num==my_test.test_question[q].question_num)
                        {
                            System.out.printf("~%s~false\n",my_sheet.sheet_answer[q+1].answer);
                        }
                        
                        else if(delete_one==my_test.test_question[q].question_num&&my_sheet.sheet_answer[q+1].answer_num==my_test.test_question[q].question_num&&my_sheet.sheet_answer[q+1].answer_num==my_test.test_question[q].question_num&&my_test.test_question[q].question_num2==my_sheet.sheet_answer[q+1].answer_num)
                        {
                            System.out.printf("the question %d invalid~0\n",delete_one);
                        }
                        if(my_sheet.sheet_answer[q+1].answer_num!=my_test.test_question[q].question_num||my_sheet.sheet_answer[q+1].answer_num!=my_test.test_question[q].question_num2)
                        {
                            System.out.printf("non-existent question~0\n");
                        }
                    }
                    if(answer_number<question_number)
                    {
                        System.out.printf("no");
                    }
                    int grade=0;
                    System.out.printf("%s %s:",student[p].id,student[p].name);
                    for(int q=0;q<question_number;q++)
                    {
                        if(my_test.test_question[q].standardanswer.compareTo( my_sheet.sheet_answer[q+1].answer)==0&&delete_one!=my_test.test_question[q].question_num&&my_sheet.sheet_answer[q+1].answer_num==my_test.test_question[q].question_num)
                        {
                            System.out.printf(" %d",my_test.test_question[q].score);
                            grade=grade+my_test.test_question[q].score;
                        }
                        else
                        {
                            System.out.printf(" 0");
                        }
                    }
                    System.out.printf("~%d",grade);
                    break;
                }
                else
                {
                    for(int q=0;q<question_number;q++)
                    {
                        if(delete_one!=my_test.test_question[q].question_num&&my_sheet.sheet_answer[q+1].answer_num==my_test.test_question[q].question_num)
                        {
                        System.out.printf("%s",my_test.test_question[q].question);
                        }
                        if(my_test.test_question[q].standardanswer.compareTo( my_sheet.sheet_answer[q+1].answer)==0&&delete_one!=my_test.test_question[q].question_num&&my_sheet.sheet_answer[q+1].answer_num==my_test.test_question[q].question_num)
                        {
                            System.out.printf("~%s~true\n",my_test.test_question[q].standardanswer);
                        }
                        else if(my_test.test_question[q].standardanswer.compareTo( my_sheet.sheet_answer[q+1].answer)!=0&&delete_one!=my_test.test_question[q].question_num&&my_sheet.sheet_answer[q+1].answer_num==my_test.test_question[q].question_num)
                        {
                            System.out.printf("~%s~false\n",my_sheet.sheet_answer[q+1].answer);
                        }
                        else if(delete_one==my_test.test_question[q].question_num&&my_sheet.sheet_answer[q+1].answer_num==my_test.test_question[q].question_num)
                        {
                            System.out.printf("the question %d invalid~0\n",delete_one);
                        }
                        if(my_sheet.sheet_answer[q+1].answer_num!=my_test.test_question[q].question_num||my_sheet.sheet_answer[q+1].answer_num!=my_test.test_question[q].question_num2)
                        {
                            System.out.printf("non-existent question~0\n");
                        }
                    }
                    System.out.printf("%s not found",answer_man);
                    break;
                }
            }
            }

else
{
System.out.printf("The test paper number does not exist");
}
}//答卷类的初始化与实例化
else
{
System.out.printf("wrong format:%s\n",information[i]);
}`
[1]首先根据题目对象的题号根据题号大小对整个题目类数组进行排序（从小到大），对答题类进行同样的操作。
[2]在对学生类的遍历循环中，判断答题人与学生类对象的name是否符合，如果符合进行操作[2],否则无输出。
[3]首先判卷是否有输入删除题号，若没有，直接进行[2]操作，反之，匹配题号与删除题号，若一致则输出"the question 2 invalid~0"，并将该题的题分改为0。
[4]用答卷类对试卷类进行匹配，如果回答与标准答案相同，则输出该题目+"~true"，并将学生得分grade加上该题的题分，否则+"false"。如果答题类出现了试卷类中未有的题号则输出"non-existent question~0",切得分为0；
[5]输出答题人的姓名，并输出学生类中name与答题人一致的对象的id，输出答题人每道题的得分，最后输出总分。
``
三.踩坑心得
（1）踩坑：答题判题程序-1中最开始不清楚需要匹配正确的字符串的格式，用极其简单且复杂的方法判断。
解决方法：使用正则表达式规定正确的格式，对每条字符串进行匹配操作。
数据：

源码：

测试结果：

（2）踩坑：答题判题程序-1中直接将字符串类型数据与整形数据进行比较，结果一直报错。
解决方法：使用Integer.parseInt(String)来进行字符串转化为int型的操作。
数据：

源码：

测试结果：

（3）踩坑：答题判题程序-2中不明白多个类的运用与多个类之间关系的处理，最开始知使用一个类。
解决方法：并使用好类之间的三个主要关系——关联、聚合、组合。如：Question类是Test类的一部分即聚合关系。
数据：。。。
源码：参考类设计图
测试结果：。。。
（4）踩坑：不理解程序的封装。
解决方法：get和set的使用。
数据：。。。
源码：

测试结果：。。。
（5）踩坑：答题判题程序-1中不知如何对各种字符串的分类，数组大小的确认以免浪费空间。
解决方法：使用charAt()，利用每条字符串的特征，以计算各种类型数据所需数组的大小，并且分别进行操作。
数据：

源码：

测试结果：

（6）踩坑：最开始在答题判题程序-2中大量使用了内部类，使得程序难以进行维护。
解决方法：使用外部类。
数据：。。。
源码：。。。
测试结果：。。。
（7）踩坑：答题判题程序-3中题目乱序输入，输出结果与预料不一样。
解决方法：利用题号对题目类数组进行排序（从小到大），利用答题号对答题类进行同样的操作。
数据：

源码：


测试结果：

（8）踩坑：答题判题程序-3中回答的题号在题目类数组中不存在和删除题目同时存在的情况下的结果混乱。
解决方法：添加一个题号2即num_2，进行两次匹配，用题号与题号2结合使用，来解决多种情况的问题。
数据：

 源码：

测试结果：

四.改进建议
目前还无法解决的问题：
（1）错误格式的信息，无效的题目引用
（2）单信息输入
（3）空白卷没有答案的试卷按正常试卷输出结果
（4）答案为空字符。按正常输入处理。
（5）消息、答案数据乱序输入+缺失的答案
（6）题目、答案数据乱序输入
改进建议：
（1）改用ArrayList或者Hashmap改进数据结构，仅仅用数组或者linkedlist在面对很多问题时难以解决甚至不能解决；
（2）在循环中嵌套多个循环，以防止乱序输入程序非零返回的问题
七.总结
（1）首先，这三题为近三周的主要任务，也是开始学习Java以来第一个比较耗时的编程任务，它们不仅仅考验了我们学生之前在C语言学习的成果。还在其中大量运用了我们在C语言中未学习到的知识如封装、正则表达式等等。

（2）其次，在这段时间里，我明显认识到了自己的不足不仅体现在学习能力上还体现在学习态度上，很多东西都是老师和同学指导以后才理解的，自主学习能力较少，急需改正。

（3）然后，在这几周中，我基本了解了Java编程的进本要求和形式。同时对于类的认识逐渐清晰正则表达式这一知识点有了更加深入的了解。

（4）此外，近几周我认识到了时间的重要性。在课程方面，建议学校可以试着调整课程的安排，让学生们在学习过程中可以尽可能的线下交流、共同讨论、一起克服难题。在作业方面，希望老师可以明确作业的要求，测试点的要求希望可以更加清晰，有的测试点自己错不知因，正不知原。在实验方面，希望每次实验能和作业一样是层层深入而不是给个大框架却在初期实现少量功能。

（5）最后，各种高级计算机语言有着许多的共同之处，一种计算机高级语言的掌握程度可以很大的影响到新的语言的学习。但是每种语言都具有自己语言的独特性，要想通过掌握一门语言而走遍天下实在有点儿戏。
在未来的Java学习中，要多去了解Java自身的特性如封装、多态等等，技多不压身，多门语言的精炼能够更好的提高我们自己的编程能力，并且学会看他人的博客多去接受更深一层的知识，感受来自来自电子计算机的浪漫。

答题判题系统的三次优化更多相关文章

今日报告-66

设置Windows10暂停更新3000天

AQS公平锁的流程

AMD锐龙7 7800X3D网游专项测试：竟比i9-13900KS强了15%

常用总线技术基本参数对比

探索图像数据中的隐藏信息：语义实体识别和关系抽取的奇妙之旅

设置Chrome浏览器自动升级

JavaScript – 小技巧 Tips

Winform无边框窗体实现拖动

STM32基础（一）

技术人的修炼---九五小庞

vue自定义事件用法及$emit

ODOO 科目配置4

sqlite 触发器 c#

postgresql在插入数据后怎么获取自增id

EF Core 的基本使用

error: failed to push some refs to 'https://github.com/*******/********.github.io.git'

欧拉降幂

编程语言能力对比

基于机器视觉的小车轨迹控制软件界面展示

随机推荐

C语言中的编译过程详解

step7 V5.x上的SCL

yolo --- 核心思想

【游记】CCPC 济南 2024 游记

AJAX & AXIOS-2024/11/1

验证码处理在自动化测试中的应用

一些学科笑话

NOIP2024模拟赛20 & 11.1 小记

20241101 数据结构与算法期中机试收获

Java，启动！

什么是IT技术

即将到来！

2024/11/1日 日志 关于JavaScript简介&引入方式 以及基础语法的学习

舍得-时间-工作是人的一生最重要的事情-自己要有私房钱-人的一生最重要的事情是书写自己的人生

2.TiUP 部署 DM 集群

原型模式的C++实现

python bytecode解析

09-XSS键盘监听、cookie窃取&文件上传绕过

ubuntu 24.04 部署 mysql 8.4.3 LTS

国标GB28181公网平台LiteGBS国标GB28181视频平台建筑工地无线视频联网监控系统方案

热门话题

Ethernaut Level 11: Elevator Attack and Blockchain Interaction

快速部署开源spug运维平台的Docker安装指南

驱动调试之printk的原理与使用

计算机思维模型及其应用

华为云发布代码大模型PanGu-Coder2，实现高效代码生成

Linux多硬盘数据存储和分区操作

构建高可用架构: 分层冗余与自动故障转移

LoRA：高效调参的大语言模型适应方法

《分布式系统的基本原理及互联网分层架构的本质》

Hadoop写流程解析

Java架构师的系统架构设计方法论中的规范要点

使用observeDOM解决BetterScroll插件在移动端无法滑动的问题

互联网一致性架构设计实践

高并发系统架构与水平扩展

混合应用的崛起：跨平台开发取代原生应用

  穗舟网 （www.seizhou.com）

本站除标明"本站原创"外所有文章版权归创作人所有，本站不承担任何法律责任和连带责任，如有冒犯请直接联系，我们将立即予以纠正并致歉。

Powered by WordPress  ·  v1.0.0-alpha