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
private String allPaper;//存放每個問題
private int paperNum;
public ArrayList
public 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
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
LinkedList
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
ArrayList
Delete delete=new Delete();
StuMessage stu=new StuMessage();
AnswerPaper answerpaper;
Question question;
int i=0,m=0;
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
public 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
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
public ArrayList
public 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.對於實驗課來說，是讓我們對一些方法和運用更加熟練，加強我們的實踐能力，讓我們在作業的完成上不會對於一些基礎語法方面產生錯誤，實驗是必要的，多的建議就是實驗是一個星期兩節課就已經足夠。