小白的PTA前三次题目总结

目录

• PTA前三次题目总结
  • 1.前言
  • 2.设计与分析
    • 题目集一 7.5 答题判题程序一
      • 设计分析：
      • UML类图：
      • 部分源码：
      • 复杂度分析：
    • 题目集二 7.4 答题判题程序二
      • 设计分析：
      • UML类图：
      • 部分源码：
      • 复杂度分析：
    • 题目集三 7.3 答题判题程序三
      • 设计分析：
      • UML类图：
      • 部分源码：
      • 复杂度分析：
  • 3.踩坑心得
  • 4.改进建议
  • 5.总结

PTA前三次题目总结

1.前言

1.题目集知识点主要涉及类的设计和实现、构造方法的使用、成员变量和访问器/修改器的定义、方法的重写（toString方法）、对象的创建和调用方法，接口实现、集合操作、封装与访问控制、输入输出，类间关系、逻辑判定、信息处理、字符串操作、数据结构设计等。总体来说，本次题目集对于我们来说是一个综合性的练习，涵盖了信息处理、字符串操作、逻辑判断、数据结构设计等多个方面的知识和技能。题量适中，但需要考虑到各种异常情况的处理。

2.设计与分析

题目集一 7.5 答题判题程序一

设计分析：

1. Question类：表示一个问题，包含问题编号、内容和标准答案。提供了方法来获取问题的信息和检查给定答案是否正确。
2. Exam类：表示一个考试，包含了多个问题。通过HashMap来存储问题，键为问题编号，值为Question对象。提供了添加问题、检查答案是否正确等方法。
3. AnswerSheet类：表示一个答题卡，包含了考试对象、学生的答案和判断结果。提供了添加答案、判断答案是否正确、打印问题和答案以及打印判断结果的方法。
4. Main类：包含主程序逻辑，通过Scanner从控制台读取输入，创建考试对象和答题卡对象，并进行答题判断和输出结果。

UML类图：

部分源码：

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Step 1: Read the number of questions
        int questionCount = scanner.nextInt();
        scanner.nextLine(); // Consume the rest of the line

        // Step 2: Read the questions and create the exam
        Exam exam = new Exam();
        for (int i = 0; i < questionCount; i++) {
            String line = scanner.nextLine();
            String[] parts = line.split("#");
            int number = Integer.parseInt(parts[1].split(":")[1].trim());
            String questionText = parts[2].split(":")[1].trim();
            // 提取标准答案，去除#A:
            String standardAnswer = parts.length > 3 ? parts[3].split(":")[1].trim() : "";
            Question question = new Question(number, questionText, standardAnswer);
            exam.addQuestion(question);
        }

        // Step 3: Read the answers and create the answer sheet
        AnswerSheet answerSheet = new AnswerSheet(exam);
        String userAnswersLine = scanner.nextLine();
        String[] userAnswers = userAnswersLine.split("#A:");
        for (int i = 0; i < userAnswers.length; i++) {
            userAnswers[i] = userAnswers[i].trim();

        }
        for(int i=1;i<userAnswers.length;i++){
        answerSheet.addAnswer(i-1, userAnswers[i]);
        }
        answerSheet.judgeAnswers();
        answerSheet.printQuestionsAndAnswers();
        answerSheet.printJudgingResults();
    }
}

复杂度分析：

Method	CogC	ev(G)	iv(G)	v(G)
com.nchu.oop1.AnswerSheet.AnswerSheet(Exam)	0	1	1	1
com.nchu.oop1.AnswerSheet.addAnswer(int, String)	2	1	1	3
com.nchu.oop1.AnswerSheet.judgeAnswers()	1	1	2	2
com.nchu.oop1.AnswerSheet.printJudgingResults()	5	1	3	4
com.nchu.oop1.AnswerSheet.printQuestionsAndAnswers()	3	1	3	3
com.nchu.oop1.Exam.Exam()	0	1	1	1
com.nchu.oop1.Exam.addQuestion(Question)	0	1	1	1
com.nchu.oop1.Exam.getQuestionCount()	0	1	1	1
com.nchu.oop1.Exam.getQuestions()	0	1	1	1
com.nchu.oop1.Exam.isCorrectAnswer(int, String)	1	2	2	2
com.nchu.oop1.Main.main(String[])	5	1	5	5
com.nchu.oop1.Question.Question(int, String, String)	0	1	1	1
com.nchu.oop1.Question.getContent()	0	1	1	1
com.nchu.oop1.Question.getNumber()	0	1	1	1
com.nchu.oop1.Question.getStandardAnswer()	0	1	1	1
com.nchu.oop1.Question.isCorrectAnswer(String)	0	1	1	1

题目集二 7.4 答题判题程序二

设计分析：

1. Question类：表示一个问题，包含问题编号、内容和答案。提供了方法来获取问题的信息。
2. TestPaper类：表示一套试卷，包含试卷编号、题目号和分数的映射关系，以及试卷总分和题目列表。提供了添加题目和获取试卷信息的方法。
3. AnswerSheet类：表示一个答题卡，包含答题卡编号、学生答案和总分。提供了添加答案和获取答题卡信息的方法。
4. Main类：包含了主程序逻辑，包括读取输入、处理答案并输出结果。在读取输入时，使用正则表达式匹配不同类型的输入行，分别创建问题、试卷和答题卡对象。在处理答案时，根据学生答案和标准答案比对得分，并输出每道题的结果和总分。
5. 逻辑分析：在处理答案时，代码会检查每套试卷的总分是否为100分，如果不是则会输出警告信息。然后根据学生答案和标准答案比对得分，输出每道题的结果和总分。还包括一些边界情况的处理，如学生未答题的情况。

UML类图：

部分源码：

public class Main {
    private List<Question> questions;
    private List<TestPaper> testPapers;
    private List<AnswerSheet> answerSheets;

    public Main() {
        this.questions = new ArrayList<>();
        this.testPapers = new ArrayList<>();
        this.answerSheets = new ArrayList<>();
    }

    public void readInput() {
        Scanner scanner = new Scanner(System.in);
        String line;
        Pattern questionPattern = Pattern.compile("#N:(\\d+) #Q:(.+) #A:(\\d+)\\s?");
        Pattern testPaperPattern = Pattern.compile("#T:(\\d+) (\\d+-\\d+\\s?)+");
        Pattern answerPattern = Pattern.compile("#S:(\\d+) (#A:(?<ans>\\d+)\\s?)+");

        while (!(line = scanner.nextLine()).equals("end")) {
            Matcher questionMatcher = questionPattern.matcher(line);
            Matcher testPaperMatcher = testPaperPattern.matcher(line);
            Matcher answerMatcher = answerPattern.matcher(line);

            if (questionMatcher.find()) {
                int number = Integer.parseInt(questionMatcher.group(1));
                String content = questionMatcher.group(2);
                String answer = questionMatcher.group(3);
                questions.add(new Question(number, content, answer));
            }
            else if (testPaperMatcher.find()) {
                int paperNumber = Integer.parseInt(testPaperMatcher.group(1));
                TestPaper testPaper = new TestPaper(paperNumber);
                String[] pairs = testPaperMatcher.group(0).split(" ");
                for (int i = 1; i < pairs.length; i++) {
                    String pair = pairs[i];
                    String[] parts = pair.split("-");
                    int questionNumber = Integer.parseInt(parts[0]);
                    int score = Integer.parseInt(parts[1]);
                    testPaper.addQuestion(questionNumber, score);
                }
                testPapers.add(testPaper);
            }
            else if (answerMatcher.find()) {
                int paperNumber = Integer.parseInt(answerMatcher.group(1));
                String[] answers = line.split("#A:");
                AnswerSheet answerSheet = new AnswerSheet(paperNumber);
                for (int i = 1; i < answers.length; i++) {
                    answerSheet.addAnswer(answers[i].trim());
                }
                answerSheets.add(answerSheet);
            }
         }
    }


    public void processAnswers() {
        int y=0;

        for (TestPaper tp : testPapers) {
            if (tp.getallscore() != 100 ) {
                tp.flag++;
                System.out.println("alert: full score of test paper" + tp.getPaperNumber() + " is not 100 points");
            }
        }
        for (AnswerSheet answerSheet : answerSheets) {
            List<String> results = new ArrayList<>();
            List<Integer> score = new LinkedList<>();
            int totalScore = 0;
            int questionScore;
            List<String> answers = answerSheet.getAnswers();

            TestPaper testPaper = null;
            for (TestPaper t : testPapers) {
                if (t.getPaperNumber() == answerSheet.getPaperNumber()) {
                    testPaper = t;
                    //t.flag++;
                    break;
                }
            }
            if (testPaper != null) {
                for (int j = 0; j < answers.size(); j++) {
                    String answer = answers.get(j);
                    int questionNumber = testPaper.getQuestionNums().get(j);
                    Question question = null;
                    for (Question q : questions) {
                        if (q.getNumber() == questionNumber) {
                            question = q;
                            break;
                        }
                    }
                    if (question != null) {
                        if (question.getAnswer().equals(answer)) {
                             questionScore = testPaper.getQuestions().get(questionNumber);
                            totalScore+=questionScore;


                            results.add(question.getContent() + "~" + answer + "~true");
                            score.add(questionScore);
                        } else {
                            results.add(question.getContent() + "~" + answer + "~false");
                            score.add(0);
                        }
                    }
                }
                if(answerSheet.getAnswers().size()<testPaper.getQuestionNums().size()){
                    for(int h=0;h<testPaper.getQuestionNums().size()-answerSheet.getAnswers().size();h++){
                        results.add("answer is null");
                        score.add(0);
                    }
                }
                answerSheet.setTotalScore(totalScore);

                System.out.println(String.join("\n", results));
                for (int j = 0; j < score.size(); j++) {
                    Integer i = score.get(j);
                    System.out.printf("%d", i);
                    if(j<score.size()-1){
                        System.out.printf(" ");
                    }
                }

                System.out.printf("~%d", answerSheet.getTotalScore());
                if(y< answerSheets.size()-1){
                    System.out.println();
                }
            }
            else{
                System.out.println("The test paper number does not exist");
            }

        }
    }

    public static void main(String[] args) {
        Main examSystem = new Main();
        examSystem.readInput();
        examSystem.processAnswers();
    }
}

复杂度分析：

Method	CogC	ev(G)	iv(G)	v(G)
com.nchu.oop2.AnswerSheet.AnswerSheet(int)	0	1	1	1
com.nchu.oop2.AnswerSheet.addAnswer(String)	0	1	1	1
com.nchu.oop2.AnswerSheet.getAnswers()	0	1	1	1
com.nchu.oop2.AnswerSheet.getPaperNumber()	0	1	1	1
com.nchu.oop2.AnswerSheet.getTotalScore()	0	1	1	1
com.nchu.oop2.AnswerSheet.setTotalScore(int)	0	1	1	1
com.nchu.oop2.Main.Main()	0	1	1	1
com.nchu.oop2.Main.main(String[])	0	1	1	1
com.nchu.oop2.Main.processAnswers()	51	8	15	17
com.nchu.oop2.Main.readInput()	11	1	7	7
com.nchu.oop2.Question.Question(int, String, String)	0	1	1	1
com.nchu.oop2.Question.getAnswer()	0	1	1	1
com.nchu.oop2.Question.getContent()	0	1	1	1
com.nchu.oop2.Question.getNumber()	0	1	1	1
com.nchu.oop2.TestPaper.TestPaper(int)	0	1	1	1
com.nchu.oop2.TestPaper.addQuestion(int, int)	0	1	1	1
com.nchu.oop2.TestPaper.getPaperNumber()	0	1	1	1
com.nchu.oop2.TestPaper.getQuestionNums()	0	1	1	1
com.nchu.oop2.TestPaper.getQuestions()	0	1	1	1
com.nchu.oop2.TestPaper.getallscore()	0	1	1	1

题目集三 7.3 答题判题程序三

设计分析：

1. Question类：表示一个问题，包含问题编号、内容和答案。提供了方法来获取问题的信息。
2. TestPaper类：表示一套试卷，包含试卷编号、题目号和分数的映射关系，以及试卷总分和题目列表。提供了添加题目和获取试卷信息的方法。
3. AnswerSheet类：表示一个答题卡，包含试卷编号、学生编号、学生答案和总分。提供了添加答案和获取答题卡信息的方法。
4. Student类：表示学生信息，包含学生编号和姓名的映射关系。提供了添加学生信息和获取学生信息的方法。
5. Delete类：用于存储要删除的问题编号。
6. Main类：包含了主程序逻辑。
   • 在 readInput 方法中，通过正则表达式匹配输入行的格式，分别创建问题、试卷、答题卡、学生信息和要删除的问题对象。
   • 在 processAnswers 方法中，处理答题卡的逻辑，包括计算得分、输出结果和处理删除的问题。还包括一些边界情况的处理，如未找到学生信息和试卷信息等。

UML类图：

部分源码：

public class Main {
    private List<Question> questions;
    private List<TestPaper> testPapers;
    private List<AnswerSheet> answerSheets;
    private Student students;
    private List<Delete> deletes;
    public Main() {
        this.questions = new ArrayList<>();
        this.testPapers = new ArrayList<>();
        this.answerSheets = new ArrayList<>();
        //this.students=new ArrayList<>();
        this.deletes=new ArrayList<>();
    }
    int b=0;
    public void readInput() {
        Scanner scanner = new Scanner(System.in);
        String line;
        Pattern questionPattern = Pattern.compile("^#N:(\\d+) #Q:(.+) #A:(.+)$");
        Pattern testPaperPattern = Pattern.compile("^#T:(\\d+)( \\d+-\\d+)*$");
        Pattern answerPattern = Pattern.compile("^#S:(\\d+) (\\d+)( #A:(?<ans>\\d+-[^#]*))*$");
        Pattern studentPattern= Pattern.compile("^#X:(\\d+ \\S+-?)*$");
        Pattern deletePattern= Pattern.compile("^#D:N-(\\d+)$");
        while (!(line = scanner.nextLine()).equals("end")) {
            line = line.trim();
            Matcher questionMatcher = questionPattern.matcher(line);
            Matcher testPaperMatcher = testPaperPattern.matcher(line);
            Matcher answerMatcher = answerPattern.matcher(line);
            Matcher studentMatcher= studentPattern.matcher(line);
            Matcher deleteMatcher=deletePattern.matcher(line);
            if (questionMatcher.find()) {
                int number = Integer.parseInt(questionMatcher.group(1));
                String content = questionMatcher.group(2).trim();
                String answer = questionMatcher.group(3);
                questions.add(new Question(number, content, answer));
            }
            else if (testPaperMatcher.find()) {
                int paperNumber = Integer.parseInt(testPaperMatcher.group(1));
                TestPaper testPaper = new TestPaper(paperNumber);
                String[] pairs = testPaperMatcher.group(0).split(" ");
                for (int i = 1; i < pairs.length; i++) {
                    String pair = pairs[i];
                    String[] parts = pair.split("-");
                    int questionNumber = Integer.parseInt(parts[0]);
                    int score = Integer.parseInt(parts[1]);
                    testPaper.addQuestion(questionNumber, score);
                }
                testPapers.add(testPaper);
            }
            else if (answerMatcher.find()) {

                int paperNumber = Integer.parseInt(answerMatcher.group(1));
                int studentNumber=Integer.parseInt(answerMatcher.group(2));
                String[] answers = line.split("#A:");
                AnswerSheet answerSheet = new AnswerSheet(paperNumber,studentNumber);
                for (int i = 1; i < answers.length; i++) {
                    String []ans=answers[i].split("-");

                    answerSheet.addAnswer(Integer.valueOf(ans[0]),ans[1]);
                }
                if(!testPapers.isEmpty()) {
                    answerSheets.add(answerSheet);
                }
                else{
                    b++;
                }
            }
            else if (studentMatcher.find()) {
                Student student=new Student();
                String []x=studentMatcher.group(0).split("#X:");
                String[] pairs = x[1].split("-");
                for (int i = 0; i < pairs.length; i++) {
                    String pair = pairs[i];
                    String[] parts = pair.split(" ");
                    int Number = Integer.parseInt(parts[0]);
                    String name = parts[1];
                    student.addStudent(Number, name);
                }

                students=student;
            }
            else if (deleteMatcher.find()) {
                Delete delete=new Delete();
                int a= Integer.parseInt(deleteMatcher.group(1));
                delete.adddeletequestion(a);
                deletes.add(delete);
            }
            else{
                System.out.println("wrong format:"+line);
            }
        }
    }


    public void processAnswers() {
        int y = 0;
        for (TestPaper tp : testPapers) {
            if (tp.getallscore() != 100) {
                System.out.println("alert: full score of test paper" + tp.getPaperNumber() + " is not 100 points");
            }
        }

        for (Delete de : deletes) {
            for (Question qu : questions) {
                if (de.getDeleteQuestion() == qu.getNumber()) {
                    qu.flag = 1;
                }
            }
        }

        List<Question> deletequestion = new ArrayList<>();
        if(!answerSheets.isEmpty()){
            for (AnswerSheet answerSheet : answerSheets) {
                List<Integer> score = new LinkedList<>();
                int totalScore = 0;
                int questionScore;
                List<Integer> answernums = answerSheet.getAnswernums();

                TestPaper testPaper = null;
                for (TestPaper t : testPapers) {
                    if (t.getPaperNumber() == answerSheet.getPaperNumber()) {
                        testPaper = t;
                        break;
                    }
                }


                int c = 0;
                if (testPaper != null) {
                    for (int j = 0; j < testPaper.getQuestionNums().size(); j++) {
                        int t = 0;
                        for (int k = 0; k < answernums.size(); k++) {
                            // 前面加ifelse结构判断答案顺序号是否等于j；
                            if (answernums.get(k) == j + 1) {
                                t = 1;
                                c = k;
                                break;
                            }
                        }
                        if (t != 0) {
                            String answer = answerSheet.getAnswers().get(answernums.get(c)).trim();
                            int questionNumber = testPaper.getQuestionNums().get(j);
                            Question question = null;
                            for (Question q : questions) {
                                if (q.getNumber() == questionNumber) {
                                    question = q;
                                    break;
                                }
                            }

                            if (question != null) {
                                if (question.flag == 0) {
                                    if (question.getAnswer().equals(answer)) {
                                        questionScore = testPaper.getQuestions().get(questionNumber);
                                        totalScore += questionScore;
                                        System.out.println(question.getContent() + "~" + answer + "~true");
                                        score.add(questionScore);
                                    } else {
                                        System.out.println(question.getContent() + "~" + answer + "~false");
                                        score.add(0);
                                    }
                                } else {
                                    deletequestion.add(question);
                                    score.add(0);
                                }
                            }
                            //加non-existent question~0;且score.add(0);
                            else {
                                System.out.println("non-existent question~0");
                                score.add(0);
                            }
                        } else {
                            System.out.println("answer is null");
                            score.add(0);
                        }

                    }

                    answerSheet.setTotalScore(totalScore);

                    for (int q = 0; q < deletequestion.size(); q++) {
                        System.out.println("the question " + deletequestion.get(q).getNumber() + " invalid~0");
                    }

                    int studentnum = 0; //添加学号审查
                    for (int num : students.getStudentNums()) {
                        if (num == answerSheet.getStudentNumber()) {
                            studentnum = num;
                        }
                    }
                    if (studentnum != 0) {
                        System.out.print(studentnum + " " + students.getStudents().get(studentnum) + ": ");
                        for (int j = 0; j < score.size(); j++) {
                            Integer i = score.get(j);
                            System.out.printf("%d", i);
                            if (j < score.size() - 1) {
                                System.out.printf(" ");
                            }
                        }

                        System.out.printf("~%d", answerSheet.getTotalScore());
                        if (y < answerSheets.size() - 1) {
                            System.out.println();
                        }
                    } else {
                        System.out.println(answerSheet.getStudentNumber() + " not found");
                    }
                } else {
                    System.out.println("The test paper number does not exist");
                }

            }
        }
        else{
            for(int i=0;i<b;i++){
                System.out.println("The test paper number does not exist");
            }
        }
    }



    public static void main(String[] args) {
        Main examSystem = new Main();
        examSystem.readInput();
        examSystem.processAnswers();
    }
}

复杂度分析：

Method	CogC	ev(G)	iv(G)	v(G)
com.nchu.oop3.AnswerSheet.AnswerSheet(int, int)	0	1	1	1
com.nchu.oop3.AnswerSheet.addAnswer(Integer, String)	0	1	1	1
com.nchu.oop3.AnswerSheet.getAnswernums()	0	1	1	1
com.nchu.oop3.AnswerSheet.getAnswers()	0	1	1	1
com.nchu.oop3.AnswerSheet.getPaperNumber()	0	1	1	1
com.nchu.oop3.AnswerSheet.getStudentNumber()	0	1	1	1
com.nchu.oop3.AnswerSheet.getTotalScore()	0	1	1	1
com.nchu.oop3.AnswerSheet.setTotalScore(int)	0	1	1	1
com.nchu.oop3.Delete.Delete()	0	1	1	1
com.nchu.oop3.Delete.adddeletequestion(int)	0	1	1	1
com.nchu.oop3.Delete.getDeleteQuestion()	0	1	1	1
com.nchu.oop3.Main.Main()	0	1	1	1
com.nchu.oop3.Main.main(String[])	0	1	1	1
com.nchu.oop3.Main.processAnswers()	118	12	23	28
com.nchu.oop3.Main.readInput()	21	1	11	11
com.nchu.oop3.Question.Question(int, String, String)	0	1	1	1
com.nchu.oop3.Question.getAnswer()	0	1	1	1
com.nchu.oop3.Question.getContent()	0	1	1	1
com.nchu.oop3.Question.getNumber()	0	1	1	1
com.nchu.oop3.Student.Student()	0	1	1	1
com.nchu.oop3.Student.addStudent(int, String)	0	1	1	1
com.nchu.oop3.Student.getStudentNums()	0	1	1	1
com.nchu.oop3.Student.getStudents()	0	1	1	1
com.nchu.oop3.TestPaper.TestPaper(int)	0	1	1	1
com.nchu.oop3.TestPaper.addQuestion(int, int)	0	1	1	1
com.nchu.oop3.TestPaper.getPaperNumber()	0	1	1	1
com.nchu.oop3.TestPaper.getQuestionNums()	0	1	1	1
com.nchu.oop3.TestPaper.getQuestions()	0	1	1	1
com.nchu.oop3.TestPaper.getallscore()	0	1	1	1

3.踩坑心得

作为一个Java小白，在编写这些代码时常常会遇到以下一些常见的坑：

1. 输入错误：在使用Scanner类获取用户输入时，需要确保输入的格式和数据类型与代码中的期望一致，否则可能会导致运行时错误或逻辑错误。
2. 数组和集合越界：在使用数组或集合时，需要注意索引的范围，避免越界访问。特别是在使用数组时，要确保数组的长度足够存储数据，以防止IndexOutOfBoundsException异常。
3. 逻辑错误和条件判断：在编写条件语句时，要确保逻辑正确，包括条件的顺序、条件的组合和逻辑运算符的正确使用。要特别注意条件的边界情况和特殊情况，确保代码能正确处理各种情况。
4. 类和对象的使用：在创建和使用类和对象时，要注意类的构造方法、属性和方法的正确使用。特别是在使用类的方法和属性之前，要确保对象的状态正确，并且属性赋值和方法调用的顺序正确。
5. 字符串处理：在对字符串进行操作时，要注意字符串的不可变性，即字符串的值无法修改，每次操作都会创建一个新的字符串对象。且对于字符串格式要求尽量用正则表达式判定合法。
6. 规范和风格：在编写代码时，要注意遵循编码规范和良好的编程风格，如使用有意义的变量名、适当的缩进和注释等。这有助于提高代码的可读性和可维护性。
   这些是我作为初学者在编写Java代码时常见的一些问题和坑，希望通过接下来跟着段老师的学习不断去完善，进步，争取踩过的坑不会再犯。

4.改进建议

在对字符串进行操作时，对于频繁的字符串操作，应该使用StringBuilder或StringBuffer类来提高效率。

对于代码异常情况，使用try-catch语句块来捕获和处理异常，以保证程序的稳定性和可靠性。

通过继承，多态进一步完善判定逻辑。如多选题判定。

深入学习面向对象编程（OOP）的原理和概念，理解如何设计和组织类、对象之间的关系。

学习常用的类和库，如java.util、java.io等，并实践使用它们来解决实际问题。

5.总结

通过本阶段的三次题目集的练习，我学会了使用List和Map等数据结构来处理和存储数据。这些数据结构在不同的情境下具有不同的优势，需要根据实际需求选择适当的数据结构。学会了使用增强for循环和if-else条件语句来实现程序的控制流程，包括遍历数据、判断条件和执行不同的操作。学会了创建类、定义属性和方法，以及使用类创建对象并操作对象的属性和方法。学会了使用字符串操作的方法，如分割、替换和拼接字符串，以及比较字符串和提取子字符串。

需要进一步学习和研究的地方包括：异常处理：在给定的代码示例中，并未完全处理输入错误或无效数据的情况。学习如何使用try-catch块来捕获和处理异常，以提高程序的健壮性。更多的数据结构和算法：除了示例中涉及到的数据结构，还有许多其他的数据结构和算法可供学习和探索。了解不同的数据结构和算法可以帮助我更高效地解决问题。面向对象编程原则：学习如何设计良好的类和对象，并遵循面向对象编程的原则，如继承和多态。这将使代码更加可维护、可扩展和可重用。更多的Java核心概念和库：继续学习Java的核心概念，如继承、多态、接口等，并了解常用的Java库和框架，如集合框架、IO操作、日期时间处理等。

总体而言，我已经掌握了一些Java编程的基础知识和技巧，但仍有许多内容需要进一步学习和研究。通过不断练习、听讲，阅读文档和参考优秀的代码示例，我相信可以不断提升自己的编程能力和解决问题的能力。