初窥门槛——菜鸟的第二次blog作业

我的第二次博客作业

 

一. 前言——以过来人的眼光看这几次作业；

 

题目集4：

我只拿到了88分，面对这题量少，难度大的题我只能say一声sorry，太遗憾了，第一题如果我当时就学会了正则，也许我会拿到满分，可那是如果，当时的我，对一连串的古怪符号望而却步，我没学会，更别说应用其到题目中，于是那个错误格式的测试点我始终没有过。无奈了。后面两题测试点过多，有时候你就按着他的测试点比对，都不知道自己错在哪，我果然还不是一个合格的程序员，我的耐心还需要锻炼，而不是放弃那几个测试点。

题目集5：

这次题目集就是对正则的应用了，题量少，难度小，与上次相比宛若云泥之别。我学会了三种正则表达式的应用，如Patten的mathes方法，或是构造一个匹配器，Pattern p = new Pattern.compiles;Mather m = new

Mather(),还有对Mather的查找，遍历等等。除了最后一题比较难之外，前四题就是基础运用。

题目集6：

这次题目集包含了对正则的进阶运用以及多个测试点的进一步训练，上一个题目集4已经是很难了，这次甚至还不说明测试点是什么，只能靠我们一个一个测试，老师说的对，我们以后编程的时候，需要我们debug了，难道甲方会告诉我们测试点在哪吗。我深以为然，并为之做出了奋斗。我花费一天把比较简单的第一题和第三题写出来后，花费了两个通宵，测试他们没过的部分测试点，这个第二题我是没有时间了，我还有一些其他事情，所以没有写完整第二题的所有情况，选项四和选项五我没有写，只拿到了基本分60分多一点。下次我一定会抱着精研严谨的变成思想，与他们奋战到底。

（OPP）期中考试：

这三道题是连环的迭代，一次比一次要求多一点，第一次实现Set和Get，以及ShowDate的方法，比较简单，第二次是需要编写上一次题目的类的父类，而且是抽象类，需要用到抽象方法，实现继承，多态与泛化；第三次便是用到ArrayList方法，将各个类的对象装在ArrayLiast里，因为我是现场开始学的缘故，时间不太够，测试点我无法一个一个试验了，故没有拿到满分，只拿到了84分。是我们班的平均成绩而已。

 

二——我的不太成熟的设计与分析

 

点线形系列一——两点之间的距离；

这题主要难在，输入与输出格式的正确的判断，毫无疑问，正则是最好的判断方式，但当时我的设计是用indexof，charAt，和subString等一系列String自带的方法进行的，代码长度不说，还很繁琐，可阅读性不强。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        String s1 = "";
        String s2 = "";
        if(str.contains(" ")) {
            s1 = str.substring(0,str.indexOf(" "));
            s2 = str.substring(str.indexOf(" ")+1);
        }
        else {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        if(s2.length() == 0) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        if(s2.contains(" ")) {
            System.out.println("wrong number of points");
            System.exit(0);
        }
        double x1 = 0;
        double x2 = 0;
        double y1 = 0;
        double y2 = 0;
        if(s1.indexOf(",",1) > 0 && s1.indexOf(",",1) < s1.length() - 1 && s2.indexOf(",",1) > 0 && s2.indexOf(",",1) < s2.length() - 1 && s1.indexOf(",") == s1.lastIndexOf(",") && s2.indexOf(",") == s2.lastIndexOf(",")) {
            for(int i =0;i < s1.length();i++) {
                if(s1.charAt(i) != '+' && s1.charAt(i) != '-' && s1.charAt(i) != ',' && s1.charAt(i) != '.' && s1.charAt(i) < '0' && s1.charAt(i) > '9') {
                    System.out.println("Wrong Format");
                    System.exit(0);
                }
            }
            if(s1.substring(0,s1.indexOf(",")).indexOf("+") != s1.lastIndexOf("+",s1.indexOf(",")) || s2.substring(0,s2.indexOf(",")).indexOf("+") != s2.lastIndexOf("+",s2.indexOf(",")) || s1.substring(s1.indexOf(",")).indexOf("+") != s1.substring(s1.indexOf(",")).lastIndexOf("+") || s2.substring(s2.indexOf(",")).indexOf("+") != s2.substring(s2.indexOf(",")).lastIndexOf("+") ||
                    s1.substring(0,s1.indexOf(",")).indexOf("-") != s1.lastIndexOf("-",s1.indexOf(",")) || s2.substring(0,s2.indexOf(",")).indexOf("-") != s2.lastIndexOf("-",s2.indexOf(",")) || s1.substring(s1.indexOf(",")).indexOf("-") != s1.substring(s1.indexOf(",")).lastIndexOf("-") || s2.substring(s2.indexOf(",")).indexOf("-") != s2.substring(s2.indexOf(",")).lastIndexOf("-") ||
                    s1.substring(0,s1.indexOf(",")).indexOf(".") != s1.lastIndexOf(".",s1.indexOf(",")) || s2.substring(0,s2.indexOf(",")).indexOf(".") != s2.lastIndexOf(".",s2.indexOf(",")) || s1.substring(s1.indexOf(",")).indexOf(".") != s1.substring(s1.indexOf(",")).lastIndexOf(".") || s2.substring(s2.indexOf(",")).indexOf(".") != s2.substring(s2.indexOf(",")).lastIndexOf(".")) {
                System.out.println("Wrong Format1");
                System.exit(0);
            }
            if(s1.contains(".") && ((s1.charAt(s1.indexOf(".")-1) < '0'||s1.charAt(s1.indexOf(".")+1) > '9') || (s1.charAt(s1.indexOf(".")-1) < '0'||s1.charAt(s1.indexOf(".")+1) > '9')) && ((s1.charAt(s1.lastIndexOf(".")-1) < '0'||s1.charAt(s1.lastIndexOf(".")+1) > '9') || (s1.charAt(s1.lastIndexOf(".")-1) < '0'||s1.charAt(s1.lastIndexOf(".")+1) > '9'))) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            if(s2.contains(".") && ((s2.charAt(s2.indexOf(".")-1) < '0'||s2.charAt(s2.indexOf(".")+1) > '9') || (s2.charAt(s2.indexOf(".")-1) < '0'||s2.charAt(s2.indexOf(".")+1) > '9')) && ((s2.charAt(s2.lastIndexOf(".")-1) < '0'||s2.charAt(s2.lastIndexOf(".")+1) > '9') || (s2.charAt(s2.lastIndexOf(".")-1) < '0'||s2.charAt(s2.lastIndexOf(".")+1) > '9'))) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            if(s1.contains("+") && (s1.indexOf("+") != 0 && s1.indexOf("+") != s1.indexOf(",")+1) && (s1.lastIndexOf("+") != 0 && s1.lastIndexOf("+") != s1.lastIndexOf(",")+1)) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            if(s2.contains("+") && (s2.indexOf("+") != 0 && s2.indexOf("+") != s2.indexOf(",")+1) && (s2.lastIndexOf("+") != 0 && s2.lastIndexOf("+") != s2.lastIndexOf(",")+1)) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            if(s1.contains("-") && (s1.indexOf("-") != 0 && s1.indexOf("-") != s1.indexOf(",")+1) && (s1.lastIndexOf("-") != 0 && s1.lastIndexOf("-") != s1.lastIndexOf(",")+1)) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            if(s2.contains("-") && (s2.indexOf("-") != 0 && s2.indexOf("-") != s2.indexOf(",")+1) && (s2.lastIndexOf("-") != 0 && s2.lastIndexOf("-") != s2.lastIndexOf(",")+1)) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            if(((s1.indexOf("+",0) > -1 || s1.indexOf("-",0) > -1) && (s1.charAt(s1.indexOf("+")+1) >= '0' && s1.charAt(s1.indexOf("+")+1) <= '9'||s1.charAt(s1.indexOf("-")+1) >= '0' && s1.charAt(s1.indexOf("-")+1) <= '9'))||s1.indexOf("+",0) == -1 && s1.indexOf("-",0) == -1) {
                x1 = Double.parseDouble(s1.substring(0,s1.indexOf(",")));
            }
            if(((s1.indexOf("+",s1.indexOf(",")) > -1 || s1.indexOf("-",s1.indexOf(",")) > -1) && (s1.charAt(s1.lastIndexOf("+")+1) >= '0' && s1.charAt(s1.lastIndexOf("+")+1) <= '9'||s1.charAt(s1.lastIndexOf("-")+1) >= '0' && s1.charAt(s1.lastIndexOf("-")+1) <= '9'))||s1.indexOf("+",s1.indexOf(",")) == -1 && s1.indexOf("-",s1.indexOf(",")) == -1) {
                y1 = Double.parseDouble(s1.substring(s1.indexOf(",")+1));
            }
            if(((s2.indexOf("+",0) > -1 || s2.indexOf("-",0) > -1) && (s2.charAt(s2.indexOf("+")+1) >= '0' && s2.charAt(s2.indexOf("+")+1) <= '9'||s2.charAt(s2.indexOf("-")+1) >= '0' && s2.charAt(s2.indexOf("-")+1) <= '9'))||s2.indexOf("+",0) == -1 && s2.indexOf("-",0) == -1) {
                x2 = Double.parseDouble(s2.substring(0,s2.indexOf(",")));
            }
            if(((s2.indexOf("+",s2.indexOf(",")) > -1 || s2.indexOf("-",s2.indexOf(",")) > -1) && (s2.charAt(s2.lastIndexOf("+")+1) >= '0' && s2.charAt(s2.lastIndexOf("+")+1) <= '9'||s2.charAt(s2.lastIndexOf("-")+1) >= '0' && s2.charAt(s2.lastIndexOf("-")+1) <= '9'))||s2.indexOf("+",s2.indexOf(",")) == -1 && s2.indexOf("-",s2.indexOf(",")) == -1) {
                y2 = Double.parseDouble(s2.substring(s2.indexOf(",")+1));
            }
            if(x1 != 0 && y1 != 0 && x2 != 0 && y2 != 0) {
                System.out.println(Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)));
                System.exit(0);
            }
            else {
                System.out.println("Wrong Format");
            }
        }
        else {
            System.out.println("Wrong Format");
        }
    }
}

点线形系列一——线的计算；

我的主要思路是，根据数学方法 ，有没有简单易实现且变量可以提取的公式去应用，以数学思想写编程；先是用正则的split分割选项与输入的点，查看格式正确与否，再将得到的点的x值与y值代入线的公式，得出最终答案；我主要写了三个类，主类main，一个check看格式是否正确，一个dot带入方法

import java.util.Scanner;
public class Main {
    public static void main(String[] args)
    {
        Scanner in=new Scanner(System.in);
        String s=in.nextLine();
        if(Check.islegal(s)==1)
        {
            Dot.setString(s);
        }
    }
}
class Dot{
    double x;
    double y;
    public static void setString(String s) {
        String[] a = s.split(":");
        String[] b = a[1].split("\\s");
        Dot[] dot = new Dot[b.length];
        for (int i = 0; i < b.length; i++) {
            String[] c = b[i].split(",");
            dot[i] = new Dot();
            dot[i].x = Double.parseDouble(c[0]);
            dot[i].y = Double.parseDouble(c[1]);
            //System.out.println(dot[i].x+" "+dot[i].y);
        }
        if (a[0].charAt(0) == '1') {
            if (dot[0].x == dot[1].x && dot[0].y == dot[1].y)
            {
                System.out.println("points coincide");
            }
            else if (dot[0].x == dot[1].x)
            {
                System.out.println("Slope does not exist");
            }
            else {
                double A = (dot[1].y - dot[0].y) / (dot[1].x - dot[0].x);
                System.out.println(A);
            }
        }
        if (a[0].charAt(0) == '2') {
            if (dot[1].x == dot[2].x && dot[1].y == dot[2].y)
            {
                System.out.println("points coincide");
            }
            else
            {
                if (dot[1].x != dot[2].x) {
                    double A = (dot[2].y - dot[1].y) / (dot[2].x - dot[1].x);
                    double C = dot[1].y - A * dot[1].x;
                    double d = Math.abs(A * dot[0].x - dot[0].y + C) / Math.sqrt(A * A + 1);
                    System.out.println(d);
                }
                else if(dot[1].x==dot[2].x)
                {
                    double d=Math.abs(dot[0].x-dot[1].x);
                    System.out.println(d);
                }
            }
        }
        if (a[0].charAt(0) == '3') {
            if ((dot[0].x == dot[1].x && dot[0].y == dot[1].y) || (dot[0].x == dot[2].x && dot[0].y == dot[2].y) || (dot[1].x == dot[2].x && dot[1].y == dot[2].y)) {
                System.out.println("points coincide");
            }
            else
            {
                if(dot[2].x!=dot[1].x) {
                    double A = (dot[2].y - dot[1].y) / (dot[2].x - dot[1].x);
                    double C = dot[1].y - A * dot[1].x;
                    double result = A * dot[0].x + dot[0].y + C;
                    if (result == 0)
                        System.out.println("true");
                    else
                        System.out.println("false");
                }
                else if(dot[2].x==dot[1].x)
                {
                    if(dot[0].x==dot[1].x)
                        System.out.println("true");
                    else
                        System.out.println("false");
                }
            }
        }
        if (a[0].charAt(0) == '4') {
            if ((dot[0].x == dot[1].x && dot[0].y == dot[1].y) || (dot[2].x == dot[3].x && dot[2].y == dot[3].y))
            {
                System.out.println("points coincide");
            }
            else
            {
                double A1 = (dot[1].y - dot[0].y) / (dot[1].x - dot[0].x);
                double A2 = (dot[3].y - dot[2].y) / (dot[3].x - dot[2].x);
                if (A1 == A2)
                    System.out.println("true");
                else
                    System.out.println("false");
            }
        }
        if(a[0].charAt(0)=='5')
        {
            if((dot[0].x==dot[1].x&&dot[0].y==dot[1].y)||(dot[2].x==dot[3].x&&dot[2].y==dot[3].y))
            {
                System.out.println("points coincide");
            }
            else
            {
                double y1,y2,x1,x2,a1,a2,e;
                y1=dot[1].y-dot[0].y;
                y2=dot[3].y-dot[2].y;
                x1=dot[1].x-dot[0].x;
                x2=dot[3].x-dot[2].x;
                a1=x1*dot[0].y-y1*dot[0].x;
                a2=x2*dot[2].y-y2*dot[2].x;
                e=y1*x2-y2*x1;
                double x=(x1*a2-x2*a1)/e;
                double y=(y1*a2-y2*a1)/e;
                if(e==0)
                {
                    System.out.println("is parallel lines,have no intersection point");
                }
                else
                {
                    double max,min,max1,min1;
                    if(dot[3].y>dot[2].y)
                    {
                        max=dot[3].y;
                        min=dot[2].y;
                    }
                    else
                    {
                        max=dot[2].y;
                        min=dot[3].y;
                    }
                    if(dot[1].y>dot[0].y)
                    {
                        max1=dot[1].y;
                        min1=dot[0].y;
                    }
                    else
                    {
                        max1=dot[0].y;
                        min1=dot[1].y;
                    }
                    if((y>min&&y<max)||(y>min1&&y<max1))
                    {
                        System.out.print(x+","+y+" ");
                        System.out.println("true");
                    }
                    else
                    {
                        System.out.print(x+","+y+" ");
                        System.out.println("false");
                    }
                }
            }
        }
    }
}
class Check{
    public static int islegal(String s)
    {
        int count;
        int count1=0;
        int count2=0;
        int count3=0;
        int flag=0;
        int flag1=0;
        int dotnum=0;
        String[] a=s.split(":");
        
         if(s.charAt(0)=='2'||s.charAt(0)=='3')
        {
            dotnum=3;
        }
        else if(s.charAt(0)=='4'||s.charAt(0)=='5')
        {
            dotnum=4;
        }
        if(s.charAt(0)>='0'&&s.charAt(0)<='5'&&s.charAt(1)!=':')
        {
            flag=1;
            dotnum=5;
        }
        char[] n=s.toCharArray();
        for(int i=0;i<n.length;i++)
        {
            if(n[i]==':')
                count2++;
        }
        if(count2>=2)
        {
            flag=1;
        }
        char[] c=a[1].toCharArray();
        for(int i=0;i<c.length;i++)
        {
            if(c[i]==','&&c[i+1]==',')
            {
                count1++;
            }
            if(c[i]==' '&&c[i+1]==' ')
            {
                count3++;
            }
        }
        String[] p=a[1].split("\\s");
        if(p.length!=dotnum)
        {
            flag1=1;
        }
        if(count1>=1)
        {
            flag=1;
        }
        if(count3>=1)
        {
            flag=1;
        }
        else {
            String b[] = a[1].split("\\s");
            if (count2 < 2) {
                for (int i = 0; i < b.length; i++) {
                    String[] m = b[i].split(",");
                    if (m.length > dotnum) {
                        flag = 1;
                    }
                    for (int j = 0; j < m.length; j++) {
                        count = 0;
                        for (int k = 0; k < m[j].length(); k++) {
                            if (m[j].charAt(k) == '.') {
                                count++;
                                if (k + 1 == m[j].length())
                                    flag = 1;
                            }
                        }
                        if (count >= dotnum) {
                            flag = 1;
                        }
                        if (m[j].charAt(0) == '+' || m[j].charAt(0) == '-') {
                            if (m[j].charAt(1) < '0' || m[j].charAt(1) > '9') {
                                flag = 1;
                            }
                            if (m[j].charAt(1) == '0' && m[j].length() > 2)
                                if (m[j].charAt(1) == '0' && m[j].charAt(2) != '.')
                                    flag = 1;
                        }
                        if (m[j].charAt(0) == '0' && m[j].length() > 1) {
                            if (m[j].charAt(0) == '0' && m[j].charAt(1) != '.')
                                flag = 1;
                        }
                    }
                }
            }
        }
        if(flag==1)
        {
            System.out.println("Wrong Format");
        }
        else if(flag1==1&&flag==0)
        {
            System.out.println("wrong number of points");
        }
        else
            return 1;
        return 0;
    }
}

 

点线形系列一——三角形的计算；

刚开始与第二题类似，都用split方法来分割选项与点的坐标；接着我构思了一个check类查看选项；一个dot来实现选项中的操作，因为想省事，dot类里把所有选项的方法几乎都包括了，其中判断三角形的方法，大部分都是和斜率有关系，于是第二题的代码也可以copy一些；

import java.util.Scanner;
public class Main {
    public static void main(String[] args)
    {
        Scanner in=new Scanner(System.in);
        String s=in.nextLine();
        if(Check.islegal(s)==1)
        {
            Dot.setString(s);
        }
    }
}
class Dot{
    double x;
    double y;
    Dot(double x,double y)
    {
        this.x=x;
        this.y=y;
    }
    public static void setString(String s)
    {
        String[] a = s.split(":");
        String[] b = a[1].split("\\s");
        Dot[] dot = new Dot[b.length];
        for (int i = 0; i < b.length; i++) {
            String[] c = b[i].split(",");
            dot[i] = new Dot(Double.parseDouble(c[0]),Double.parseDouble(c[1]));
            //System.out.println(dot[i].x+" "+dot[i].y);
        }
        if(a[0].charAt(0)=='1')
        {
            double l1,l2,l3;
            l1=Math.sqrt((dot[1].x-dot[0].x)*(dot[1].x-dot[0].x)+(dot[1].y-dot[0].y)*(dot[1].y-dot[0].y));
            l2=Math.sqrt((dot[2].x-dot[0].x)*(dot[2].x-dot[0].x)+(dot[2].y-dot[0].y)*(dot[2].y-dot[0].y));
            l3=Math.sqrt((dot[2].x-dot[1].x)*(dot[2].x-dot[1].x)+(dot[2].y-dot[1].y)*(dot[2].y-dot[1].y));
            if(l1+l2<=l3||l1+l3<=l2||l2+l3<=l1||(dot[0].x==dot[1].x&&dot[1].x==dot[2].x)||(dot[0].y==dot[1].y&&dot[1].y==dot[2].y)) {
                System.out.println("data error");
            }
            else {
                if (l1 == l2 || l1 == l3 || l2 == l3) {
                    System.out.print("true ");
                } else {
                    System.out.print("false ");
                }
                if (l1 == l2 && l2 ==l3) {
                    System.out.print("true");
                } else {
                    System.out.print("false");
                }
            }
        }
        if(a[0].charAt(0)=='2')
        {
            double l1=Math.sqrt((dot[1].x-dot[0].x)*(dot[1].x-dot[0].x)+(dot[1].y-dot[0].y)*(dot[1].y-dot[0].y));
            double l2=Math.sqrt((dot[2].x-dot[0].x)*(dot[2].x-dot[0].x)+(dot[2].y-dot[0].y)*(dot[2].y-dot[0].y));
            double l3=Math.sqrt((dot[2].x-dot[1].x)*(dot[2].x-dot[1].x)+(dot[2].y-dot[1].y)*(dot[2].y-dot[1].y));
            if(l1+l2<=l3||l1+l3<=l2||l2+l3<=l1||(dot[0].x==dot[1].x&&dot[1].x==dot[2].x)||(dot[0].y==dot[1].y&&dot[1].y==dot[2].y))
            {
                System.out.println("data error");
            }
            else {
                double L = l1 + l2 + l3;
                double S = (dot[0].x * dot[1].y + dot[1].x * dot[2].y + dot[2].x * dot[0].y - dot[0].x * dot[2].y - dot[1].x * dot[0].y - dot[2].x * dot[1].y) / 2;
                double x = (dot[0].x + dot[1].x + dot[2].x) / 3;
                double y = (dot[0].y + dot[1].y + dot[2].y) / 3;
                double num[] = {L, S, x, y};
                String[] m = new String[4];
                int count = 0;
                for (int i = 0; i < 4; i++) {
                    String str = num[i] + "";
                    int n = str.length() - (str.indexOf(".") + 1);
                    if (n > 6) {
                        m[count] = String.format("%.6f", num[i]);
                        count++;
                    }
                    else
                    {
                        m[count] = num[i] + "";
                        count++;
                    }
                }
                System.out.print(m[0] + " " + m[1] + " " + m[2] + ',' + m[3]);
            }
        }
        if(a[0].charAt(0)=='3')
        {
            double l1=Math.sqrt((dot[1].x-dot[0].x)*(dot[1].x-dot[0].x)+(dot[1].y-dot[0].y)*(dot[1].y-dot[0].y));
            double l2=Math.sqrt((dot[2].x-dot[0].x)*(dot[2].x-dot[0].x)+(dot[2].y-dot[0].y)*(dot[2].y-dot[0].y));
            double l3=Math.sqrt((dot[2].x-dot[1].x)*(dot[2].x-dot[1].x)+(dot[2].y-dot[1].y)*(dot[2].y-dot[1].y));
            if(l1+l2<=l3||l1+l3<=l2||l2+l3<=l1||(dot[0].x==dot[1].x&&dot[1].x==dot[2].x)||(dot[0].y==dot[1].y&&dot[1].y==dot[2].y)) {
                System.out.println("data error");
            }
            else {
                if (l1*l1+l2*l2<l3*l3-0.001||l1*l1+l3*l3<l2*l2-0.001||l2*l2+l3*l3<l1*l1-0.001)
                    System.out.print("true ");
                else
                    System.out.print("false ");
                if (Math.abs(l1*l1+l2*l2-l3*l3)<0.001||Math.abs(l1*l1+l3*l3-l2*l2)<0.001||Math.abs(l2*l2+l3*l3-l1*l1)<0.001)
                    System.out.print("true ");
                else
                    System.out.print("false ");
                if (l1*l1+l2*l2>l3*l3&&l1*l1+l3*l3>l2*l2&&l2*l2+l3*l3>l1*l1)
                    System.out.print("true");
                else
                    System.out.print("false");
            }
        }
        if(a[0].charAt(0)=='4')
        {
            double l1=Math.sqrt((dot[3].x-dot[2].x)*(dot[3].x-dot[2].x)+(dot[3].y-dot[2].y)*(dot[3].y-dot[2].y));
            double l2=Math.sqrt((dot[4].x-dot[2].x)*(dot[4].x-dot[2].x)+(dot[4].y-dot[2].y)*(dot[4].y-dot[2].y));
            double l3=Math.sqrt((dot[4].x-dot[3].x)*(dot[4].x-dot[3].x)+(dot[4].y-dot[3].y)*(dot[4].y-dot[3].y));
            if (dot[0].x == dot[1].x && dot[0].y == dot[1].y) {
                System.out.println("points coincide");
            }
            else {
                if (l1 + l2 <= l3 || l1 + l3 <= l2 || l2 + l3 <= l1 || (dot[2].x == dot[3].x && dot[3].x == dot[4].x) || (dot[2].y == dot[3].y && dot[3].y == dot[4].y)) {
                    System.out.println("data error");
                }
                else
                {
                    double A = (dot[1].y - dot[0].y) / (dot[1].x - dot[0].x);
                    double C = dot[0].y - A * dot[0].x;
                    double A1 = (dot[3].y - dot[2].y) / (dot[3].x - dot[2].x);
                    double C1 = dot[2].y - A1 * dot[2].x;
                    double A2 = (dot[4].y - dot[2].y) / (dot[4].x - dot[2].x);
                    double C2 = dot[2].y - A2 * dot[2].x;
                    double A3 = (dot[4].y - dot[3].y) / (dot[4].x - dot[3].x);
                    double C3 = dot[3].y - A3 * dot[3].x;
                    if((A==A1&&C==C1)||(A==A2&&C==C2)||(A==A3&&C==C3))
                    {
                        System.out.println("The point is on the edge of the triangle");
                    }
                    else
                    {
                        int dotnum=0;
                        int num1=0;
                        int num2=0;
                        int num3=0;
                        Dot d1=calcudot(dot[0],dot[1],dot[2],dot[3]);
                        Dot d2=calcudot(dot[0],dot[1],dot[2],dot[4]);
                        Dot d3=calcudot(dot[0],dot[1],dot[3],dot[4]);
                        if(isin(dot[2],dot[3],d1)) {
                            num1=1;
                            dotnum++;
                        }
                        if(isin(dot[2],dot[4],d2)) {
                            dotnum++;
                            num2=1;
                        }
                        if(isin(dot[3],dot[4],d3)) {
                            dotnum++;
                            num3=1;
                        }
                        if(d1.x==d2.x&&d1.y==d2.y) {
                            dotnum--;
                            num1=0;
                            num2=0;
                        }
                        if(d1.x==d3.x&&d1.y==d3.y) {
                            dotnum--;
                            num1=0;
                            num3=0;
                        }
                        if(d2.x==d3.x&&d2.y==d3.y) {
                            dotnum--;
                            num2=0;
                            num3=0;
                        }
                        if(dotnum==1||dotnum==0)
                            System.out.println(dotnum);
                        else
                        {
                            double S = Math.abs(dot[2].x * dot[3].y + dot[3].x * dot[4].y + dot[4].x * dot[2].y - dot[2].x * dot[4].y - dot[3].x * dot[2].y - dot[4].x * dot[3].y) / 2;
                            double S1=0;
                            double S2;
                            if(num1==1&&num2==1)
                            {
                                S1 = Math.abs(d1.x * d2.y + d2.x * dot[2].y + dot[2].x * d1.y - d1.x * dot[2].y - d2.x * d1.y - dot[2].x * d2.y) / 2;
                            }
                            else if(num1==1&&num3==1)
                            {
                                S1 = Math.abs(d1.x * d3.y + d3.x * dot[3].y + dot[3].x * d1.y - d1.x * dot[3].y - d3.x * d1.y - dot[3].x * d3.y) / 2;
                            }
                            else if(num2==1&&num3==1)
                            {
                                S1 = Math.abs(d2.x * d3.y + d3.x * dot[4].y + dot[4].x * d2.y - d2.x * dot[4].y - d3.x * d2.y - dot[4].x * d3.y) / 2;
                            }
                            else if(num1==1&&num2==0&&num3==0)
                            {
                                S1 = Math.abs(d1.x * dot[3].y + dot[3].x * dot[4].y + dot[4].x * d1.y - d1.x * dot[4].y - dot[3].x * d1.y - dot[4].x * dot[3].y) / 2;
                            }
                            else if(num2==1&&num1==0&&num3==0)
                            {
                                S1 = Math.abs(d2.x * dot[3].y + dot[3].x * dot[2].y + dot[2].x * d2.y - d2.x * dot[2].y - dot[3].x * d2.y - dot[2].x * dot[3].y) / 2;
                            }
                            else if(num3==1&&num1==0&&num2==0)
                            {
                                S1 = Math.abs(d3.x * dot[3].y + dot[3].x * dot[2].y + dot[2].x * d3.y - d3.x * dot[2].y - dot[3].x * d3.y - dot[2].x * dot[3].y) / 2;
                            }
                            if(S-S1<S1)
                            {
                                S2=S1;
                                S1=S-S1;
                            }
                            else
                            {
                                S2=S-S1;
                            }
                            double num[] = {S1,S2};
                            String[] m = new String[2];
                            int count = 0;
                            for (int i = 0; i < 2; i++) {
                                String str = num[i] + "";
                                int n = str.length() - (str.indexOf(".") + 1);
                                if (n > 6) {
                                    m[count] = String.format("%.6f", num[i]);
                                    count++;
                                }
                                else
                                {
                                    m[count] = num[i] + "";
                                    count++;
                                }
                            }
                            System.out.println("2 "+m[0]+" "+m[1]);
                        }
                    }
                }
            }
        }
        if(a[0].charAt(0)=='5')
        {
            double l1=Math.sqrt((dot[2].x-dot[1].x)*(dot[2].x-dot[1].x)+(dot[2].y-dot[1].y)*(dot[2].y-dot[1].y));
            double l2=Math.sqrt((dot[3].x-dot[1].x)*(dot[3].x-dot[1].x)+(dot[3].y-dot[1].y)*(dot[3].y-dot[1].y));
            double l3=Math.sqrt((dot[3].x-dot[2].x)*(dot[3].x-dot[2].x)+(dot[3].y-dot[2].y)*(dot[3].y-dot[2].y));
            if(l1+l2<=l3||l1+l3<=l2||l2+l3<=l1||(dot[1].x==dot[2].x&&dot[2].x==dot[3].x)||(dot[1].y==dot[2].y&&dot[2].y==dot[3].y)){
                System.out.println("data error");
            }
            else
            {
                int i,j;
                int flag=0;
                boolean redo,inside;
                redo=true;
                for(i=1;i<4;i++)
                {
                    if(dot[0].x==dot[i].x&&dot[0].y==dot[i].y)
                    {
                        redo=false;
                        inside=true;
                        System.out.println("on the triangle");
                        break;
                    }
                }
                while (redo)
                {
                    redo = false;
                    inside = false;
                    for (i = 1,j =3;i <4;j=i++)
                    {
                        if ( (dot[i].y < dot[0].y && dot[0].y < dot[j].y) || (dot[j].y < dot[0].y && dot[0].y < dot[i].y) )
                        {
                            if(dot[0].x <= dot[i].x || dot[0].x <= dot[j].x)
                            {
                                double x = (dot[0].y-dot[i].y)*(dot[j].x-dot[i].x)/(dot[j].y-dot[i].y)+dot[i].x;
                                if (dot[0].x <x)
                                {
                                    System.out.println("in the triangle");
                                    inside = !inside;
                                }
                                else if (dot[0].x==x)
                                {
                                    System.out.println("on the triangle");
                                    inside = true;
                                    break;
                                }
                                else
                                {
                                    System.out.println("outof the triangle");
                                    inside=false;
                                }
                            }
                        }
                        else if ( dot[0].y ==dot[i].y)
                        {
                            if (dot[0].x < dot[i].x)
                            {
                                System.out.println("outof the triangle");
                                redo = true;
                                flag=1;
                                break;
                            }
                        }
                        else if (dot[i].y==dot[j].y &&dot[0].y == dot[i].y && ( (dot[i].x < dot[0].x && dot[0].x < dot[j].x) || (dot[j].x < dot[0].x && dot[0].x < dot[i].x) ) )
                        {
                            System.out.println("in the triangle");
                            inside = true;
                            break;
                        }
                    }
                }
            }
        }
    }
    public static Dot calcudot(Dot d1,Dot d2,Dot d3,Dot d4)
    {
        double y1,y2,x1,x2,a1,a2,e;
        y1=d2.y-d1.y;
        y2=d4.y-d3.y;
        x1=d2.x-d1.x;
        x2=d4.x-d3.x;
        a1=x1*d1.y-y1*d1.x;
        a2=x2*d3.y-y2*d3.x;
        e=y1*x2-y2*x1;
        double x=(x1*a2-x2*a1)/e;
        double y=(y1*a2-y2*a1)/e;
        Dot p1=new Dot(x,y);
        return p1;
    }
    public static Boolean isin(Dot d1,Dot d2,Dot d3)
    {
        if(d3.y<=Math.max(d1.y,d2.y)&&d3.y>=Math.min(d1.y,d2.y))
        {
            return true;
        }
        return false;
    }
}
class Check{
    public static int islegal(String s)
    {
        int count;
        int count1=0;
        int count2=0;
        int count3=0;
        int count4=0;
        int flag=0;
        int flag1=0;
        int dotnum=0;
        String[] a=s.split(":");
        if(s.charAt(0)=='1'||s.charAt(0)=='2'||s.charAt(0)=='3')
        {
            dotnum=3;
        }
        else if(s.charAt(0)=='4')
        {
            dotnum=5;
        }
        else if (s.charAt(0) =='5') {
            dotnum=4;
        }
        if(s.charAt(0)>='0'&&s.charAt(0)<='5'&&s.charAt(1)!=':')
        {
            flag=1;
            dotnum=10;
        }
        if(s.charAt(1)==':')
        {
            count4=1;
        }
        char[] n=s.toCharArray();
        for(int i=0;i<n.length;i++)
        {
            if(n[i]==':')
                count2++;
        }
        if(count2>=2)
        {
            flag=1;
        }
        if(count2==1&&count4==1) {
            char[] c = a[1].toCharArray();
            for (int i = 0; i < c.length; i++) {
                if (c[i] == ',' && c[i + 1] == ',') {
                    count1++;
                }
                if (c[i] == ' ' && i + 1 != c.length) {
                    if (c[i + 1] == ' ')
                        count3++;
                }
            }
            if (c[c.length - 1] == ' ') {
                flag = 1;
            }
            String[] p = a[1].split("\\s");
            if (p.length != dotnum) {
                flag1 = 1;
            }
            if (count1 >= 1) {
                flag = 1;
            }
            if (count3 >= 1) {
                flag = 1;
            }
        }
        else {
            if (count4 == 1) {
                String b[] = a[1].split("\\s");
                if (count2 < 2 && count1 < 1) {
                    for (int i = 0; i < b.length; i++) {
                        String[] m = b[i].split(",");
                        if (m.length > dotnum) {
                            flag = 1;
                        }
                        for (int j = 0; j < m.length; j++) {
                            count = 0;
                            for (int k = 0; k < m[j].length(); k++) {
                                if (m[j].charAt(k) == '.') {
                                    count++;
                                    if (k + 1 == m[j].length())
                                        flag = 1;
                                }
                            }
                            if (count >= dotnum) {
                                flag = 1;
                            }
                            if (m[j].charAt(0) == '+' || m[j].charAt(0) == '-') {
                                if (m[j].charAt(1) < '0' || m[j].charAt(1) > '9') {
                                    flag = 1;
                                }
                                if (m[j].charAt(1) == '0' && m[j].length() > 2)
                                    if (m[j].charAt(1) == '0' && m[j].charAt(2) != '.')
                                        flag = 1;
                            }
                            if (m[j].charAt(0) == '0' && m[j].length() > 1) {
                                if (m[j].charAt(0) == '0' && m[j].charAt(1) != '.')
                                    flag = 1;
                            }
                        }
                    }
                }
            }
        }
        if(flag==1)
        {
            System.out.println("Wrong Format");
        }
        else if(flag1==1&&flag==0)
        {
            System.out.println("wrong number of points");
        }
        else
            return 1;
        return 0;
    }
}

点线形系列一——凸四边形的计算；

没错跨了一个正则，这个点线形系列又回来了，我的这个系列分一次比一次少；首先我觉得以后可能还会出现迭代，而且学会了正则，于是我规范化了我的代码，首先main类里直接判断选项，输入格式匹配用mathes方法，分割以及替换空格的split方法，switch方法进入选项，Quadrilateral类写入判断方法，类型boolean，我只编写了前三种选项的方法，所以分数不高。我接下来的修改将是再次编写另外两个类，受同学启发，一个关于线的判断逻辑Line类，一个判断格式正不正确的点类Point。

代码如下：

import java.text.DecimalFormat;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String string = in.nextLine();
        Quadrilateral q = new Quadrilateral();
        int count = 0;
        int choice = Integer.parseInt(string.substring(0,1));
        String str = string.substring(2);
        String ReGex = " ";
        //String Regex = "^(\\-|\\+)?\\d+(\\.\\d+)?,(\\-|\\+)?\\d+(\\.\\d+)?$";
        String Reg1 = "((\\-|\\+)?\\d+(\\.\\d+)?,(\\-|\\+)?\\d+(\\.\\d+)?\\s?){4}";
        String Reg2 = "((\\-|\\+)?\\d+(\\.\\d+)?,(\\-|\\+)?\\d+(\\.\\d+)?\\s?){5}";
        String Reg3 = "((\\-|\\+)?\\d+(\\.\\d+)?,(\\-|\\+)?\\d+(\\.\\d+)?\\s?){6}";
        String[] arr1 = str.split(ReGex);
        for(String s :arr1)
            count++;
        double[] arr2 = new double[12];
        if((choice==1||choice==2||choice==3)&&count==4 || choice==4&&count==6 || choice==5&&count==5) {
            if((choice==1||choice==2||choice==3)&&str.matches(Reg1) || choice==4&&str.matches(Reg3) || choice==5&&str.matches(Reg2)) {

                arr2[0] = Double.parseDouble(arr1[0].substring(0,arr1[0].indexOf(",")));
                arr2[1] = Double.parseDouble(arr1[0].substring(arr1[0].indexOf(",")+1));
                arr2[2] = Double.parseDouble(arr1[1].substring(0,arr1[1].indexOf(",")));
                arr2[3] = Double.parseDouble(arr1[1].substring(arr1[1].indexOf(",")+1));
                arr2[4] = Double.parseDouble(arr1[2].substring(0,arr1[2].indexOf(",")));
                arr2[5] = Double.parseDouble(arr1[2].substring(arr1[2].indexOf(",")+1));
                arr2[6] = Double.parseDouble(arr1[3].substring(0,arr1[3].indexOf(",")));
                arr2[7] = Double.parseDouble(arr1[3].substring(arr1[3].indexOf(",")+1));
                switch (choice) {
                    case 1:
                        for(int i=0 ;i < 3;i++) {
                            for(int j=i+1;j<4;j++) {
                                if(arr1[i].equals(arr1[j])) {
                                    System.out.println("points coincide");
                                    System.exit(0);
                                }
                            }
                        }
                        System.out.print(q.isQuadrilateral(arr2[0],arr2[1],arr2[2],arr2[3],arr2[4],arr2[5],arr2[6],arr2[7]));
                        System.out.println(" "+q.isParallelogram(arr2[0],arr2[1],arr2[2],arr2[3],arr2[4],arr2[5],arr2[6],arr2[7]));
                        break;
                    case 2:
                        
                        if(q.isQuadrilateral(arr2[0],arr2[1],arr2[2],arr2[3],arr2[4],arr2[5],arr2[6],arr2[7])) {
                            System.out.print(q.isRhombus(arr2[0],arr2[1],arr2[2],arr2[3],arr2[4],arr2[5],arr2[6],arr2[7]));
                            System.out.print(" "+q.isRectangle(arr2[0],arr2[1],arr2[2],arr2[3],arr2[4],arr2[5],arr2[6],arr2[7]));
                            System.out.println(" "+q.isSquare(arr2[0],arr2[1],arr2[2],arr2[3],arr2[4],arr2[5],arr2[6],arr2[7]));
                        }
                        else {
                            System.out.println("not a quadrilateral");
                        }
                        break;
                    case 3:
                        for(int i=0 ;i < 3;i++) {
                            for(int j=i+1;j<4;j++) {
                                if(arr1[i].equals(arr1[j])) {
                                    System.out.println("points coincide");
                                    System.exit(0);
                                }
                            }
                        }
                        if(q.isQuadrilateral(arr2[0],arr2[1],arr2[2],arr2[3],arr2[4],arr2[5],arr2[6],arr2[7])) {
                            System.out.print(q.isConvexQuadrilateral(arr2[0],arr2[1],arr2[2],arr2[3],arr2[4],arr2[5],arr2[6],arr2[7]));
                            System.out.print(" "+q.perimeter(arr2[0],arr2[1],arr2[2],arr2[3],arr2[4],arr2[5],arr2[6],arr2[7]));
                            System.out.println(" "+q.area(arr2[0],arr2[1],arr2[2],arr2[3],arr2[4],arr2[5],arr2[6],arr2[7]));
                        }
                        else {
                            System.out.println("not a quadrilateral");
                        }
                        break;
                    case 4:
                        System.out.println("not a quadrilateral or triangle");
                        break;
                    default:
                        System.out.println("not a quadrilateral or triangle");
                }
            }
            else {
                System.out.println("Wrong Format");
            }
        }
        else if((choice==1||choice==2||choice==3)&&count<4 || choice==4&&count<6 || choice==5&&count<5) {
            System.out.println("wrong number of points");
        }
        else {
            System.out.println("Wrong Format");
        }
    }
}
class Quadrilateral{
    public boolean isQuadrilateral(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {//四边形
        if(y1==y2 || y2==y3 || y3==y4 || y1==y4) {
            if(y1==y2&&y1!=y4&&y2!=y3 || y3==y2&&y1!=y2&&y4!=y3 || y3==y4&&y1!=y4&&y2!=y3 || y1==y4&&y1!=y2&&y4!=y3) {
                return true;
            }
            else {
                return false;
            }
        }
        else {
            double k1 = (x1-x2)/(y1-y2);
            double k2 = (x2-x3)/(y2-y3);
            double k3 = (x3-x4)/(y3-y4);
            double k4 = (x1-x4)/(y1-y4);
            if(k1 != k2 && k2 != k3 && k3 != k4 && k1 != k4) {
                return true;
            }
            else {
                return false;
            }
        }
    }
    public boolean isParallelogram(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {//平行四边形
        if(isQuadrilateral(x1, y1, x2, y2, x3, y3, x4, y4)) {
            if(y1==y2 || y2==y3 || y3==y4 || y1==y4) {
                if((x1-x2)==(x4-x3)&&y2==y1&&y3==y4 || (x1-x4)==(x2-x3)&&y2==y3&&y1==y4) {
                    return true;
                } else {
                    return false;
                }
            } else {
                double k1 = (x1-x2)/(y1-y2);
                double k2 = (x2-x3)/(y2-y3);
                double k3 = (x3-x4)/(y3-y4);
                double k4 = (x1-x4)/(y1-y4);
                if(k1 == k3 && k2 == k4) {
                    return true;
                } else {
                    return false;
                }
            }
        } else {
            return false;
        }
    }
    public boolean isRhombus(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {//菱形
        double l1 = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
        double l2 = (x3-x2)*(x3-x2)+(y3-y2)*(y3-y2);
        double l3 = (x3-x4)*(x3-x4)+(y3-y4)*(y3-y4);
        double l4 = (x1-x4)*(x1-x4)+(y1-y4)*(y1-y4);
        return (l1==l2&&l1==l3&&l1==l4);
    }
    public boolean isRectangle(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {//矩形
        if(isParallelogram(x1, y1, x2, y2, x3, y3, x4, y4)) {
            double l1 = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
            double l2 = (x4-x2)*(x4-x2)+(y4-y2)*(y4-y2);
            return (l1==l2);
        }
        else {
            return false;
        }
    }
    public boolean isSquare(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {//正方形
        return (isRectangle(x1, y1, x2, y2, x3, y3, x4, y4) && isRhombus(x1, y1, x2, y2, x3, y3, x4, y4));
    }
    public boolean isConvexQuadrilateral(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {//凸四边形
        double l1 = Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
        double l2 = Math.sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));
        double l3 = Math.sqrt((x3-x4)*(x3-x4)+(y3-y4)*(y3-y4));
        double l4 = Math.sqrt((x1-x4)*(x1-x4)+(y1-y4)*(y1-y4));
        double l5 = Math.sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3));
        double l6 = Math.sqrt((x4-x2)*(x4-x2)+(y4-y2)*(y4-y2));
        double p1 = (l1+l2+l5)/2;
        double p2 = (l3+l4+l5)/2;
        double p3 = (l1+l4+l6)/2;
        double p4 = (l3+l2+l6)/2;
        double area1 = Math.sqrt(p1*(p1-l1)*(p1-l2)*(p1-l5)) + Math.sqrt(p2*(p2-l3)*(p2-l4)*(p2-l5));
        double area2 = Math.sqrt(p3*(p3-l1)*(p3-l4)*(p3-l6)) + Math.sqrt(p4*(p4-l2)*(p4-l3)*(p4-l6));
        return (area1 == area2);
    }
    public double perimeter(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {//周长
        double l1 = Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
        double l2 = Math.sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));
        double l3 = Math.sqrt((x3-x4)*(x3-x4)+(y3-y4)*(y3-y4));
        double l4 = Math.sqrt((x1-x4)*(x1-x4)+(y1-y4)*(y1-y4));
        return Double.parseDouble(new DecimalFormat("#.###").format(l1+l2+l3+l4));
    }
    public double area(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {//面积
        double l1 = Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
        double l2 = Math.sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));
        double l3 = Math.sqrt((x3-x4)*(x3-x4)+(y3-y4)*(y3-y4));
        double l4 = Math.sqrt((x1-x4)*(x1-x4)+(y1-y4)*(y1-y4));
        double l5 = Math.sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3));
        double l6 = Math.sqrt((x4-x2)*(x4-x2)+(y4-y2)*(y4-y2));
        double p1 = (l1+l2+l5)/2;
        double p2 = (l3+l4+l5)/2;
        double p3 = (l1+l4+l6)/2;
        double p4 = (l3+l2+l6)/2;
        double area1 = Math.sqrt(p1*(p1-l1)*(p1-l2)*(p1-l5)) + Math.sqrt(p2*(p2-l3)*(p2-l4)*(p2-l5));
        double area2 = Math.sqrt(p3*(p3-l1)*(p3-l4)*(p3-l6)) + Math.sqrt(p4*(p4-l2)*(p4-l3)*(p4-l6));
        if(area1 <= area2) {
            return Double.parseDouble(new DecimalFormat("#.###").format(area1));
        }
        else {
            return Double.parseDouble(new DecimalFormat("#.###").format(area2));
        }
    }
}

超星学习通的链表练习；

双向链表与单链表相比，多了一种操作——从尾节点开始查找；其他的几乎相同，我的思路是：

在Node类里有两个数据，一个是下一个节点的地址，需要创建New出一个，一个便是Date数据；

存入——在为节点里构造一个新的Node用于指向数据的存放节点，然后数据代入Date；

删除——让上一个节点的为节点跳过Index节点，直接指向下下个地址；

类图如下：

 

 部分代码如下

main

public class Main {

    public static void main(String[] args) {
        DoubleLinkedList<String> list1 = new DoubleLinkedList<String>();
        System.out.println("\"链表是空\" 是 " + list1.isEmpty());
        list1.add("张无忌");
        list1.add("韦小宝");
        list1.add("杨过");
        list1.add("郭靖");
        list1.printList();
            //越界数据测试（边界值）
        System.out.println("\"链表是空\" 是 " + list1.isEmpty());
        System.out.println("请做出你对双向链表的选择 :"+
                "\n1.获取当前链表的长度"+
                "\n2.增加元素在链表的末尾"+
                "\n3.输入索引，得到索引处的数据"+
                "\n4.在指定索引处添加元素"+
                "\n5.在指定索引处移除元素");
        while(true) {
            Scanner in = new Scanner(System.in);
            int choice = in.nextInt();
            switch (choice) {
                case 1 :
                    System.out.println("列表的长度是" + list1.getSize());
                    break;
                case 2 :
                    System.out.printf("请输入数据 :");
                    String str2 = in.next();
                    list1.add(str2);
                    break;
                case 3 :
                    System.out.printf("请输入索引 :");
                    int index3 = in.nextInt();
                    System.out.println("链表第"+index3+"个是:"+list1.getData(index3));
                    break;
                case 4 :
                    System.out.printf("请输入索引 :");
                    int index4 = in.nextInt();
                    System.out.printf("请输入数据 :");
                    String str4 = in.next();
                    list1.add(index4,str4);
                    break;
                default :
                    System.out.printf("请输入索引 :");
                    int index5 = in.nextInt();
                    list1.remove(index5);
            }
            list1.printList();
            //越界数据测试（边界值）
            System.out.println("\"链表是空\" 是 " + list1.isEmpty());
        }
    }

}

Node

public class Node<E> {

    private E data;//数据域，类型为泛型E

    private Node<E> next = null;//后继引用（指针）

    private Node<E> previous = null;//前驱引用（指针）

    public Node() {

    }

    public Node(E data) {
        super();
        this.data = data;
    }

    public E getData() {
        return data;
    }

    public void setData(E data) {
        this.data = data;
    }

    public Node<E> getNext() {
        return next;
    }

    public void setNext(Node<E> next) {
        this.next = next;
    }

    public Node<E> getPrevious() {
        return previous;
    }

    public void setPrevious(Node<E> previous) {
        this.previous = previous;
    }
}

DoubleLinkedList

package DoubleLinkedList;

public class DoubleLinkedList<E> implements DoubleLinkedListImpl<E> {

    private Node<E> head;//头结点，非第一个节点

    private Node<E> curr;//当前节点

    private Node<E> tail;//最后一个节点

    private int size;

    public DoubleLinkedList() {
        super();
        head = new Node<E>();
        curr = head;
        tail = head;
    }
    public boolean isEmpty() {
        return (size == 0);
    }
    public int getSize() {
        return size;
    }

    public E getData(int index) {
        if (index > size || index < 0) {
            System.out.println("链表里没有索引\"" + index + "\"!");
            return null;
        } else {
            curr = head;
            for (int i = 0; i < index; i ++ )
            {
                curr = curr.getNext();
            }
            return curr.getData();
        }
    }

    public void remove() {
        curr = tail.getPrevious();
        tail = curr;
        tail.setNext(null);
        size --;
    }

    public void remove(int index) {
        if (index > size || index <= 0) {
            System.out.println("链表里没有索引\"" + index + "\"!");
        }
        else {
            if (index == size) {
                tail = tail.getPrevious();
                tail.setNext(null);
                size --;
            }
            else {
                curr = head;
                for (int i = 0; i < index - 1; i ++) {
                    curr = curr.getNext();
                }
                curr.setNext(curr.getNext().getNext());
                curr.getNext().setPrevious(curr);
                size --;
            }
        }
    }
    public void add(int index, E theElement) {
        if (index > size || index <= 0) {
            System.out.println("链表里没有索引\"" + index + "\"!");
        }
        else {
            curr = head;
            Node<E> temp = new Node<>(theElement);
            for (int i = 0; i < index - 1; i ++) {
                curr = curr.getNext();
            }
            curr.getNext().setPrevious(temp);
            temp.setPrevious(curr);
            temp.setNext(curr.getNext());
            curr.setNext(temp);
            size ++;
        }
    }
    public void add(E element) {
        Node<E> temp = new Node<>(element);
        tail.setNext(temp);
        temp.setPrevious(tail);
        tail = temp;
        size ++;
    }
    public void printList() {
        curr = head;
        if (curr.getNext() == null) {
            System.out.println("The list is empty!");
        } else {
            curr = head.getNext();
            for (int i = 0; i < size; i++, curr = curr.getNext()) {
                if (i > 0) {
                    System.out.print(", ");
                }
                System.out.print("Node" + (i + 1) + "{" + curr.getData() + "}");
            }
            System.out.println();
        }
    }
    public E getFirst() {
        if (head.getNext() == null) {
            System.out.println("The first data is null!");
            return null;
        }
        else {
            return head.getNext().getData();
        }
    }
    public E getLast() {
        if (tail.getData() == null) {
            System.out.println("The last data is null!");
            return null;
        }
        else {
            return tail.getData();
        }
    }//当前链表节点数

}

OPP期中考试：

除了基本的题意理解，写了三个子类--点point，线Line，面Plane，后来第三题加上了关于ArrayList的GeometryObject容器类，父类Element类，主类main。每个子类基本的Set与Get，还有子类泛型showDate；按照题意便能做出来，其中需要注意的是ArrayList的索引Index需要位序减1。

类图如下：

 

 第三题代码如下：

import java.util.Scanner;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        GeometryObject<Element> list = new GeometryObject<>();
        int choice = in.nextInt();
        while(choice != 0) {
            switch(choice) {
                case 1://insert Point object into list
                    double x = in.nextDouble();
                    double y = in.nextDouble();
                    Point p = new Point(x,y);
                    list.add(p);
                    break;
                case 2://insert Line object into list
                    double x1 = in.nextDouble();
                    double y1 = in.nextDouble();
                    double x2 = in.nextDouble();
                    double y2 = in.nextDouble();
                    String color = in.next();
                    Point p1 = new Point(x1,y1);
                    Point p2 = new Point(x2,y2);
                    Line line = new Line(p1,p2,color);
                    list.add(line);
                    break;
                case 3://insert Plane object into list
                    String color1 = in.next();
                    Plane plane = new Plane(color1);
                    list.add(plane);
                    break;
                case 4://delete index - 1 object from list
                    int index = in.nextInt();
                    list.remove(index);
            }
            choice = in.nextInt();
        }
        for(int i=0;i<list.getList().size();i++) {
            list.getList().get(i).display();
        }
    }
}
class Point extends Element{
    private double x;
    private double y;
    public Point() {

    }
    public Point(double x,double y) {
        this.x = x;
        this.y = y;
    }
    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public void display() {
        System.out.println("("+String.format( "%.2f", x)+","+String.format( "%.2f", y)+")");
    }

}

class Line extends Element{
    private Point point1;
    private Point point2;
    private String color;
    public Line() {

    }
    public Line(Point point1,Point point2,String string) {
        this.point1 = point1;
        this.point2 = point2;
        this.color = string;
    }

    public Point getPoint1() {
        return point1;
    }

    public void setPoint1(Point point1) {
        this.point1 = point1;
    }

    public Point getPoint2() {
        return point2;
    }

    public void setPoint2(Point point2) {
        this.point2 = point2;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getDistance() {
        return Math.sqrt((point1.getX()-point2.getX())*(point1.getX()-point2.getX())+(point1.getY()-point2.getY())*(point1.getY()-point2.getY()));
    }

    public void display() {
        System.out.println("The line's color is:"+color);
        System.out.println("The line's begin point's Coordinate is:");
        point1.display();
        System.out.println("The line's end point's Coordinate is:");
        point2.display();
        System.out.println("The line's length is:"+String.format("%.2f",getDistance()));
    }

}
class Plane extends Element{
    private String color;
    public Plane() {

    }
    public Plane(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void display() {
        System.out.println("The Plane's color is:"+color);
    }

}
abstract class Element {
    public abstract void display();

}
class GeometryObject<E> {
    ArrayList<E> list =new ArrayList<>();
    public void add(Element element) {
        list.add((E) element);
    }
    public void remove(int index) {
        list.remove(index);
    }
    public ArrayList<E> getList() {
        return list;
    }

}

 

三.我踩坑与填坑心得。

 

1. 如果想要使用ArrayList和LinkedList，一定要记得索引值要减1；在OPP期中考试的最后一题中，那个测试点我没通过的原因，便是索引值问题。

 

 2. 泛化的应用有时候会更加简便。比如LinkedList需要编写一个节点Node里有两个数据Node及数据类型String，这时候用标准型<E>，会更方便add数据。又比如OPP期中考试的第三题，如果用那几个Point，Line，Plane，我们需要在GeometryObject容器类编写三个ArrayList，把三个类都i给对应起来，不太方便。

 public void add(E element) {
        Node<E> temp = new Node<>(element);
        tail.setNext(temp);
        temp.setPrevious(tail);
        tail = temp;
        size ++;
    }

3. 正则表达式的测试工具很难识别%d，%s等，最好用[0-9][a-zA-Z]来代替测试。

4. 正则和string自带方法可以灵活使用，不一定非得用某一种。

 

四.我的一些不成熟的建议。

 

1. pta题目集5第五题，常识是一个卡号拥有一个独立的账户，题目却是一个人不管有多少账户或卡号，都只拥有一个卡号，这导致了我每次都错。希望老师可以在题意的说明上，更严谨一点；

2. 测试点过多的时候，我真不希望老师连个提示都没有，我是根本过不去，还不知道怎么测试，这样我并不能学到一些对自己有用的知识；

3. 链表老师刚开始要求写的时候，我相信绝大部分人都是网上copy的，因为我们根本想不出这样的方法，还有接口，老师都是提了一下就带过，我们根本理解不了如何写。都是借助网上的视频或者源码进行修改，修改完之后甚至还不知所以然。并不存在老师说明的那种借鉴网上的优秀经验。

 

五.那就总结一下吧。

 

题目开始越来越难，内容开始有深度起来，我听课是越来越不懂，只能勉强跟上，但是当做题之后，突然就发现自己学会了好多东西，借助csdn，借助百度，我们总能获得我们意想不到的方法。老师最近讲lambda，还有map这种我们不需要理解，只会用就可以的方法，我是很喜欢现在的讲课方式的，我自己学的这种往往比老师讲的更牢固。老师最近讲的我毕竟不能马上投入使用，我感觉老师可以进行布置一些课堂测试题，让我们去练习，让我们巩固这些有深度的方法，我觉得还是很有必要的。