OO题目集1~3作业总结

OO题目集1~3作业总结

1.前言

针对于PTA上面的三次题目集的作业，有如下分析：

第一次作业知识点、题量、难度：

①计算两个数的和：使用Java的Scanner进行简单的输入输出，了解int的输入输出以及其定义；

②电话键盘字母数字转换：使用Java的if-else选择结构将字母转换为数字并输出；

③成绩分级管理：将学生分数使用选择结构转换为相应的等级并输出；

④计算税率：使用选择结构计算纳税金额；

⑤计算钱币：对数据进行相除计算，多次对纸币进行判断；

⑥使用一维数组求平均值：使用for循环，将数组里面的整数进行叠加之后求出平均值并输出；

⑦对多个整数进行排序：对输入的整数进行排序并输出，考察对排序方法的使用；

⑧判断三角形类型：对输入的三条边数据使用选择结构进行判断，输出三角形相应的类型。

第一次作业的难度，相对于我个人而言，我觉得比较简单，因为并不是第一次学习编程语言，以前学习过基础的C语言，所以这第一次作业的难易程度对我而言，比较简单，使用以前学过的一些编程语言的知识也能解决问题，之前听一个老师说过，编程语言大部分都是一通百通，真正把一门语言学精了，之后学其他的语言也能很快的上手，这应该也是为什么我会觉得Java第一次作业比较简单吧。

 

第二次作业知识点、题量、难度：

①IP地址转换：分割字符串进行转换，考察了对String类型数据的操作；

②合并两个有序数组为新的有序数组：合并数组并升序输出；

③判断闰年及星期几：对输入数据进行判断，调用方法实现程序的相应功能；

④求下一天：输入日期求取下一天，调用方法实现相应功能；⑤求前N天：对输入数据进行处理，输出前N天。

第二次作业的难度，相对于我个人而言，我觉得难度一般，我感觉主要是为了考察学生的逻辑思维能力以及对题目的的思考，需要对程序的一个完整性有一个很好的了解，需要考虑到输出的多种情况，以及对于数据的边界也有了一个严格的的要求，不能越过数据定义的边界，否则程序无法输出下一天或者前N天等信息。

 

第三次作业知识点、题量、难度：

①创建账户类Account：给出Account类得相关属性以及方法，设计Account，主要为了考察类与对象、封装性的知识点；

②定义日期类：给出了Date类的结构图，通过结构图对题目程序进行编写，主要考查类的封装性；

③一元多项式求导：编写程序，对简单多项式的导函数求解，主要考查了正则表达式、数组的应用、去除字符串的空格。

第三次作业的难度，对于我个人而言，是这前三次作业里面最难的，对于设计Account类以及设计Date类的题目难度感觉还可以，但是感觉写一元多项式求导这题很难，不知道如何下手，对于正则表达式的理解不够透彻，不能熟练的使用正则表达式。

2.设计与分析

由于篇幅限制，因此使用比较有代表性的题目代码进行分析。

第一次作业：

7-8判断三角形类型代码如下：

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        double a = input.nextDouble();
        double b = input.nextDouble();
        double c = input.nextDouble();
        if(a >= 1 && a <= 200 && b >= 1 && b <= 200 && c >= 1 && c <= 200) {
            if(a + b > c && a + c > b && b + c > a) {
                if(a == b && b==c) {
                    System.out.println("Equilateral triangle");
                }
                else if((a == b && a != c) || (a == c && a != b) || (b == c && b != a)) {
                    if((a * a + b * b - c * c <= 1e-6) || (a * a + c * c - b * b <= 1e-6) || (c * c + b * b - a * a <= 1e-6)){
                        System.out.println("Isosceles right-angled triangle");
                    }
                    else {
                        System.out.println("Isosceles triangle");
                    }
                }
                else if((a * a + b * b - c * c <= 1e-6) || (a * a + c * c - b * b <= 1e-6) || (c * c + b * b - a * a <= 1e-6)) {
                    System.out.println("Right-angled triangle");
                }
                else {
                    System.out.println("General triangle");
                }
            }
            else {
                System.out.println("Not a triangle");
            }
        }
        else {
            System.out.println("Wrong Format");
        }
    }

}

 判断三角形类型，1.判断输入的数据是否符合题目定义的边界；2.判断是否为等边三角形；3.判断是否为等腰三角形；4.判断是否为直角三角形。

通过相应的判断，输出相应的结果。判断三角形这题，需要了解浮点型的数据如何判断相等，否则对于直角三角形的判断无法进行，写这道题目，需要了解浮点型数据的一些知识，写起来需要逻辑清晰，判定条件不能出错，判定条件之间如何进行嵌套才能更好的解决此题。

 

第二次作业：

7-4求下一天代码如下：

import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        int year = input.nextInt();
        int month = input.nextInt();
        int day = input.nextInt();
        if(checkInputValidity(year,month,day) == false) {
            System.out.println("Wrong Format");
        }else {
            System.out.print("Next date is:");
            nextDate(year,month,day);
        }
    }
    
    public static boolean checkInputValidity(int year,int month,int day) {
        // TODO Auto-generated method stub
        boolean flag = true;
        if(year < 1820||year > 2020||month < 1||month > 12 ||day < 1) {
            flag = false;
        }else if(month == 4 || month == 6 || month == 9 || month == 11) {
            if(day > 30) {
                flag = false;
            }
        }else if(month == 1||month == 3||month == 5||month == 7||month == 8||month == 10||month ==12) {
            if(day > 31) {
                flag = false;
            }
        }else {
            if(isLeapYear(year) == true) {
                if(day > 29) {
                    flag = false;
                }
            }else {
                if(day > 28) {
                    flag = false;
                }
            }
        }
        return flag;
    }
    
    public static boolean isLeapYear(int year) {
        // TODO Auto-generated method stub
        if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
            return true;
        }else {
            return false;
        }
    }
    
    public static void nextDate(int year,int month,int day) {
        // TODO Auto-generated method stub
        if(month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10) {
            if(day == 31) {
                System.out.println(year + "-" + (month + 1) + "-1");
            }else {
                System.out.println(year + "-" + month + "-" + (day + 1));
            }
        }else if(month == 4 || month == 6 || month == 9 || month == 11) {
            if(day == 30) {
                System.out.println(year + "-" + (month + 1) + "-1");
            }else {
                System.out.println(year + "-" + month + "-" + (day + 1));
            }
        }else if(month == 12){
            if(day == 31) {
                System.out.println((year + 1) + "-" + (month - 11) + "-1");
            }else {
                System.out.println(year + "-" + month + "-" + (day + 1));
            }

        }else {
            if(isLeapYear(year) == true) {
                if(day == 29) {
                    System.out.println(year + "-" + (month + 1) + "-1");    
                }else {
                    System.out.println(year + "-" + month + "-" + (day + 1));
                }
            }else {
                if(day == 28) {
                    System.out.println(year + "-" + (month + 1) + "-1");    
                }else {
                    System.out.println(year + "-" + month + "-" + (day + 1));
                }
            }
        }
    }
}

Main类的几个方法如下：

main：主方法

isLeapYear：判断year是否为闰年，返回boolean类型

checkInputValidity：判断输入日期是否合法，返回布尔值

nextDate：求输入日期的下一天

本题通过调用各种方法，传参来进行判断日期是否合法、是否为闰年，以及输出日期的下一天，对于这道题，需要了解方法的调用以及传参，我在写这道题的时候，对于日期是否合法设定了一个标志位flag，通过返回flag的值判断是否合法；这道题需要对闰年有一个了解：普通闰年:公历年份是4的倍数的，且不是100的倍数，为普通闰年；世纪闰年:公历年份是整百数的，必须是400的倍数才是世纪闰年。编写这道题时，checkInputValidity方法需要注意输入数据的边界；在nextDate方法中时，需要注意大小月、2月以及12月的情况。

 

7-5求前N天代码如下：

import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        int year = input.nextInt();
        int month = input.nextInt();
        int day = input.nextInt();
        int n = input.nextInt();
        if(checkInputValidity(year,month,day,n) == false) {
            System.out.println("Wrong Format");
        }else {
            System.out.print(n + " days ago is:");
            nextDate(year,month,day,n);
        }
    }
    
    public static boolean checkInputValidity(int year,int month,int day,int n) {
        // TODO Auto-generated method stub
        boolean flag = true;
        if(n < -10||n > 10) {
            flag = false;
        }
        if(year < 1820||year > 2020||month < 1||month > 12 ||day < 1) {
            flag = false;
        }else if(month == 4 || month == 6 || month == 9 || month == 11) {
            if(day > 30) {
                flag = false;
            }
        }else if(month == 1||month == 3||month == 5||month == 7||month == 8||month == 10||month ==12) {
            if(day > 31) {
                flag = false;
            }
        }else {
            if(isLeapYear(year) == true) {
                if(day > 29) {
                    flag = false;
                }
            }else {
                if(day > 28) {
                    flag = false;
                }
            }
        }
        return flag;
    }
    
    public static boolean isLeapYear(int year) {
        // TODO Auto-generated method stub
        if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
            return true;
        }else {
            return false;
        }
    }
    
    public static void nextDate(int year,int month,int day,int n) {
        // TODO Auto-generated method stub
        int sum = day - n;
        if(month == 5 || month == 7 || month == 10) {
            if(sum > 31) {
                System.out.println(year + "-" + (month + 1) + "-" + (sum - 31));
            }else if(sum > 0) {
                System.out.println(year + "-" + month + "-" + sum);
            }else {
                System.out.println(year + "-" + (month - 1) + "-" + (30 + sum));
            }
        }else if(month == 4 || month == 6 || month == 9 || month == 11) {
            if(sum > 30) {
                System.out.println(year + "-" + (month + 1) + "-" + (sum - 30));
            }else if(sum > 0) {
                System.out.println(year + "-" + month + "-" + sum);
            }else {
                System.out.println(year + "-" + (month - 1) + "-" + (31 + sum));
            }
        }else if(month == 12){
            if(sum > 31) {
                System.out.println((year + 1) + "-" + (month - 11) + "-" + (sum - 31));
            }else if(sum > 0) {
                System.out.println(year + "-" + month + "-" + sum);
            }else {
                System.out.println(year + "-" + (month - 1) + "-" + (30 + sum));
            }
        }else if(month == 1){
            if(sum > 31) {
                System.out.println((year + 1) + "-" + (month + 1) + "-" + (sum - 31));
            }else if(sum > 0) {
                System.out.println(year + "-" + month + "-" + sum);
            }else {
                System.out.println((year - 1) + "-" + (month + 11) + "-" + (31 + sum));
            }
        }else if(month == 2) {
            if(isLeapYear(year) == true) {
                if(sum > 29) {
                    System.out.println(year + "-" + (month + 1) + "-" + (sum - 29));
                }else if(sum > 0) {
                    System.out.println(year + "-" + month + "-" + sum);
                }else {
                    System.out.println(year + "-" + (month - 1) + "-" + (31 + sum));
                }
            }else {
                if(sum > 28) {
                    System.out.println(year + "-" + (month + 1) + "-" + (sum - 28));
                }else if(sum > 0) {
                    System.out.println(year + "-" + month + "-" + sum);
                }else {
                    System.out.println(year + "-" + (month - 1) + "-" + (31 + sum));
                }
            }
        }else if(month == 3) {
            if(isLeapYear(year) == true) {
                if(sum > 31) {
                    System.out.println(year + "-" + (month + 1) + "-" + (sum - 31));
                }else if(sum > 0) {
                    System.out.println(year + "-" + month + "-" + sum);
                }else {
                    System.out.println(year + "-" + (month - 1) + "-" + (29 + sum));
                }
            }else {
                if(sum > 31) {
                    System.out.println(year + "-" + (month + 1) + "-" + (sum - 31));
                }else if(sum > 0) {
                    System.out.println(year + "-" + month + "-" + sum);
                }else {
                    System.out.println(year + "-" + (month - 1) + "-" + (28 + sum));
                }
            }
        }else {
            if(sum > 31) {
                System.out.println(year + "-" + (month + 1) + "-" + (sum - 31));
            }else if(sum > 0) {
                System.out.println(year + "-" + month + "-" + sum);
            }else {
                System.out.println(year + "-" + (month - 1) + "-" + (31 + sum));
            }
        }
    }
}

本题与7-4其实相差不是很多，不过一个是求下一天，一个是求前N天，代码大同小异，都是通过调用方法，传参进行判断。但是本题求的是前N天，所以需要对N进行一个思考，当N为正值时，求前N天；当其为负值时，求后-N天。同时需要对N的值进行判断，N是否符合题目要求的取值范围、前N天是否横跨月份、是否横跨年份等。

 

 

 第三次作业：

7-2定义日期类代码如下：

import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        Date date = new Date();
        Scanner input = new Scanner(System.in);
        int year = input.nextInt();
        int month = input.nextInt();
        int day = input.nextInt();
        date.setYear(year);
        date.setMonth(month);
        date.setDay(day);
        if(date.checkInputValidity() == false) {
            System.out.println("Date Format is Wrong");
        }else {
            System.out.print("Next day is:");
            date.getNextDate();
        }
    }
}
class Date {
    private int year;
    private int month;
    private int day;
    public Date() {
        
    }
    public Date(int year,int month,int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public int getYear() {
        return year;
    }
    public void setYear(int year) {
        this.year = year;
    }
    public int getMonth() {
        return month;
    }
    public void setMonth(int month) {
        this.month = month;
    }
    public int getDay() {
        return day;
    }
    public void setDay(int day) {
        this.day = day;
    }
    public boolean isLeapYear(int year) {
        if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
            return true;
        }else {
            return false;
        }
    }
    public boolean checkInputValidity() {
        boolean flag = true;
        if(getYear() < 1900||getYear() > 2000||getMonth() < 1||getMonth() > 12 ||getDay() < 1) {
            flag = false;
        }else if(getMonth() == 1||getMonth() == 3||getMonth() == 5||getMonth() == 7||getMonth() == 8||getMonth() == 10||getMonth() ==12) {
            if(getDay() > 31) {
                flag = false;
            }
        }else if(getMonth() == 4 || getMonth() == 6 || getMonth() == 9 || getMonth() == 11) {
            if(getDay() > 30) {
                flag = false;
            }
        }else {
            if(isLeapYear(getYear()) == true) {
                if(getDay() > 29) {
                    flag = false;
                }
            }else {
                if(getDay() > 28) {
                    flag = false;
                }
            }
        }
        return flag;
    }
    public void getNextDate() {
        if(getMonth() == 1 || getMonth() == 3 || getMonth() == 5 || getMonth() == 7 || getMonth() == 8 || getMonth() == 10) {
            if(getDay() == 31) {
                System.out.println(getYear() + "-" + (getMonth() + 1) + "-1");
            }else {
                System.out.println(getYear() + "-" + getMonth() + "-" + (getDay() + 1));
            }
        }else if(getMonth() == 4 || getMonth() == 6 || getMonth() == 9 || getMonth() == 11) {
            if(getDay() == 30) {
                System.out.println(getYear() + "-" + (getMonth() + 1) + "-1");
            }else {
                System.out.println(getYear() + "-" + getMonth() + "-" + (getDay() + 1));
            }
        }else if(getMonth() == 12){
            if(getDay() == 31) {
                System.out.println((getYear() + 1) + "-" + (getMonth() - 11) + "-1");
            }else {
                System.out.println(getYear() + "-" + getMonth() + "-" + (getDay() + 1));
            }

        }else {
            if(isLeapYear(getYear()) == true) {
                if(getDay() == 29) {
                    System.out.println(getYear() + "-" + (getMonth() + 1) + "-1");    
                }else {
                    System.out.println(getYear() + "-" + getMonth() + "-" + (getDay() + 1));
                }
            }else {
                if(getDay() == 28) {
                    System.out.println(getYear() + "-" + (getMonth() + 1) + "-1");    
                }else {
                    System.out.println(getYear() + "-" + getMonth() + "-" + (getDay() + 1));
                }
            }
        }
    }
    
}

 

 

 本题主要是考察调用类，以及考察类的封装性。刚开始写这道题是我没用封装，因为还不了解封装是什么，后来通过网上查阅看到了一个博主对封装的介绍：封装就是把普通的对象进行封装，对象的属性设为私有的，对外提供get和set方法，其他类只能通过get和set对对象属性值进行操作。通过博主的介绍，我对Date类使用了封装，将year、month、day三个属性进行了封装，Main类通过调用Date类的get和set方法来对对象属性进行操作。

 

7-3一元多项式求导（类设计）代码如下：

import java.util.Scanner;
import java.math.BigInteger;
import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String m = "";
        String n = "";
        m = input.nextLine().replace(" ", "");
        for(int i = 0;i < m.length();i++) {
            if(m.charAt(0) == '+'||m.charAt(0) == '0') {
                System.out.println("Wrong Format");
                return;
            }if(m.charAt(i) == '0') {
                    System.out.println("Wrong Format");
                    return;
            }
        }
        Polynomial polynomial = new Polynomial(m);
        if(!m.equals("")) {
            if(polynomial.isPolynomial()) {
                n = m.replaceAll(" ","");
                if(n.matches("^((([+-]?)([0-9]|([1-9][0-9]*))))+$")) {
                    System.out.println("0");
                }else {
                    n = n.replace("^+","^");
                    n = n.replace("-","+-");
                    n = n.replace("^+-","^-");
                    Expression expression = new Expression(polynomial.getPolynomial(n));
                    System.out.println(expression.toString());
                }
            }
        }
    }
}
class Term{
    Term(){
    }
    public Term getDerivative() {
        Term term = null;
        return term;
    }
}
class Expression{
    private LinkedList<Term> list=new LinkedList<>();
    Expression(){
    }
    public Expression(LinkedList<Term> list) {
        this.list = list;
    }
    public LinkedList<Term> getList() {
        return list;
    }
    public String toString() {
        String m = "";
        String n = "";
        for(int i = 0;i < list.size();i++) {
            m = m + list.get(i);
        }
        if(m.charAt(0) == '+') {
            for(int j = 1;j < m.length();j++) {
                n = n + m.charAt(j);
            }
            return n;
        }else {
            return m;
        }
    }
}
class PowerFunctionTerm extends Term{
    BigInteger coeff;
    BigInteger index;
    PowerFunctionTerm(){
    }
    public PowerFunctionTerm(BigInteger coeff,BigInteger index) {
        this.coeff = coeff;
        this.index = index;
    }
    public BigInteger getCoeff() {
        return coeff;
    }
    public BigInteger getIndex() {
        return index;
    }
    public PowerFunctionTerm getDerivative() {
         BigInteger m,n;
         BigInteger x = new BigInteger("1");
         m = coeff.multiply(index);
         n = index.subtract(x);
         PowerFunctionTerm powerFunctionTerm = new PowerFunctionTerm(m,n);
         return powerFunctionTerm;
    }
    public String toString() {
        BigInteger m = new BigInteger("1");
        BigInteger n = new BigInteger("0");
        String str = "";
        if(getDerivative().getCoeff().compareTo(n) == 1) {
            if(getDerivative().getIndex().compareTo(n) == 0) {
                str = "+" + getDerivative().getCoeff();
            }else if(getDerivative().getIndex().compareTo(m)==0) {
                    str = "+" + getDerivative().getCoeff() + "*x";
            }else {
                str = "+" + getDerivative().getCoeff() + "*x^" + getDerivative().getIndex();
            }
        }else {
            if(getDerivative().getIndex().compareTo(n) == 0) {
                str = getDerivative().getCoeff() + str;
            }else if(getDerivative().getIndex().compareTo(m) == 0) {
                    str = getDerivative().getCoeff() + "*x";
            }else {
                str = getDerivative().getCoeff() + "*x^" + getDerivative().getIndex();
            }
        }
        return str;
    }
}
class ConstantTerm extends Term{
    BigInteger value;
    ConstantTerm(){
    }
    public ConstantTerm(BigInteger value){
        this.value = value;
    }
    public void setValue(BigInteger value) {
        this.value = value;
    }
    public ConstantTerm getDerivative() {
        ConstantTerm constantTerm=new ConstantTerm();
        BigInteger x= new BigInteger("0");
        constantTerm.setValue(x);
        return constantTerm;
    }
    public String toString() {
        return "";
    }
}
class Polynomial{
    String item;
    Polynomial(){
    }
    public Polynomial(String item){
        this.item = item;
    }
    public boolean isInteger(String str) {
        if(str.matches("^(([+-]?)([0-9]|([1-9][0-9]*)))")) {
            return true;
        }else {
            return false;
        }
    }
    public LinkedList<Term> getPolynomial(String str){
        LinkedList<Term> list = new LinkedList<Term>();
        if(str.charAt(0) == '+') {
            String strin = "";
            for(int j = 1;j < str.length();j++) {
                strin = strin+str.charAt(j);
            }
            String[] ptr = strin.split("\\+");
            for(int i = 0;i < ptr.length;i++) {
                if(isInteger(ptr[i])) {
                    BigInteger big = new BigInteger(ptr[i],10);
                    list.add(new ConstantTerm(big));
                }else {
                    list.add(new PowerFunctionTerm(getCoeff(ptr[i]),getIndex(ptr[i])));
                }
            }
        }
        return list;
    }
    public BigInteger getCoeff(String str) {
        if(str.charAt(0) == 'x') {
            BigInteger big = new BigInteger("1");
            return big;
        }else {
            String x = "";
            for(int i = 0;i < str.length();i++) {
                if(str.charAt(i) != '*'&&str.charAt(i) != 'x') {
                    x = x + str.charAt(i);
                }else {
                    break;
                }
            }
            BigInteger big1 = new BigInteger(x,10);
            return big1;
        }
    }
    public BigInteger getIndex(String  str) {
        int i;
        for(i = 0;i < str.length();i++) {
            if( str.charAt(i) == 'x')
                break;
        }
        if(i == str.length()-1) {
            BigInteger big = new BigInteger("1");
            return big;
        }else {
            String x = "";
            for(i = i + 2;i < str.length();i++) {
                x = x + str.charAt(i);
            }
            BigInteger big1 = new BigInteger(x,10);
            return big1;
        }
    }
    
    public boolean isPolynomial() {
        if(item.replace(" ", "").matches(polynomial())) {
            return true;
        }else {
            return false;
        }
    }
    public String polynomial() {
        String str = "";
        str = "^([+-]?([0-9]+)([\\*]?)x*(\\^[+-]?[0-9]+)?)+";
        return str;
    }
}

本题代码出现了很多错误（代码仅供参考），对于正则表达式、数组的掌握还不够，也不够了解继承。思路不清晰，不知道如何进行解题。

3.踩坑心得

源码提交过程中的问题：

1.对PTA的提交规则不了解，刚开始提交作业将package也提交了，导致程序编译错误；

2.对PTA的提交规则不了解，刚开始提交作业的时候没有把类名改为Main，导致程序编译错误；

3.多个类提交时，没有删除其他类的public，导致程序格式错误；

4.代码在编译器上运行无误，提交时答案错误，需要善于利用PTA的自定义测试；

5.一元多项式求导其中一个测试点能过，其他的的测试点过不去。

总结：由于这是完成作业后的总结blog，所以只有部分截图，望谅解。

前N天测试结果如下：

 

 定义日期类测试如下：

 

 一元多项式求导测试如下：

 

4.改进建议

对于题目而言感觉没什么问题，但是定义日期类我感觉有点不懂，为什么要使用mon_maxnum数组，因为年份分为闰年和平年，使用数组需要时刻对数组中2月份的值进行更改，感觉可以不使用数组，而是直接进行输出。

5.总结

本阶段三次题目集，让我对于Java编程有了一个简单的了解，能够自主编写简单的Java程序;对于类与对象也有了一个深刻的了解，懂得了如何调用类，调用不同类的方法；本阶段也让我对于类的封装性有了一个清晰的认识，将类中的属性设为私有，通过get和set对对象的属性值进行操作。在进行一元多项式求导的程序编写时，学会了如何分割字符串，通过spilt方法来对字符串进行分割，分割后存入字符数组。并且学会了replace方法，使用replace方法除去字符串中的空格。但是这阶段的学习，我对于正则表达式还是不够了解，对于ArrayList数组并不了解，不能熟练使用，知识点过于薄弱，之后的需要好好学习正则表达式和ArrayList数组。关于课程方面的建议，我觉得这种上课方式挺适合我的，例题解析进行知识点讲解，生动形象。这一小阶段的Java已经结束了，但是我许要学的还有很多，加油！