PTA三次作業

来源:https://www.cnblogs.com/xyxpta/p/18148919
-Advertisement-
Play Games

1.前言： 第一次作業難度較大，從無到有的設計，涉及到的主要類有Paper，Question，AnswerPaper，Main，主要題目方向為字元串判斷與字元串處理(提取有效信息)，判斷對錯算總分，配合一些Java自帶的數據結構如ArrayList即可快速解決問題，第一次作業是後面作業的基礎，需自行 ...


1.前言：
第一次作業難度較大，從無到有的設計，涉及到的主要類有Paper，Question，AnswerPaper，Main，主要題目方向為字元串判斷與字元串處理(提取有效信息)，判斷對錯算總分，配合一些Java自帶的數據結構如ArrayList即可快速解決問題，第一次作業是後面作業的基礎，需自行瞭解正則表達式等方法。第二次作業難度適中，題目在第一次作業前提下添加了試卷類，涉及較為複雜類引用，需要對類的引用有一定瞭解。第三次作業難度最高，在前兩次作業基礎上添加學生信息及刪除題號，還添加了許多錯誤提醒及錯誤提醒優先順序顯示。這三次作業的難度可以說是逐次遞增，需要學生在第一次作業建立良好的類結構，併在第二次作業中添加類，以及第三次作業給刪除的題目添加標記以執行語句都是難點。這三次PTA作業考察了學生構建程式框架的能力，以及正則表達式提取所需信息，ArrayList儲存內容等方面的知識。
2.設計與分析：
第一次作業：
只需用AnswerPaper判斷，Paper儲存Question數組。由於當時還未學習ArrayList，使用數組儲存，設計上採用兩個字元串數組，一個數組裝題目（題號與題目對應），一個數組裝寫的答案（題號與標準的答案對應），傳遞到AnswerPaper中進行比較。Question類封裝題目信息，包括題號、題目內容、標準答案、作答；最後再將Question類封裝進AnswerPaper類，其方法為判斷答案與標準答案是否相同，最後進行輸出。
建立Question類儲存數據

點擊查看源碼 

class Question{
    private int num;
    private String content;
    private String standard_answer;
    private String answer;
    private boolean result;
    public Question(){}
    public Question(int num,String content,String standard_answer,String answer,boolean result){
        this.num=num;
        this.content=content;
        this.standard_answer=standard_answer;
        this.answer=answer;
        this.result=result;
    }
    public String getStandard_Answer(){
        return standard_answer;
    }
    public void setStandard_Answer(String standard_answer){
        this.standard_answer=standard_answer;
    }
    public String getContent(){
        return content;
    }
    public void setContent(String content){
        this.content=content;
    }
    public int getNum(){
        return num;
    }
    public void setNum(int num){
        this.num=num;
    }
    public void setAnswer(String answer){
        this.answer=answer;
    }
    public String getAnswer(){
        return answer;
    }
    public void setResult(boolean result){
        this.result=result;
    }
    public boolean getResult(){
        return this.result;
    }
    public boolean TF(){
        if(standard_answer==answer)
        {
            result=true;
        }
        else
        {
            result=false;
        }
        return result;
    }
}
建立AnswerPaper類以便判斷
點擊查看源碼 
class AnswerPaper{
    private Paper paper;
    private Question []question=new Question[1000];
    public AnswerPaper(Paper paper,String str,int num){
        this.paper=paper;
        String answer1;
        boolean result;
        String strs[]=str.split(" #");
        for(int i=0;i<strs.length;i++)
        {
            String strs1[]=strs[i].split(":");
            strs1[1]=strs1[1].trim();
            answer1=strs1[1];
            if(answer1.equals(this.paper.getQuestionAnswer(i+1)))
            {
                result=true;
            }
            else
            {
                result=false;
            }
            Question que=new Question(i+1,paper.getQuestionContent(i+1),paper.getQuestionAnswer(i+1),answer1,result);
            question[i]=que;
        }
    }
    public String getPaperAnswer(int i){
        return question[i-1].getAnswer();
    }
    public String getPaperResult(int a){
        String str=String.valueOf(question[0].getResult());
        for(int i=1;i<a;i++)
        {
            str=str+" "+String.valueOf(question[i].getResult());
        }
        return str;
    }
}
建立Paper類以儲存Question數組，提取題目內容
點擊查看源碼 
class Paper{
    private int num;
    private Question []question=new Question[1000];
    private int flag=1;
    public Paper(){}
    public Paper(int num){
        this.num=num;
    }
    public void setNum(int num){
        this.num=num;
    }
    public int getNum(){
        return num;
    }
    public void setQuestion(String str){
        String strs[]=str.split(" #");
        String strs1[]=strs[0].split(":");
        strs1[1]=strs1[1].replaceAll(" ","");
        int i=Integer.parseInt(strs1[1]);
        String strs2[]=strs[1].split(":");
        strs2[1]=strs2[1].trim();
        String strs3[]=strs[2].split(":");
        strs3[1]=strs3[1].replaceAll(" ","");
        Question que=new Question(i,strs2[1],strs3[1],null,true);
        question[i-1]=que;
    }
    public String getQuestionAnswer(int i){
        return question[i-1].getStandard_Answer();
    }
    public String getQuestionContent(int i){
        return question[i-1].getContent();
    }
}
SourceMontor的生成報表如下

類圖如下

第二次作業：
第二次作業在第一次作業的基礎上增加了試卷和答卷，其中試卷中包括題目的序號以及分值。試卷中極有可能有多道題，這就導致可能會出現答案不全的情況（試卷中的題目並沒有全都被作答）。在輸出部分，第二次作業比第一次作業多了試卷滿分不是100分、答卷缺失部分答案、無效的試卷號。在輸入格式方面，第二次作業的格式與第一次作業的格式要求沒有變化，因為沒有錯誤要求，所以輸入的都為正確格式，正則表達式的作用也只是將輸入的字元串分成幾個部分。此次作業使用了類，但是並沒有遵守或運用單一職責原則、開閉原則、迪米特法則，且許多判定過程寫在了主方法中，而不是寫在類中作為類的方法，更沒有代理類。因為在敲之前，很多邏輯部分並沒有思考清楚，導致代碼出現了許多的冗餘及不必要的代碼，但又擔心刪掉那部分之後代碼無法正常運行，所以為了完成作業得到較高的分數就沒有修改。這次作業中，我深刻意識到了寫註釋的重要性。前幾次提交之後，我發現代碼的邏輯有些問題。但當我回頭看我的代碼的時候，我已經看不懂我原來的寫的內容了。一方面是因為，代碼更多的是面向過程而非面向對象，另一方面就是因為沒有寫註釋了。寫註釋不僅有益於在寫代碼過程中清晰自己的邏輯，更有益於改代碼過程中讀懂自己之前寫的代碼。

SourceMontor的生成報表如下：

可見代碼存在許多的不足（方法的功能較為單一、最複雜方法行的數量過高有待優化、代碼中的塊結構相對簡單、註釋少等），大多是由於基礎知識不扎實，但第二次作業是在第一次作業基礎上完成的，難度有所降低。在第一次作業基礎上，我將提取有效內容功能放在了main中，用上了ArrayList傳遞數據，將作答部分寫成新類——Answer——代碼如下：

點擊查看代碼 
class Answer{
    private String answer;
    private int grade;
    public Answer(String answer){
        this.answer=answer;
    }

    public String getAnswer(){
        return answer;
    }

    public void setGrade(int grade){
        this.grade=grade;
    }
    public int getGrade(){
        return grade;
    }
}
在Paper類中添加分數數組以求試卷總分——代碼如下：
點擊查看代碼 
class Paper{
    private int num;
    private int score_sum;
    private int question_sum;
    private ArrayList<Question> list = new ArrayList<>();
    private int score[];
    public Paper(int num,int questionnum[],int score[],ArrayList<Question> listQuestion)
    {
        this.num=num;
        this.score=score;
        this.question_sum=questionnum.length-1;
        for(int i=1;i<score.length;i++)
        {
            this.score_sum+=this.score[i];
        }
        for(int i=1;i<questionnum.length;i++)
        {
            for(Question t:listQuestion)
            {
                if(questionnum[i]==t.getNum())
                {
                    list.add(t);
                }
            }
        }
    }

    public ArrayList<Question> getList(){
        return list;
    }

    public int getSum()
    {
        return score_sum;
    }

    public int getNum(){
        return num;
    }

    public int getScore(int i){
        return score[i+1];
    }
}
減少了AnswerPaper功能，使該類的功能更明顯，更多在Main中實現——代碼如下：
點擊查看代碼 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ArrayList<Question> listQuestion = new ArrayList<>();
        ArrayList<Paper> listPaper = new ArrayList<>();
        ArrayList<AnswerPaper> listAnswerPaper = new ArrayList<>();
        String str=scanner.nextLine();
        while(!str.equals("end"))
        {
            if(str.indexOf("#N")!=-1)
            {
                String strs[]=str.split(" #");
                String strs1[]=strs[0].split(":");
                strs1[1]=strs1[1].replaceAll(" ","");
                int i=Integer.parseInt(strs1[1]);
                String strs2[]=strs[1].split(":");
                strs2[1]=strs2[1].trim();
                String strs3[]=strs[2].split(":");
                strs3[1]=strs3[1].replaceAll(" ","");
                Question question=new Question(i,strs2[1],strs3[1]);
                listQuestion.add(question);
            }
            if(str.indexOf("#T")!=-1)
            {
                String strs[]=str.split(" ");
                String strs1[]=strs[0].split(":");
                int questionnum[]=new int [strs.length];
                int score[]=new int [strs.length];
                int i=Integer.parseInt(strs1[1]);
                for(int j=1;j<strs.length;j++)
                {
                    String strs2[]=strs[j].split("-");
                    questionnum[j]=Integer.parseInt(strs2[0]);
                    score[j]=Integer.parseInt(strs2[1]);
                }
                Paper paper=new Paper(i,questionnum,score,listQuestion);
                listPaper.add(paper);
            }
            if(str.indexOf("#S")!=-1)
            {
                ArrayList<Answer> listAnswer = new ArrayList<>();
                String strs[]=str.split(" #");
                String strs1[]=strs[0].split(":");
                strs1[1]=strs1[1].replaceAll(" ","");
                int i=Integer.parseInt(strs1[1]);
                for(int j=1;j<strs.length;j++)
                {
                    String strs2[]=strs[j].split(":");
                    Answer answer=new Answer(strs2[1]);
                    listAnswer.add(answer);
                }
                AnswerPaper answerPaper=new AnswerPaper(i,listAnswer);
                listAnswerPaper.add(answerPaper);
            }
            str=scanner.nextLine();
        }
        for (int i = 0; i < listPaper.size(); i++) {
            if(listPaper.get(i).getSum()!=100)
            {
                System.out.println("alert: full score of test paper"+listPaper.get(i).getNum()+" is not 100 points");
            }
        }
        int flag=1;
        for(AnswerPaper r : listAnswerPaper)
        {
            flag=1;
            for (Paper p:listPaper) 
            {
                if(r.getNum()==p.getNum())
                {
                    flag=0;
                    for(int i = 0; i < p.getList().size()&& i < r.getList().size(); i++)
                    {
                        Question w=p.getList().get(i);
                        Answer x=r.getList().get(i);
                        System.out.print(w.getContent()+"~"+x.getAnswer()+"~");
                        if(w.getStandard_Answer().equals(x.getAnswer()))
                        {
                            System.out.println("true");
                            x.setGrade(p.getScore(i));
                            r.setSum(p.getScore(i));
                        }
                        else
                        {
                            System.out.println("false");
                            x.setGrade(0);
                        }
                    }
                    for(int i = 0; i < p.getList().size() - r.getList().size(); i++)
                    {
                        System.out.println("answer is null");
                    }
                    for(int i = 0; i < p.getList().size(); i++)
                    {
                        if(i < r.getList().size())
                        {
                            Answer x=r.getList().get(i);
                            System.out.print(x.getGrade());
                        }
                        else
                            System.out.print("0");
                        if(i!=p.getList().size()-1)
                            System.out.print(" ");
                        else
                            System.out.print("~");
                    }
                    System.out.println(r.getSum());
                }
            }
        }
        if(flag==1)
            System.out.println("The test paper number does not exist");
    }
}
class AnswerPaper{
    private int num;
    private int sum;
    private ArrayList<Answer> list = new ArrayList<>();
    public AnswerPaper(int num,ArrayList<Answer> listAnswer){
        this.num=num;
        for(Answer t:listAnswer)
        {
            list.add(t);
        }
    }

    public int getNum(){
        return num;
    }

    public ArrayList<Answer> getList(){
        return list;
    }

    public void setSum(int grade){
        this.sum+=grade;
    }

    public int getSum(){
        return sum;
    }
}
Question類用於儲存數據，基本不變，減少了未使用的get/set方法，簡化代碼——代碼如下：
點擊查看代碼 
class Question{
    private int num;
    private String content;
    private String standard_answer;

    public Question(int num,String content,String standard_answer){
        this.num=num;
        this.content=content;
        this.standard_answer=standard_answer;
    }

    public int getNum(){
        return num;
    }

    public String getContent(){
        return content;
    }

    public String getStandard_Answer(){
        return standard_answer;
    }
}

類圖如下：

第三次作業：
第三次作業結束了幾天，至今仍有心理陰影，心理路程依舊記憶猶新，不僅是正則表達式學習實踐每每出錯，難以改正，split的使用出現非零返回，耗費心力，而且刪減的過程也是困難重重（會在採坑心得內分析），我的得分很低，該代碼多用於避坑，辯證性看待分析。
第三次作業在第二次作業的基礎上增加了刪除題目和學生信息，這就使在輸出部分多了找不到學生信息以及題目被刪出，另外，作業中還增加了引用本來就不存在的題目等錯誤情況，並要求錯誤優先順序顯示。這次作業我做出了一部分改進，使代碼變得複雜度降低一些，且開始有意識的遵循或運用單一職責原則、開閉原則、迪米特法則。

  第三次作業增加了錯誤格式這一部分。我便沒有辦法像前兩次作業一樣只用split切割輸入語句，增加了Matcher和Pattern的運用。在運用錯誤格式這裡，我卡了很久，卡的測試點中錯誤表達式就占了兩種類型（8個點）。重寫了很久pattern.compile和輸入部分的代碼，後嘗試改回split，但效果不佳。感覺不是什麼技術問題、邏輯問題、理解問題或者設計問題，可能是做事不夠仔細認真，對正則表達式理解不夠徹底。

  第三次作業增加了Student類——代碼如下：
點擊查看代碼 
class Student{
    private String num;
    private String name;
    public Student(String num,String name){
        this.num=num;
        this.name=name;
    }
    public String getNum(){
        return num;
    }
    public String getName(){
        return name;
    }
}
用作鏈表的類儲存數據。嘗試在Paper類中添加判斷題目序號有效與否——代碼如下：
點擊查看代碼 
class Paper{
    private int num;
    private int score_sum;
    private int question_sum;
    private ArrayList<Question> list = new ArrayList<>();
    private int score[];
    private boolean haveque=true;
    public Paper(int num,int questionnum[],int score[],ArrayList<Question> listQuestion)
    {
        this.num=num;
        this.score=score;
        this.question_sum=questionnum.length-1;
        for(int i=1;i<score.length;i++)
        {
            this.score_sum+=this.score[i];
        }
        for(int i=1;i<questionnum.length;i++)
        {
            
            for(Question t:listQuestion)
            {
                if(questionnum[i]==t.getNum())
                {
                    list.add(t);
                    this.haveque=true;
                }
                else
                {
                    this.haveque=false;
                }
            }
        }
    }

    public ArrayList<Question> getList(){
        return list;
    }

    public int getSum()
    {
        return score_sum;
    }
    public boolean getHaveque()
    {
        return haveque;
    }
    public int getNum(){
        return num;
    }

    public int getScore(int i){
        return score[i+1];
    }
}
同時在Main中輸出是添加判斷條件——代碼如下：
點擊查看代碼 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ArrayList<Question> listQuestion = new ArrayList<>();
        ArrayList<Student> listStudent = new ArrayList<>();
        ArrayList<Paper> listPaper = new ArrayList<>();
        ArrayList<AnswerPaper> listAnswerPaper = new ArrayList<>();
        String str=scanner.nextLine();
        int num_of_cut=0;
        while(!str.equals("end"))
        {
            Pattern pattern = Pattern.compile("^#N:(.*)\\s#Q:(.*)\\s+#A:(.*)");
            Matcher matcher = pattern.matcher(str);
            Pattern pattern2 = Pattern.compile("^#T:(\\d+)(\\s+(\\d+-\\d+))*$");
            Matcher matcher2 = pattern2.matcher(str);
            Pattern pattern3 = Pattern.compile("^#S:(\\d+)\\s+(\\d+)(.*)");
            Matcher matcher3 = pattern3.matcher(str);
            Pattern pattern4 = Pattern.compile("^#X:(\\d+)\\s+(\\w+)(-\\d+\\s\\w+)*$");
            Matcher matcher4 = pattern4.matcher(str);
            Pattern pattern5 = Pattern.compile("^#D:N\\-(\\d+)$");
            Matcher matcher5 = pattern5.matcher(str);
            
            if(matcher.find())
            {
                String num=matcher.group(1);
                String que=matcher.group(2);
                String ans=matcher.group(3);
                int i=Integer.parseInt(num);
                Question question=new Question(i,que,ans);
                listQuestion.add(question);
                
            }
            else if(matcher2.find())
            {
                String num=matcher2.group(1);
                String text=matcher2.group(2);
                String strs[]=text.split("\\s+");
                int numofp=Integer.parseInt(num);
                int questionnum[]=new int [strs.length];
                int score[]=new int [strs.length];
                for(int j=1;j<strs.length;j++)
                {
                    String strs2[]=strs[j].split("-");
                    questionnum[j]=Integer.parseInt(strs2[0]);
                    score[j]=Integer.parseInt(strs2[1]);
                }
                Paper paper=new Paper(numofp,questionnum,score,listQuestion);
                listPaper.add(paper);
            }
            else if(matcher3.find())
            {
                ArrayList<Answer> listAnswer = new ArrayList<>();
                String num=matcher3.group(1);
                String nums=matcher3.group(2);
                String text=matcher3.group(3);
                String strs[]=text.split("\\s+#A:");
                int numofap=Integer.parseInt(num); 
                for(int j=1;j<strs.length;j++)
                {
                    String strs2[]=strs[j].split("-");
                    int num_of_que=Integer.parseInt(strs2[0]);
                    Answer answer=new Answer(num_of_que,strs2[1]);
                    listAnswer.add(answer);
                }
                AnswerPaper answerPaper=new AnswerPaper(numofap,nums,listAnswer);
                listAnswerPaper.add(answerPaper);
            }
            else if(matcher4.find())
            {
                String text1=matcher4.group(1);
                String text=matcher4.group(2);
                Student student=new Student(text1,text);
                listStudent.add(student);
                String text2=matcher4.group(3);
                if(text2!=null)
                {
                    String strs3[]=text2.split("-");
                    for (String part : strs3)
                    {
                        if (part.length() > 8)
                        {
                            String date = part.substring(0, 8);
                            String nameOrIdentifier = part.substring(8);
                            Student student2 = new Student(date, nameOrIdentifier);  
                            listStudent.add(student2);  
                        }
                    }
                }
            }
            else if(matcher5.find())
            {
                String num=matcher5.group(1);
                num_of_cut=Integer.parseInt(num);
            }
            else
            {
                System.out.println("wrong format:"+str);
            }
            str=scanner.nextLine();
        }
        for (int i = 0; i < listPaper.size(); i++) {
            if(listPaper.get(i).getSum()!=100)
            {
                System.out.println("alert: full score of test paper"+listPaper.get(i).getNum()+" is not 100 points");
            }
        }
        int flag=1;
        for(AnswerPaper r : listAnswerPaper)
        {
            flag=1;
            for (Paper p:listPaper) 
            {
                if(r.getNum()==p.getNum())
                {
                    flag=0;
                    for(int i = 0; i < p.getList().size()&& i < r.getList().size(); i++)
                    {
                        Question w=p.getList().get(i);
                        Answer x=r.getList().get(i);
                        if(w.getNum()==num_of_cut)
                        {
                            x.setGrade(0);
                            System.out.println("the question "+w.getNum()+" invalid~0");
                        }
                        else
                        {
                            if(p.getHaveque())
                            {
                                System.out.print(w.getContent()+"~"+x.getAnswer()+"~");
                                if(w.getStandard_Answer().equals(x.getAnswer()))
                                {
                                    System.out.println("true");
                                    x.setGrade(p.getScore(i));
                                    r.setSum(p.getScore(i));
                                }
                                else
                                {
                                    System.out.println("false");
                                    x.setGrade(0);
                                }
                            }
                            else
                            {
                                System.out.println("non-existent question~0");
                                x.setGrade(0);
                            }
                        }
                    }
                    for(int i = 0; i < p.getList().size() - r.getList().size(); i++)
                    {
                        System.out.println("answer is null");
                    }
                    int flag1=0;
                    for(int j = 0;j<listStudent.size();j++){
                        
                        if(r.getNums().equals(listStudent.get(j).getNum()))
                        {
                            System.out.print(r.getNums()+" "+listStudent.get(j).getName()+": ");
                            for(int i = 0; i < p.getList().size(); i++)
                            {
                                if(i < r.getList().size())
                                {
                                    Answer x=r.getList().get(i);
                                    System.out.print(x.getGrade());
                                }
                                else
                                    System.out.print("0");
                                if(i!=p.getList().size()-1)
                                    System.out.print(" ");
                                else
                                    System.out.print("~");
                            }
                            System.out.println(r.getSum());
                            flag1=1;
                            break;
                        }
                    }
                    if(flag1==0)
                    {
                        System.out.println(r.getNums()+" not found");
                    }
                }
            }
        }
        if(flag==1)
            System.out.println("The test paper number does not exist");
    }
}
其他類沒有思路去修改 SourceMontor的生成報表如下：

根據此報表，以下是改進方向：

減少方法調用：方法調用可能會導致代碼執行效率降低。嘗試合併或簡化方法調用，以減少方法的調用次數。
增加註釋：註釋嚴重不足，有很多的空間來添加註釋，從而提高代碼的可讀性和維護性。
優化類和介面：確保類的結構和介面的設計是合理的。避免過度耦合，儘量保持類的獨立性。
控制方法複雜度：平均每方法語句數過多，這可能表明某些方法過於複雜。嘗試分解這些方法為更小的、更專註的部分。
管理塊深度：最大塊深度為太大，這可能會影響代碼的性能。優化塊結構，使其更加扁平化，以減少執行時間。

類圖如下：

採坑心得：
第一次作業：在answer1.equals(this.paper.getQuestionAnswer(i+1))判斷時用equals不要直接用=，用等號過不了；
如圖：

              Question類可簡化出Answer類；

第二次作業：提取時用正則表達式會更加方便快捷；
第三次作業：這段代碼中，我將spilt改為固定數提取，因為我發現在測試用例中20201103 Tom-20201104 Jack-20201105 Www檢測不出空格，應該是無空格，測試用例中的空格不存在。

點擊查看代碼 
if(text2!=null)
                {
                    String strs3[]=text2.split("-");
                    for (String part : strs3)
                    {
                        if (part.length() > 8)
                        {
                            String date = part.substring(0, 8);
                            String nameOrIdentifier = part.substring(8);
                            Student student2 = new Student(date, nameOrIdentifier);  
                            listStudent.add(student2);  
                        }
                    }
                }
正則表達式中提取輸入鏈表儲存過程中提取會少數據，應該是Pattern.compile部分出錯； 如圖： 

             試卷題目數明顯少了。

改進建議：
第三次作業中，判定題目刪減時用HashMap會好很多。
正則表達式的Pattern.compile有待改準。
第二次作業中，輸入提取部分改用正則表達式提取。
寫代碼時提前畫好類圖以減少遺漏。

總結：
1.學到了：
Java是一門純粹的面向對象語言，因此理解類、對象、繼承、多態和封裝這些OOP概念至關重要。這些概念是Java編程的核心。
理論知識很重要，但沒有實踐是不夠的。嘗試編寫自己的程式，從簡單的“Hello World”開始，逐步增加難度。通過實際編碼，可以更好地理解概念，並學會如何解決問題。
Java擁有豐富的標準庫，提供了許多預製的類和介面，用於處理文件、網路、資料庫等。熟悉這些庫可以節省編寫代碼的時間，並提高代碼的質量。
編寫清晰、可讀的代碼比僅僅讓代碼工作更重要。遵循良好的編碼習慣，使用有意義的變數名和方法名，添加註釋，這些都是編寫可維護代碼的關鍵。
Java中有許多提前設計好的便捷方法供我們使用，多學習有利於減少冗餘代碼，如：HashMap與ArrayList等。
2.需要進一步學習及研究：
在寫代碼之前，要將整個代碼的邏輯部分設計好，避免出現寫到中途手忙腳亂的現象。
提升代碼的可復用性，註重設計中的開閉原則。
每次寫完代碼都會出現數組越界的情況，原因大概是思考邏輯時，無法面面俱到。多敲代碼以提升自己的思考能力以及邏輯能力。畫設計圖、類圖是個不錯的選擇。
對正則表達式理解、運用仍有不足。
3.建議：
希望老師能提前推薦更多用得上方法幫助作業完成。
希望測試點點明測試方向。
希望老師能演示類之間引用的例子，講方法時更深入些，講些多出現的特例。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 線程池的運行邏輯與你想象的不一樣，它是池族中的異類
    只要是 web 項目，程式都會直接或間接使用到線程池，它的使用是如此頻繁，以至於像空氣一樣，大多數時候被我們無視了。但有時候，我們會相當然地認為線程池與其它對象池（如：資料庫連接池）一樣，要用的時候向池子索取，用完後歸還給它即可。然後事實上，線程池獨樹一幟、鶴立雞群，它與普通的對象池就是不同。本文本 ...
  • ArcPy自動繪製大量地圖並設置地圖要素：Python
    本文介紹基於Python語言中ArcPy模塊，實現ArcMap自動批量出圖，並對地圖要素進行自定義批量設置的方法。 1 任務需求 首先，我們來明確一下本文所需實現的需求。 現有通過Python基於Excel數據加以反距離加權空間插值並掩膜圖層所繪製的北京市在2019年05月18日00時至23時（其中 ...
  • day18-網路編程（下）
    1. OSI 7層模型 OSI的7層模型對於大家來說可能不太好理解，所以我們通過一個案例來講解： 假設，你在瀏覽器上輸入了一些關鍵字，內部通過DNS找到對應的IP後，再發送數據時內部會做如下的事： 應用層：規定數據的格式。 "GET /s?wd=你好 HTTP/1.1\r\nHost:www.bai ...
  • web server apache tomcat11-14-CGI
    前言 整理這個官方翻譯的系列，原因是網上大部分的 tomcat 版本比較舊，此版本為 v11 最新的版本。 開源項目 從零手寫實現 tomcat minicat 別稱【嗅虎】心有猛虎，輕嗅薔薇。 系列文章 web server apache tomcat11-01-官方文檔入門介紹 web serv ...
  • Deep "Hello world!"
    目錄1. #include <stdio.h>2.int 整形數據類型3.main 函數4.printf 函數5.return 函數6.”{}”與“；” “Hellow world!"是初學者的第一份代碼，可以說所學萬物代碼之基礎。下麵看一下代碼是如何實現的： 代碼雖然簡潔，但是包含了許多C語言的知 ...
  • Python環境和PyCharm搭建教程
    Python的下載安裝和環境搭建，以及python的IDE工具PyCharm搭建及常用配置教程，可以讓新人快速上手python的使用。 ...
  • Java常用的十大開源工具類庫總結
    以下是個人總結的Java常用的十大開源工具類庫，根據具體需求和項目，可以選擇合適的工具類庫來提高開發效率。1. Apache Commons：Apache Commons是一個開源的工具類庫，提供了大量常用的工具類和組件，如StringUtils、IOUtils、CollectionUtils等。2 ...
  • MySQL-06.索引的數據結構
    1.為什麼使用索引 索引是存儲引擎用於快速找到數據記錄的一種數據結構，就好比一本書的目錄部分，通過目錄中找到對應文章的頁碼，便可快速定位到需要的文章。MySQL中的索引也是一樣的道理，進行數據查找時，首先查看查詢條件是否命中某條索引，符合則通過索引查找相關數據，如果不符合則需要全表掃描，即需要一條條 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類