标签：总结题目 String int num OOP score public

一、前言

介绍本篇博客的大致内容、写作目的、意义等

本篇博客介绍如何使用Java语言基础和算法来解决题目问题，在此基础上进行对最近Java编程语言学习的总结

题目的难度为Java入门，主要考察类的设计与创建、对象的使用、数组的基本使用、关联类、结构设计等一些基础算法以及一些自学内容

二、作业介绍

展示作业题目，并梳理算法思路

题目内容

前三次PTA作业共12大题，本篇博客将挑选其中几道典型题目进行举例与分析，题目分别考查了：

类的设计与创建，题目（1）如图：

类数组的基本使用，题目（2）如图：

数组的排序与查找，题目（3）如图：

等一些基础题型，以及空间结构较复杂的题型——包含多个知识点，题目（4）如图：

答题判题程序 题目组共有三题，其中，上图的 * 答题判题程序-3* 是对 答题判题程序-1 和 答题判题程序-2 的增补和迭代。因此，下面内容将以本题为侧重点展开分析与总结，其他基础题将简略带过

三、算法与代码

展示个人解决题目的算法思路以及答案

算法大纲

题目（1）：

本题需要创建：

风扇类
class Fan
，包含：
- 三个速度等级常量—SlOW=1、MEDIUM=2、FAST=3
- 整型—speed（速度）
- 布尔型—on（开关：true=开/false=关）
- 双精度浮点型—radius（半径）
- 字符串型—color（颜色）

用顺序结构进行处理，修改输出格式后即可

题目（2）：

本体需要创建：

学生类
class Student
，包含：
- 字符串型—num（学号）
- 字符串型—name（姓名）
- 双精度浮点型—chinese（语文成绩）
- 双精度浮点型—math（数学成绩）
- 双精度浮点型—physic（物理成绩）
- 方法—getsum()（计算总分）
- 方法—getaverage()（计算平均分）
- 方法—printscore()（按格式输出）

类数组s[ ]——存放学生信息数据

用循环结构收集输入信息，按输出格式后即可

题目（3）：

本题需要创建：

手机类
class MobilePhone
，包含：
- 字符串型—type（型号）
- 整型—price（价格）

比较器接口class Comparable，分析价格大小，返回对应关系

数组列表List[MobilePhone] list——存放手机信息数据

用循环结构收集输入信息，遍历初始List，遍历使用比较器后的List，循环顺序查找手机后输出即可

题目（4）：

Tips：

1、题目输入按照一定格式规律，因此可以运用正则表达式来高效处理输入数据，且处理输入时运用while( input.hasNextLine() ){ }循环，逐行收集输入信息，知道该行字符串为end时退出循环

2、在审阅题目（下两图）时，可以发现试卷信息、答卷信息格式较其他输入不同，多个【题目】—【分值】/【答题顺序】-【答案】共用一个【试卷编号】/【答卷编号】，即输入信息有阶级关系，因此需要在试卷类和答卷类中额外创建一个集合来存放和引用输入信息。而集合(Linked)Hashmap的特点适合这种格式，因此将会使用 Hashmap 和 LinkedHashMap（相关特点在自学内容中）

3、题目输出的错误提示较多且有优先级顺序输出，所以做题之前应做好输出提示的优先级排序，优先级越高的代码块应越靠前/在越外层的循环

本题需要创建：

类

题目类class Question，包含：
- 整型—num（题目编号）
- 字符串型—content（题目内容）
- 字符串型—standardanswer（标准答案）
- 整型—score（题目分值）
- 整型—flag（是否被删除：true=已被删除/false=未被删除）
- 方法—Right_Result()（答题正确输出）
- 方法—Wrong_Result( String wrong_answer )（答题错误输出）

试卷类class Exam_paper，包含：

整型—paper_num（试卷编号）
链表LinkedHashMap<Integer,Integer> score_map——存放试卷中的题目及对应分值

方法—put_score_map(int num, int score )（score_map添加新元素）

方法—Check_total_score()（检测当前试卷是否满分为100分）

学生类class Student，包含：

字符串型—ID（学号）
字符串型—name（姓名）

答卷类class Answer，包含：

整型—paper_num（答卷编号）
字符串型—ID（学号）
链表LinkedHashMap<Integer,String> answer_map——存放答卷中的答题顺序及对应答案

方法—put_answer_map(int order, String answer )（answer_map添加新元素）

删除题目类class Delete，包含：

整型—delete_num（删除题目编号）

主函数

数组列表List[Question] questionArrayList——存放 题目类 信息

数组列表List[Exam_paper] exam_paperArrayList——存放 试卷类 信息

数组列表List[Student] studentsArrayList——存放 学生类 信息

数组列表List[Answer] answerArrayList——存放 答卷类 信息

数组列表List[Delete] deleteArrayList——存放 删除题目类 信息

链表LinkedList score——临时记录当前答卷人的各题赋分情况

本题的算法有不同种，这里只提供我的个人思路：

采用循环结构利用正则表达式逐行分析输入——>判断试卷分值——>记录删除的题目——>试卷赋分——>核对试卷与答卷编号——>按照试卷顺序去答卷中查找试卷题号——>判断题目是否被删除——>判断答题是否正确并记录得分——>判断是否有题目漏答——>查找学生信息——>输出学生答题得分

代码

题目（1）：

import java.util.Scanner;
class Fan
{
    public final int slow=1;
    public final int medium=2;
    public final int fast=3;
    private int speed=1;
    private boolean on=false;
    private double radius=5;
    private String color="white";

    Fan(int Speed, boolean On, double Radius, String Color)
    {
        this.speed=Speed;
        this.on=On;
        this.radius=Radius;
        this.color=Color;
    }

    public String toString()
    {
        String s="speed "+speed+"\n";
        s+="color "+color+"\n";
        s+="radius "+radius+"\n";
        if(on)
        {
            s+="fan is on";
        }
        else
        {
            s+="fan is off";
        }

        return s;
    }
}

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

        System.out.println("-------");
        System.out.println("Default");
        System.out.println("-------");

        Fan f1=new Fan(1,false,5,"white");

        System.out.println( f1.toString() );

        System.out.println("-------");
        System.out.println("My Fan");
        System.out.println("-------");

        int f2_speed=input.nextInt();
        boolean f2_on=input.nextBoolean();
        double f2_radius=input.nextDouble();
        String f2_color=input.next();

        Fan f2=new Fan( f2_speed,f2_on,f2_radius,f2_color );

        System.out.println( f2.toString() );
    }
}

题目（2）：

import java.util.Scanner;
class Student
{
    private String num;
    private String name;
    private double chinese;
    private double math;
    private double physic;

    Student(String num, String name,double chinese, double math,double physic)
    {
        this.num=num;
        this.name=name;
        this.chinese=chinese;
        this.math=math;
        this.physic=physic;
    }
    public  int getsum()
    {
        return (int)( chinese + math + physic );
    }

    public  double getaverage()
    {
        return ( chinese + math + physic ) / 3;
    }

    public String printscore()
    {
        //format四舍五入保留两位小数
        String average = String.format( "%.2f", getaverage() );
        
        return num + " " + name + " " + getsum() + " " + average;
    }
}

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

        Student[] s = new Student[5];

        for(int i=0;i<5;i++)
        {
            String num = input.next();
            String name = input.next();
            double chinese = input.nextDouble();
            double math = input.nextDouble();
            double physics = input.nextDouble();

            s[i]=new Student(num,name,chinese,math,physics);
        }

        for(int i=0;i<5;i++)
        {
            System.out.println( s[i].printscore() );
        }
    }
}

题目（3）：

import java.util.*;
class MobilePhone
{
    public String type;
    public int price;
    public MobilePhone(String type, int price)
    {
        this.type = type;
        this.price = price;
    }

    //主动调用 toString 库函数，用toString函数产生的字符串来输出
    public String toString()
    {
        return "型号：" + type + "，价格：" + price;
    }
}

class Comparable implements Comparator<MobilePhone>
{
    public int compare(MobilePhone phone1 , MobilePhone phone2 )
    {
        if( phone1.price > phone2.price )
            return 2;
        else if( phone1.price == phone2.price )
            return 0;
        else return -1;
    }
}

class Main
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        List<MobilePhone> list = new ArrayList<>();
        //依次输入
        for( int i = 0 ; i<3 ; i++ )
        {
            MobilePhone mobilePhone = new MobilePhone( input.next()  , input.nextInt() );
            list.add( mobilePhone );
        }

        String inputString = input.next();
        int inputInteger = input.nextInt();
        MobilePhone search = new MobilePhone( inputString , inputInteger );

        //遍历原始list
        System.out.println( "排序前，链表中的数据：" );
        for ( MobilePhone mobilePhone:list )
        {
            System.out.println( mobilePhone );
        }

        Comparable comparable = new Comparable();

        list.sort( comparable );

        //遍历排序list
        System.out.println( "排序后，链表中的数据：" );
        for ( MobilePhone mobilePhone:list )
        {
            System.out.println( mobilePhone );
        }

        //查找输入手机
        for( MobilePhone mobilePhone : list )
        {
            if( mobilePhone.price == search.price )
            {
                System.out.print( search.type + "与链表中的" + mobilePhone.type + "价格相同");
                return;
            }
        }
        System.out.print("链表中的对象，没有一个与" + search.type + "价格相同的");
    }

}

题目（4）：

import java.util.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

//1、题目信息  "#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
class Question
{
    int num;
    String content;
    String standardanswer;
    int score;
    int flag=1;
    public Question(int num,String content,String standaanswer)
    {
        this.num = num;
        this.content = content;
        this.standardanswer = standaanswer;
    }

    //主动调用 toString 库函数，用toString函数产生的字符串来输出
    public String toString()
    {
        return num+" "+content+" "+standardanswer+" "+score+" "+flag;
    }

    public void Right_Result()
    {
        System.out.println(content+"~"+standardanswer+"~true");
    }

    public void Wrong_Result( String wrong_answer )
    {
        System.out.println(content+"~"+wrong_answer+"~false");
    }
}

//2、试卷信息  "#T:"+试卷号+" "+题目编号+"-"+题目分值
class Exam_paper
{
    int paper_num;
    LinkedHashMap<Integer,Integer> score_map = new LinkedHashMap<>();
    public void put_score_map(int num, int score )
    {
        score_map.put( num , score );
    }
    public Exam_paper(int paper_num)
    {
        this.paper_num=paper_num;
    }
    public void Check_total_score()
    {
        int total_score=0;
        // 迭代值
        for (Integer score : score_map.values())
        {
            total_score=total_score+score;
        }
        if(total_score!=100)
        {
            System.out.println( "alert: full score of test paper"+ paper_num +" is not 100 points" );
        }
    }
    public String toString()
    {
        return paper_num+" "+score_map;
    }
}

//3、学生信息  "#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
class Student
{
    String ID;
    String name;
    public Student(String ID,String name)
    {
        this.ID=ID;
        this.name=name;
    }

    public String toString()
    {
        return ID+" "+name;
    }
}


//4、答卷信息  **"#S:"+试卷号+" "+"#A:"+答案内容**
class Answer
{
    int paper_num;
    String ID;
    LinkedHashMap<Integer,String> answer_map = new LinkedHashMap<>();
    public Answer(int paper_num,String ID)
    {
        this.paper_num=paper_num;
        this.ID=ID;
    }
    public void put_answer_map(int order, String answer )
    {
        answer_map.put( order,answer );
    }

    public String toString()
    {
        return paper_num+" "+ID+" "+answer_map;
    }
}

class Delete
{
    int delete_num;
    public Delete(int delete_num)
    {
        this.delete_num=delete_num;
    }
    public String toString()
    {
        return String.valueOf(delete_num);
    }
}

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

        String regex_Question = "#N:\\s*(\\d+)\\s*#Q:(.+) #A:(.+)";
        Pattern pattern_Question = Pattern.compile(regex_Question);

        String regex_Exam_paper = "#T:\\s*(\\d+)(\\s*\\d+-\\d+)*\\s*";
        Pattern pattern_Exam_paper = Pattern.compile(regex_Exam_paper);

        String regex_Student = "#X:(-*\\s*\\d+\\s+.*\\s*)*";
        Pattern pattern_Student = Pattern.compile(regex_Student);

        String regex_Answer = "#S:\\s*(\\d*)\\s*(\\d*)(\\s*#A:\\d+-[^#]*)*";
        Pattern pattern_Answer = Pattern.compile(regex_Answer);

        String regex_Delete = "^#D:\\s*N\\s*-\\s*(\\d+)\\s*$";
        Pattern pattern_Delete = Pattern.compile(regex_Delete);

        List<Question> questionArrayList = new ArrayList<>();
        List<Exam_paper> exam_paperArrayList = new ArrayList<>();
        List<Student> studentsArrayList = new ArrayList<>();
        List<Answer> answerArrayList = new ArrayList<>();
        List<Delete> deleteArrayList = new ArrayList<>();

        //输入
        while( input.hasNextLine() )
        {
            //当前一行的输入字符串
            String inputString = input.nextLine();

            Matcher pmatcher_Question = pattern_Question.matcher(inputString);
            Matcher pmatcher_Exam_paper = pattern_Exam_paper.matcher(inputString);
            Matcher pmatcher_Student = pattern_Student.matcher(inputString);
            Matcher pmatcher_Answer = pattern_Answer.matcher(inputString);
            Matcher pmatcher_Delete = pattern_Delete.matcher(inputString);

            //输入字符串是end，则输入完毕退出循环
            if(inputString.equals("end"))
                break;

                //inputString==输入1、题目信息  "#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
            else if(pmatcher_Question.matches())
            {
                Question question = new Question(Integer.parseInt(pmatcher_Question.group(1).trim()), pmatcher_Question.group(2).trim(), pmatcher_Question.group(3).trim());
                questionArrayList.add(question);
            }

            //inputString==输入2、试卷信息  "#T:"+试卷号+" "+题目编号+"-"+题目分值
            else if(pmatcher_Exam_paper.matches())
            {
                //试卷编号
                Exam_paper exam_paper = new Exam_paper( Integer.parseInt( pmatcher_Exam_paper.group(1).trim() ) );

                Pattern pattern = Pattern.compile("(\\d+)\\s*-\\s*(\\d*)");
                Matcher patternmatcher = pattern.matcher(inputString);

                while ( patternmatcher.find() )  //局部匹配，调用第二次会继续向下匹配
                {
                    //Map<题目编号-分值>
                    exam_paper.put_score_map( Integer.parseInt( patternmatcher.group(1).trim() ) , Integer.parseInt( patternmatcher.group(2) ) );
                }
                exam_paperArrayList.add(exam_paper);
            }

            //inputString==3、学生信息   "#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
            else if( pmatcher_Student.matches() )
            {
                Pattern pattern = Pattern.compile("(\\d+)\\s+([^-]+)");
                Matcher patternmatcher = pattern.matcher(inputString);

                while ( patternmatcher.find() )
                {
                    //学号-姓名
                    Student student = new Student( patternmatcher.group(1).trim(),patternmatcher.group(2).trim() );
                    studentsArrayList.add(student);
                }
            }

            //inputString==4、答卷信息  "#S:"+试卷号+" "+学号+"#A:"+试卷题目的顺序号+"-"+**+答案内容+...
            else if(pmatcher_Answer.find())
            {
                //试卷编号-学号
                Answer answer = new Answer( Integer.parseInt(pmatcher_Answer.group(1)),pmatcher_Answer.group(2));

                Pattern pattern = Pattern.compile("#A:\\s*(\\d+)-([^#|\\n]*)");
                Matcher patternmatcher = pattern.matcher(inputString);

                while ( patternmatcher.find() ) //局部匹配，调用第二次会继续向下匹配
                {
                    answer.put_answer_map( Integer.parseInt(patternmatcher.group(1).trim()),patternmatcher.group(2).trim() );
                }
                answerArrayList.add(answer);
            }

            //inputString==5、删除题目信息  "#D:N-"+题目号
            else if(pmatcher_Delete.matches())
            {
                Delete delete = new Delete( Integer.parseInt(pmatcher_Delete.group(1).trim()) );
                deleteArrayList.add(delete);
            }

            //输入信息只要不符合格式要求，均输出”wrong format:”+信息内容       例如：wrong format:2 #Q:2+2=
            else
            {
                System.out.println("wrong format:"+inputString);
            }

        }//总while结束


        //判断试卷分值是否100
        for( int i=0;i<exam_paperArrayList.size();i++ )
        {
            exam_paperArrayList.get(i).Check_total_score();
        }

        if( exam_paperArrayList.size()==0 )
        {
            Exam_paper exam_paper = new Exam_paper( 0 );
            exam_paper.put_score_map( 0 , 0 );
            exam_paperArrayList.add(exam_paper);
        }

        //删除题目并记录
        for( int i=0;i<deleteArrayList.size();i++ )
        {
            int num=deleteArrayList.get(i).delete_num;
            //选中删除题目,修改flag
            for(int j=0;j< questionArrayList.size();j++)
            {
                if( questionArrayList.get(j).num==num )
                {
                    questionArrayList.get(j).flag=0;
                }
            }
        }


        for( int S=0;S<answerArrayList.size();S++ )  //几份答卷
        {
            boolean flag=false;
            for( int T=0;T<exam_paperArrayList.size();T++ )
            {
                if( answerArrayList.get(S).paper_num == exam_paperArrayList.get(T).paper_num )
                {
                    flag=true;
                }
            }

            for( int T=0;T<exam_paperArrayList.size();T++ )  //几份试卷分则
            {
                //判断试卷编号是否相同
                if( flag )
                {
                    //当前试卷题目赋分值
                    for( Integer num: exam_paperArrayList.get(T).score_map.keySet() )  //当前试卷分则有几份分值
                    {
                        //根据#T 搜索题号
                        Optional<Question> questionOptional = questionArrayList.stream().filter(question -> num == (question.num)).findFirst();

                        //搜到了题号
                        if( !questionOptional.isEmpty() )
                        {
                            questionOptional.get().score=exam_paperArrayList.get(T).score_map.get(num);
                        }
                    }
                    
                    //记录分数
                    LinkedList<Integer> score = new LinkedList<>();
                    //检测#A
                    int t=1;//#T里的第几个
                    Cycle:for( Integer current_num: exam_paperArrayList.get(T).score_map.keySet() )
                    {
                        //循环查找题目
                        for( Integer current_order: answerArrayList.get(S).answer_map.keySet() )
                        {
                            if (current_order == t)
                            {
                                //搜索当前题号current_num信息
                                int finalCurrent_num = current_num;
                                Optional<Question> questionOptional = questionArrayList.stream().filter(question -> finalCurrent_num == (question.num)).findFirst();

                                //找到current_num题目
                                if (!questionOptional.isEmpty())
                                {
                                    //题目有效
                                    if (questionOptional.get().flag == 1)
                                    {
                                        //判断是否答对  计算分数
                                        if (answerArrayList.get(S).answer_map.get(current_order).equals(questionOptional.get().standardanswer))
                                        {
                                            questionOptional.get().Right_Result();
                                            score.add(questionOptional.get().score);

                                            t++;
                                            continue Cycle;
                                        }
                                        else
                                        {
                                            questionOptional.get().Wrong_Result(answerArrayList.get(S).answer_map.get(current_order));
                                            score.add(0);

                                            t++;
                                            continue Cycle;
                                        }
                                    }
                                    //#S:里的#A:答了删除的题目                                    the question 2 invalid
                                    else if (questionOptional.get().flag == 0)
                                    {
                                        System.out.println("the question " + current_num + " invalid~0");
                                        score.add(0);
                                    }
                                }
                                //没找到
                                else
                                {
                                    System.out.println("non-existent question~0");
                                    score.add(0);
                                    t++;

                                    continue Cycle;
                                }
                            }
                        }

                        t++;

                    }//输入的#A检测完


                    //#S：里的#A: < #T里的个数  输入的答案信息少于试卷的题目数量        answer is null
                    if( answerArrayList.get(S).answer_map.size() < exam_paperArrayList.get(T).score_map.size() )
                    {
                        int count=exam_paperArrayList.get(T).score_map.size()-answerArrayList.get(S).answer_map.size();
                        while( count>0 )
                        {
                            System.out.println("answer is null");
                            score.add(0);
                            count--;
                        }
                    }


                    //搜索学生
                    int finalS = S;
                    Optional<Student> studentOptional = studentsArrayList.stream().filter(student -> answerArrayList.get(finalS).ID.equals(student.ID)).findFirst();

                    //#S:里的学号在#X:里没有  学号引用错误                          20201103 not found
                    if( studentOptional.isEmpty() )
                    {
                        System.out.println(answerArrayList.get(S).ID+" not found");
                    }
                    else
                    {
                        System.out.print(studentOptional.get().ID+" "+studentOptional.get().name+": ");

                        //输出分数
                        int total_score=0;
                        if(score.size()==0 )
                        {
                            System.out.print("0");
                        }
                        for( int k=0;k<score.size();k++ )
                        {
                            total_score=total_score+score.get(k);
                            System.out.print( score.get(k) );
                            if( k!= score.size()-1 )
                            {
                                System.out.print(" ");
                            }
                            else
                            {
                                System.out.println("~"+total_score);
                            }
                        }
                    }

                }
                //#S:里的paper_num和#T:里的papernum不等  试卷号引用错误         The test paper number does not exist
                else
                {
                    System.out.println("The test paper number does not exist");
                }
                break;
            }
        }
    }
}

可以看到最后一题的算法复杂度高，且又因为我是Java初学者，故需要自学一些内容，下面将进行个人对自学内容一些重点的整理

四、SourceMonitor代码分析

题目（1）：

题目（2）：

题目（3）：

题目（4）：

五、自学内容

展示自学内容，并进行重点的归纳和整理（这里只展示个人认为比较重要且题目需要用到的知识点）

正则表达式

推荐正则表达式的网上测试工具网址：<正则表达式在线测试 | 菜鸟工具 (jyshare.com)>里面附带下图最基本的正则表达式语法参考

Pattern类和 Matcher 方法

（1） Matcher 匹配器类，通过 Pattern 执行匹配操作，基本用法为：

Pattern [pattern名称] = Pattern.compile([正则表达式/固定字符串]);
Matcher [matcher名称] = [pattern名称].matcher([被匹配的字符串]);

（2）.matches() 方法：对整个字符串进行匹配，匹配成功返回true

例：正则表达式：\d+ //至少一个数字

被匹配字符串：12345 //匹配成功

被匹配字符串：12345abc //匹配失败

//(1)代码
if( [matcher名称].matches() ){
	System.out.println("匹配成功");
}

（3）.find() 方法：对字符串进行局部匹配，匹配成功返回true

.find()方法在匹配后会从匹配部分的下个位置开始

例：正则表达式：\d+ //至少一个数字

被匹配字符串：123abc //匹配成功一次

被匹配字符串：123abc123 //匹配成功两次

//(1)代码
if( [matches名称].find() ){
    System.out.println("匹配成功");
}

（4）.group() 方法：通过对括号内的字符分组，对每个组进行处理的方法

group( [组数] )，括号中的整型(>0) 对应正则表达式中按括号分组的局部字符段；整型（=0）对应整个字符串

Pattern pattern = Pattern.compile("(\\w+)-(\\d+)");  	//[至少一个数字]-[至少一个字母]
Matcher matcher = pattern.matcher("a-1,b-b,c-3,d-d");
while ( matcher.find() )  	//循环局部匹配
{
    System.out.println("整组：" + matcher.group(0));
    System.out.println("组1：" + matcher.group(1));
    System.out.println("组2：" + matcher.group(2));
}

输出如图：

ArrayList 和 LinkedList

需要导入 java.util.Array 、java.util.LinkedList 包

异同：

相同处：没有固定大小的限制，可以添加或删除元素

不同处:1）ArrayList按线性的顺序存储数据；LinkedList是在每一个节点里存到下个节点地址的线性表

2）ArrayList适用频繁访问列表中的某个元素，查找和修改操作效率较低

LinkedList需要通过循环迭代来访问列表中的元素，增加和删除操作效率较高

（1）创建

ArrayList<E> [表名称] =new ArrayList<>();  	//E—>泛型

LinkedList<E> [表名称] = new LinkedList<E>();  	//E—>泛型，普通创建
LinkedList<E> [表名称] = new LinkedList(Collection<? extends E> c); 	 //E—>泛型，集合创建

（2）.add() 方法：添加元素

List.add( [元素] );  	//尾插一个新元素

（3）. get() 方法：访问元素

List.get( n-1 );  	//访问第n个元素

（4）size() 方法：计算大小

List.size();  	//返回整型=表的元素个数

（5）for each 方法：迭代遍历

for ( [元素类型] [循环变量] : [表名称] ) 
{
    System.out.println([循环变量]);
}

HashMap 和 LinkedHashMap

需要导入 java.util.HashMap 、java.util.LinkedHashMap 包

异同：

相同处：没有固定大小的限制的散列表，它存储的内容是键值对(key-value)映射

不同处:1）HashMap每次添加元素的存放位置是无序的；LinkedHashMap保证迭代顺序，即按照储存顺序排列

2） LinkedHashMap额外加了 头节点header，标志位accessOrder 两个成员变量

（1）创建

HashMap<[key类型], [value类型]> [表名称] = new HashMap<{[key类型], [value类型]}>();  	//E—>泛型，{}中内容可以省略

LinkedHashMap<[key类型], [value类型]> [表名称] = new LinkedHashMap<{[key类型], [value类型]}>();  	//E—>泛型，{}中内容可以省略

（2）.put() 方法：添加元素

Map.put( [key],[value] );  	//尾插一个新元素

（3）. get(key) 方法：访问键值对应映射值

Map.get( [key] );  	//访问key的value

（4）size() 方法：计算大小

Map.size();  	//返回整型=表的元素个数

（5）for each 方法：迭代遍历

// 输出 key 和 value
for ([key类型] key : [表名称].keySet() )   	//.keySet()方法当前获取键值
{
    System.out.println( "key: " + key + " value: " + [表名称].get(key) );
}

Comparator 和 Comparable 方法

需要导入 java.util.Comparator 包

异同：

相同处：可以对 集合Collections 进行排序

不同处：Comparator 可以有更多的排序方法

数值排序

class [方法名称] implements Comparator<[排序对象类型]>
{
    public int compare( [排序元素1] , [排序元素2] )  	//Comparator接口的方法 int compare(object o1,object o2);
    {
        if([排序元素1]>[排序元素2]) return 1;
        else if([排序元素1]>[排序元素2])  return -1;
        else return 0;
    }
}

字符串排序

class [方法名称] implements Comparator<[排序对象类型]>
{
    public int compare( [排序元素1] , [排序元素2] )  	
    {
        return [排序元素1].compareTO( [排序元素2] );  	//.compareTo()方法用于字符串之间的比较
    }
}

六、总结

答题技巧

1）、在面对像答题判题程序-3这种工程量大，情况案例多的题目时，应在正式敲代码前提前设计好类设计和算法思路，否则在过程需要更多的时间精力进行修改调试，甚至还会出现大代码块需要删除重新设计的情况

2）、在完成答题判题程序-3题目时，因为有错误格式Wrong Format的情况，应该适当的降低输入门槛，即设计的正则表达式应该尽可能地让更多种输入格式不会报错，如：题目内容仅仅是数学题——>题目内容可以是由数字，字母，汉字组成、答卷#S里的#A格式必须是【答题顺序】—【答案】——>可以为【答题顺序】—【空】或全为空 等

心得体会

1）、除答题判题程序题目组外，其他题目相对较简单，考察新手对Java编程语言的一些基础且重要的知识点，例如类的设计和对象、类的封装性等

2）、相对C语言，Java语言的单一职责原则体现得更为显著，要培养将相同对象的不同自定义方法函数放进类中，而不是像C一样通过更多的自定义函数来处理。因为Java中类的存在，Java的代码量更大，空间复杂度更高，也随着题目难度的上升，任务更重

3）、这次答题判题程序-3共有28个测试得分点，而样例却只给出10个，因此开发程序时，思维不能固化，要学会主动联想特殊情况，如答卷的答案漏答，或答题的题目已被删除等特殊情况也要纳入代码的考虑范围内，这样才能增加代码的质量，适用范围更广

个人建议

PTA中既然测试点远大于给出样例，为了方便学生理解，测试点提示应该更加准确具体易懂，否则不停的调试搞错了方向也是徒劳无功

标签：总结,题目,String,int,num,OOP,score,public
From： https://www.cnblogs.com/nchu22022202java01/p/18146605

OOP题目集1~3的总结

目录

（一）前言

（二）作业介绍

（三）算法与代码

（四）SourceMonitor代码分析

（五）自学内容

（六）总结

一、前言

二、作业介绍

题目内容

类的设计与创建，题目（1）如图：

类数组的基本使用，题目（2）如图：

数组的排序与查找，题目（3）如图：

三、算法与代码

算法大纲

题目（1）：

题目（2）：

题目（3）：

题目（4）：

1、题目输入按照一定格式规律，因此可以运用正则表达式来高效处理输入数据，且处理输入时运用while( input.hasNextLine() ){ }循环，逐行收集输入信息，知道该行字符串为end时退出循环

3、题目输出的错误提示较多且有优先级顺序输出，所以做题之前应做好输出提示的优先级排序，优先级越高的代码块 应越靠前/在越外层的循环

代码

题目（1）：

题目（2）：

题目（3）：

题目（4）：

四、SourceMonitor代码分析

题目（1）：

题目（2）：

题目（3）：

题目（4）：

五、自学内容

正则表达式

Pattern类 和 Matcher 方法

ArrayList 和 LinkedList

HashMap 和 LinkedHashMap

Comparator 和 **Comparable **方法

数值排序

字符串排序

六、总结

答题技巧

心得体会

个人建议

相关文章

赞助商

阅读排行

3、题目输出的错误提示较多且有优先级顺序输出，所以做题之前应做好输出提示的优先级排序，优先级越高的代码块应越靠前/在越外层的循环

Pattern类和 Matcher 方法

Comparator 和 Comparable 方法