Java基础练习习题

1 输入三边的长度，求三角形的面积和周长(海伦公式)

package Demo2.Test4;

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        /*
               输入三边的长度，求三角形的面积和周长(海伦公式)
        */
                Scanner scanner =new Scanner(System.in);//扫描器
                System.out.println("请分别输入三角形的三条边");
                int a = scanner.nextInt();//长
                int b = scanner.nextInt();//宽
                int c = scanner.nextInt();//高
                method(a,b,c);

            }
            public static void method(int a,int b,int c){
                double s = (a+b+c)/2.0;
                double v = s*(s-a)*(s-b)*(s-c);
                System.out.println("周长为"+(a+b+c));
                System.out.println("面积为"+Math.sqrt(v));
            }


        }

2 英雄联盟商品首页

package Demo2.Test4;

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        print(sc);

    }
    //选项代码
    private static void print(Scanner sc) {
        while (true) {

            method1();

            int k = sc.nextInt();

            switch (k) {

                case 1:

                    method2();
                    Scanner sc1 = new Scanner(System.in);
                    int k1 = sc1.nextInt();
                    if (k1!=0) {
                        if (k1 == 1) {
                            method3();//英雄超市
                            int ss2 = sc1.nextInt();

                            if (ss2 == 1) {
                                method4();
                                int ss22 = sc1.nextInt();
                                System.out.println("成功付款" + ss22);//交款成功

                                System.out.println("是否查看英雄信息，按1为查看,0为否认");
                                Scanner sss = new Scanner(System.in);
                                int sss1 = sss.nextInt();
                                if (sss1 == 1) {
                                    method5();
                                    break;
                                }
                            }

                        }


                        if (k1 == 2) {
                            System.out.println("休闲小游戏还没开通");
                            //休闲小游戏
                        }
                        if (k1 == 3) {
                            //退出登录
                        }
                    }
                    if (k1==0){
                        System.out.println("没有这个操作");
                        break;
                    }

                    break;

            }
            System.out.println("请输入你的操作功能0.返回主界面---9.退出系统");


            k = sc.nextInt();

            switch (k) {
                case 0:

                    break;

                case 9:

                    sc.close();

                    return;

            }


        }
    }
    //创建主页方法
    private static void method1(){
        System.out.println("\t\t\t\t\t英雄联盟商城登录界面");
        System.out.println("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~");
        System.out.println("                       "+"1.用户登录"+'\n'+"                       "+"2.新用户注册"+'\n'+"                       "+"3.退出系统");
        System.out.println("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~");
        System.out.println("(温馨提示)请输入您的选项：");
    }
    private static void method2(){
        System.out.println("\t\t\t\t\t英雄联盟商城首页");
        System.out.println("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~");
        System.out.println("                       "+"1. 进入英雄超市"+'\n'+"                       "+"2. 休闲小游戏"+'\n'+"                       "+"3. 退出登录");
        System.out.println("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~");
        System.out.println("(温馨提示)请输入您的选项：");
    }
    private static void method3() {
        System.out.println("\t\t\t\t\t英雄商城英雄列表");
        System.out.println("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~");
        System.out.println('\t' + '\t' + "编号" + '\t' + '\t' + "姓名" + '\t' + '\t' + "昵称" + '\t' + '\t' + "价格" + '\t' + '\t' + "库存" + '\t' + '\t' + "描述");
        System.out.println('\t' + '\t' + "1" + '\t' + '\t' + "盲僧" + '\t' + '\t' + "迷失之牙" + '\t' + '\t' + "3500" + '\t' + '\t' + "100" + '\t' + '\t' + "丛林不会原谅盲目与无知");
        System.out.println('\t' + '\t' + "2" + '\t' + '\t' + "锐雯" + '\t' + '\t' + "放逐之刃" + '\t' + '\t' + "4000" + '\t' + '\t' + "100" + '\t' + '\t' + "她是残忍高效的战士");
        System.out.println('\t' + '\t' + "3" + '\t' + '\t' + "薇恩" + '\t' + '\t' + "暗夜猎手" + '\t' + '\t' + "3500" + '\t' + '\t' + "100" + '\t' + '\t' + "这个世界不想人们想象的那么好");
        System.out.println('\t' + '\t' + "4" + '\t' + '\t' + "扎克" + '\t' + '\t' + "生化魔人" + '\t' + '\t' + "3000" + '\t' + '\t' + "100" + '\t' + '\t' + "即使你没有脊柱,你也必须站起来");
        System.out.println('\t' + '\t' + "4" + '\t' + '\t' + "杰斯" + '\t' + '\t' + "未来守护者" + '\t' + '\t' + "2500" + '\t' + '\t' + "100" + '\t' + '\t' + "武装着睿智与魅力,你的选择没有错");
        System.out.println("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~");
        System.out.println("(温馨提示)请输入您要购买的英雄编号：");
    }
    private static void method4(){
        System.out.println("\t\t\t\t\t英雄商城购买英雄");
        System.out.println("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~");
        System.out.println("英雄名称：盲僧(史诗)\n" +
                "\t英雄属性：生命值428(+85)/能量值200(+0)/移动速度425/攻击力55.8(+3.2)\n" +
                "\t\t攻击速度0.651(+3.1%)/护甲值24(+1.25)/攻击距离125\n" +
                "\n" +
                "\t英雄座右铭：一人之行可灭世，众人之勤可救世！\n" +
                "\t英雄价格：3000\n" +
                "\t活动折扣：9.5\n" +
                "\n" +
                "插播广告：当风云变色，当流离失所，世界不再是旧日模样\n" +
                "你是否会为了自己的梦想战斗，直至力战身亡，直至彼岸他乡 ");
        System.out.println("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~");
        System.out.println("(温馨提示)请付款：");
    }
    private static void method5(){
        System.out.println("\t\t\t\t\t英雄商城购买英雄");
        System.out.println("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~");
        System.out.println("\n" +
                "\t英雄名称：九尾妖狐(史诗)\n" +
                "\t英雄价格：10000\n" +
                "\t活动折扣：9.5\n" +
                "\n" +
                "\t应付付款：9500\n" +
                "\t实际付款：10000\n" +
                "\t找零：500\n" +
                "\n" +
                "插入广告：当风云变色，当流离失所，世界不再是旧日模样\n" +
                "你是否会为了自己的梦想战斗，直至力战身亡，直至彼岸他乡 ");
        System.out.println("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~");
        System.out.println("(温馨提示)按任意键返回上一级菜单：");
    }
}

3 请输入一个数，判断这个数是偶数还是奇数，如果使用偶数，请判断从1到该数是3的倍数有哪些如果是奇数，请判断从1到该数是5的倍数有哪些

package Demo2.Test4;

import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
          /*
    请输入一个数，判断这个数是偶数还是奇数，
	如果使用偶数，请判断从1到该数是3的倍数有哪些
	如果是奇数，请判断从1到该数是5的倍数有哪些
     */
        System.out.println("请输入一个数，判断这个数是偶数还是奇数");
        int s = new Scanner(System.in).nextInt();
        method(s);
    }
    private static void method(int s){
        if (s % 2 == 0) {
            System.out.println("是偶数");
            for (int i = 1; i <= s; i++) {
                if (i % 3 == 0) {
                    System.out.println("倍数有" + i);
                }
            }
        } else {
            System.out.println("是奇数");
            for (int i = 1; i <= s; i++) {
                if (i % 5 == 0) {
                    System.out.println("倍数有" + i);
                }
            }
        }
    }
}

4 循环输入某同学S1结业考试的5门课成绩，并计算平均分

package Demo2.Test4;

import java.util.Scanner;

public class Test4 {
    public static void main(String[] args) {
        //循环输入某同学S1结业考试的5门课成绩，并计算平均分
        Scanner sc = new Scanner(System.in);
        System.out.println("请分别输入语文,数学,英语,物理,化学的成绩");
        method(sc);
        sc.close();
    }

    private static void method(Scanner sc) {
        int i1 = sc.nextInt();
        int i2 = sc.nextInt();
        int i3 = sc.nextInt();
        int i4 = sc.nextInt();
        int i5 = sc.nextInt();
        System.out.println("平均分为" + (i1 + i2 + i3 + i4 + i5) / 5);
    }

}

5 求1~100之间不能被3整除的数之和

package Demo2.Test4;

public class Test5 {
    public static void main(String[] args) {
        /*
        求1~100之间不能被3整除的数之和
         */
        showInfo(100);

    }
    private static void showInfo(int num){
        int sum=0;
        for (int i=1; i<num; i++) {
            if (i%3!=0) {
                sum+=i;
            }
        }
        System.out.println("和为"+sum);
    }
}

6 打印一个表格根据用户输入的数1 11 1112 22 222…n n平方n立方

package Demo2.Test4;

import java.util.Scanner;

public class Test6 {
    public static void main(String[] args) {
        /*
        打印一个表格
	    根据用户输入的数

    	1	1*1	1*1*1
    	2	2*2	2*2*2
    	....

    	n	n平方	n立方

         */
        System.out.println("请输入一个数");
        int sc1 = new Scanner(System.in).nextInt();
        print(sc1);
    }
    private static void print(int sc1){
        for (int sc = 1; sc <=sc1; sc++) {
            System.out.println(sc + "\t" + sc + "*" + sc + "\t" + sc + "*" + sc + "*" + sc);
        }
    }
}

7 打印各种三角形

package Demo2.Test4;

public class Test7 {
    public static void main(String[] args) {
        System.out.println("图1");
        print1();
        System.out.println("图2");
        print2();
        System.out.println("图3");
        print3();
        System.out.println("图4");
        print4();
        System.out.println("图5");
        print5();
    }
    private static void print1(){
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
    private static void print2(){
        for (int i = 1; i <= 4; i++) {
            for (int j = 4; j >= i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
    private static void print3(){
        for (int i = 1; i <= 4; i++) {
            for (int j = 4; j >= i; j--) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print(" ");
            }
            System.out.println();
        }
    }
    private static void print4(){
        for (int i = 1; i <= 6; i++) {
            for (int j = 6; j >= i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        for (int i = 1; i <= 6; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(" ");
            }
            for (int j = 6; j >= i; j--) {
                System.out.print("*");
            }
            for (int j = 6; j > i; j--) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
    private static void print5(){
        int num = 5;
        for (int i = 1; i <= num; i++) {
            //控制打印上半部分菱形每层的*个数
            if (i <= num / 2 + 1) {
                //在输出*之前，还有输出 对应空格 = 中间层-当前层
                for (int h = 1; h <= num / 2 + 1 - i; h++) {
                    System.out.print(" ");
                }
                for (int j = 1; j <= 2 * i - 1; j++) {
                    //当前行的第一个位置是*,最后一个位置也是*
                    if (j == 1 || j == 2 * i - 1) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
            }
            //控制打印下半部分菱形每层的*个数
            else {
                //在输出*之前，还有输出 对应空格 = 当前层-中间层
                for (int s = 1; s <= i - (num / 2 + 1); s++) {
                    System.out.print(" ");
                }
                for (int k = 1; k <= (2 * (num / 2 + 1) - i) * 2 - 1; k++) {
                    //当前行的第一个位置是*,最后一个位置也是*
                    if (k == 1 || k == (2 * (num / 2 + 1) - i) * 2 - 1) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
            }
            // 每打印完一层的*后，就换行 println本身会换行
            System.out.println("");
        }
    }
}

8 请在控制台上输入两个数，并且输入一个符号（+ - * / %），使用switch语句

package Demo2.Test4;

import java.util.Scanner;

public class Test8 {
    public static void main(String[] args) {
      /*
      作业6：请在控制台上输入两个数，并且输入一个符号（+ - * / %），使用switch语句
       */
        Scanner sc = new Scanner(System.in);
        System.out.println("请你输入两个数");
        printInfo(sc.nextInt(),sc.nextInt());
    }
    private static void printInfo(int i,int i2) {
        System.out.println("请你输入+ - * / %其中一个运算来两数字");
        String s = new Scanner(System.in).nextLine();
        switch(s){
            case "+":
                System.out.println(i+"+"+i2+"="+(i+i2));
                break;
            case "-":
                System.out.println(i+"-"+i2+"="+(i-i2));
                break;
            case "*":
                System.out.println(i+"*"+i2+"="+(i*i2));
                break;
            case "/":
                System.out.println(i+"/"+i2+"="+(i/i2));
                break;
            default:
                System.out.println("你输入不在范围内");

        }
    }
}

9 100~1000返回内，能被5和6整除的数

package Demo2.Test4;

public class Test9 {
    public static void main(String[] args) {
        /*
        100~1000返回内，能被5和6整除的数
         */
        System.out.println("能被5和6整除的数有");
        print();
    }

    public static void print(){
        for (int i = 100; i <= 1000; i++) {
            if (i % 5 == 0 && i%6==0) {
                System.out.print(i+" ");
            }
        }
    }
}

10 输入一个年份，判断该年是否是闰年

package Demo2.Test4;

import java.util.Scanner;

public class Test10 {
    public static void main(String[] args) {
        /*
        输入一个年份，判断该年是否是闰年
         */
        System.out.println("请输入年份");
        year(new Scanner(System.in).nextInt());

    }

    private static void year(int year) {
        if (year%4==0&&year%100!=0||year%400==0){
            System.out.println("是闰年");
        }else{
            System.out.println("不是闰年");
        }
    }
}

11 一个自然数与3的和是5的倍数,与3的差是6的倍数,这个自然数最小是几?

package Demo2.Test4;

public class Test11 {
    public static void main(String[] args) {
        /*
        一个自然数与3的和是5的倍数,与3的差是6的倍数,这个自然数最小是几?
         */
        for (int i = 1; i < 100; i++) {
            if (i %3== 0&&i%5==0&&(i-3)%6==0) {
                System.out.println(i);
            }
        }
    }
}

12 在400–500之间求一个数,它被2除余1,被5除余3,被9除余1,这个数是多少?

package Demo2.Test4;

public class Test12 {
    public static void main(String[] args) {
        /*
        在400--500之间求一个数,它被2除余1,被5除余3,被9除余1,这个数是多少?
        */
        for (int i = 400; i <= 500; i++) {
            if (i % 2 == 1 && i % 5 == 3 && i % 9 == 1) {
                System.out.println(i);
            }
        }
    }
}

13 有一些四位数,百位数字都是3,十位数字都是6,并且它们既能被2整除,又能被3整除,求这样的四位数中最大的和最小的两数各是几?

package Demo2.Test4;

public class Test13 {
    public static void main(String[] args) {
        /*
        有一些四位数,百位数字都是3,十位数字都是6,并且它们既能被2整除,又能被3整除,求这样的四位数中最大的和最小的两数各是几?
         */

    }
    public static void print(){
        for (int i = 1; i < 10; i++) {
            for (int j=0;j<10;j++ ){
                int num=i*1000+300+60+j;
                if (((num % 3) == 0) && ((num % 2) == 0)) {
                    System.out.println("最小数为"+num);
                    break;
                }
            }
        }
        System.out.println("--");

        for (int i = 10; i > 1; i--) {
            for (int j=10;j>1;j-- ){
                int num=i*1000+300+60+j;
                if (((num % 3) == 0) && ((num % 2) == 0)) {
                    System.out.println("最大数为"+num);
                    break;
                }
            }
        }
    }
}

14 编程求一个四位自然数ABCD,它乘以A后变成DCBA

package Demo2.Test4;

import java.util.Scanner;

public class Test14 {
    public static void main(String[] args) {
        /*
        编程求一个四位自然数ABCD,它乘以A后变成DCBA
         */
        System.out.println("请输入四位数");
        print(new Scanner(System.in).nextInt());


    }
    private static void print(int n){
        for (int i = 1000; i <n; i++) {
            int a = (i / 1000) % 10;
            int b = (i / 100) % 10;
            int c = (i / 10) % 10;
            int d = i % 10;
            int num = d * 1000 + c * 100 + b * 10 + a;
            if (i * a == num) {
                System.out.println("这个数是：" + i);
            }
        }
    }
}

15 编程求出满足以下条件的三位数:它除以11所得的商等于,它各位数字之和

package Demo2.Test4;

import java.util.Scanner;

public class Test15 {
    public static void main(String[] args) {
        /*
        编程求出满足以下条件的三位数:它除以11所得的商等于,它各位数字之和
         */
        print(new Scanner(System.in).nextInt());
    }
    public static void print(int num){
        for (int i = 1; i < num; i++) {
            int x=i%10;//个
            int y=(i/10)%10;//十
            int z=i/100;//百
            boolean b = i / 11 == (x + y + z);
            if (b) {
                System.out.println(i);
            }
        }
    }
}

16 某数被80除所得的商,不但是7的倍数,而且用2,3,4,5,6去除余数都是1,求这个自然数.

package Demo2.Test4;

public class Test16 {
    public static void main(String[] args) {
        /*
        某数被80除所得的商,不但是7的倍数,而且用2,3,4,5,6去除余数都是1,求这个自然数.
         */
        for (int i = 1; i <=1000; i++) {
            int shang=80/i;
            if ((i%2==1)&&(i%3==1)&&(i%4==1)&&(i%5==1)&&(i%6==1)&&(shang%7==0)){
                System.out.println(i);
            }
        }
    }
}

17 有一种最简真分数,它们的分子与分母的乘积都是140,把所有这样的真分数从小到大打印出来(真分数是指分子小于分母的分数，最简真分数是指分子和分母没有共同公约数的分数)

package Demo2.Test4;

public class Test17 {
    public static void main(String[] args) {
        /*
        有一种最简真分数,它们的分子与分母的乘积都是140,把所有这样的真分数从小到大打印出来
        (真分数是指分子小于分母的分数，最简真分数是指分子和分母没有共同公约数的分数)
         */
        method();
    }
    public  static  void method(){
        int index = 0;
        //分子循环
        for (int i = 1; i <=140; i++) {
            //分母循环
            for (int j = i+1; j <=140; j++) {
                if (i*j==140){
                    for (int k = 1; k <=i; k++) {
                        if(i%k==0&&j%k==0){
                            index++;
                        }
                    }
                    if (index==1){
                        System.out.println(i+"/"+j);
                    }
                    index=0;
                }
            }
        }
    }
}

18 一个五位数,若在它的后面写上一个7,得到一个六位数A,若在它前面写上一个7,得到一个六位数B,B是A的五倍,求此五位数

package Demo2.Test4;

public class Test18 {
    public static void main(String[] args) {
        /*
        一个五位数,若在它的后面写上一个7,得到一个六位数A,若在它前面写上一个7,得到一个六位数B,B是A的五倍,求此五位数
         */
        print();
    }
    private static void print(){
                int a,b;
                for (int i = 10000; i <= 99999; i++) {
                    // 后面写 7
                    a = i*10+7;
                    // 前面写 7
                    b = 700000+i;
                    if (a*5 == b) {
                        System.out.println("这个五位数是:"+i);
                    }
                }
            }
        }

19 把123456789这个数乘以一个什么数,能使它的结果不但不含零,而且仍然是 由1,2,3,4,5,6,7,8,9这九个数字组成的,只是顺序不同而已

package Demo2.Test4;

public class Test19 {
    public static void main(String[] args) {
        /*
        把123456789这个数乘以一个什么数,能使它的结果不但不含零,而且仍然是 由1,2,3,4,5,6,7,8,9这九个数字组成的,只是顺序不同而已
         */
                int val =123456789;
                for(int i=2;i<=8;i++){
                    int num=i*val;
                    if(bits(num)==bits(val) ){
                        System.out.println(num);
                    }
                }

            }
            public  static int bits(int num) {
                if (num <= 10) {
                    int c = num % 10;
                    return c;
                } else {
                    int c = num % 10;
                    return c + bits(num / 10);
                }
            }
        }

20 验证:任意一个大于9的整数减去它的各位数字之和所得的差,一定能被9整除.

package Demo2.Test4;

import java.util.Scanner;

public class Test20 {
    /*
    验证:任意一个大于9的整数减去它的各位数字之和所得的差,一定能被9整除.
     */
    public static void main(String[] args) {


        System.out.println("请输入数字");
        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();
        int bits = bits(i);
        if (i-bits(i)%9==0){
            System.out.println("验证成功");
        }else{
            System.out.println("验证失败");
        }
    }

        public  static int bits(int num) {
            if (num <= 10) {
                int c = num % 10;
                return c;
            } else {
                int c = num % 10;
                return c + bits(num / 10);
            }
        }

    }

21 求素数的孪生数

package Demo2.Test4;

public class Test21 {
    public static void main(String[] args) {
        print();

    }
    private static void print(){
        int nums1 = 0,nums2 = 0;
        int a=0;//定义一个变动器
        // 手动加上
        System.out.println("孪生数为:"+"1"+"\t"+"3");

        for (int num = 1; num <= 100; num++) {
            boolean flag = true ;
            // 判断num是不是质数
            // 只要判断一般就可一以了
            for (int i = 2; i <= num / 2; i++) {
                if (num % i == 0) {
                    flag = false;
                    break;
                }
            }
            //如果为真则执行一下
            if (flag) {
                if (a % 2 == 0){
                    nums1 = num; //
                    if (nums1 - nums2 == 2 ) {
                        System.out.println("孪生数为:"+nums2+"\t"+nums1);
                    }
                    a++;
                } else {
                    nums2 = num;
                    if (nums2 - nums1 == 2 ) {//a不同,所以此时nums1为上一次执行num所附的
                        System.out.println("孪生数为:"+nums1+"\t"+nums2);
                    }
                    a++;
                }
            }
        }
    }
}

22 求水仙花数。ABC = a^3+b3+c^3

package Demo2.Test4;

import java.util.Scanner;

public class Test22 {
    public static void main(String[] args) {
        /*
        求水仙花数。ABC  = a^3+b^3+c^3
         */
        System.out.println("请输入你想输入的数");
        int i = new Scanner(System.in).nextInt();
        printf(i);
    }
    private static void printf(int i) {
        for (int i1 = 1; i1 <= i; i1++) {
            int a=i1%10;
            int b=i1/10%10;
            int c=i1/100;
            if (i1==(a*a*a+b*b*b+c*c*c)){
                System.out.println(i1);
            }
        }

    }
}

23 求 a+aa+aaa+…+aaaaaaaaa=?其中a为1至9之中的一个数，项数也要可以指定。

package Demo2.Test4;
import java.util.Scanner;
public class Test23 {
    public static void main(String[] args) {
        /*
        作业23：求  a+aa+aaa+.......+aaaaaaaaa=?其中a为1至9之中的一个数，项数也要可以指定。
         */

                Scanner sc= new Scanner(System.in);
                System.out.println("请输入a:");
                double num=sc.nextDouble();
                System.out.println("请输入项数:");
                int item=sc.nextInt();
                System.out.println(cumulative(num,item));
            }
            public static double cumulative(double num,int item){
                if(item==1){
                    return num;
                }else {
                    double number=0;
                    for(int i=0;i<item;i++){
                        number+=num*Math.pow(10,i);
                    }
                    return number+cumulative(num,item-1);
                }
            }
        }

24 求 2/1+3/2+5/3+8/5+13/8…前20项之和？

package Demo2.Test4;
import java.util.Scanner;
public class Test24 {

    public static void main(String[] args) {
//    求 2/1+3/2+5/3+8/5+13/8.....前20项之和？
                Scanner sc= new Scanner(System.in);
                System.out.println("请输入项数:");
                int item=sc.nextInt();
                item=item+1;
                double val=0;
                for (int i=1;i<=item;i++){
                    val+=(cumulative(item)/cumulative(item-1));
//            System.out.println(val);
                }
                System.out.println("前"+item+"项和为："+val);
            }
            public static double cumulative(int item){
                if(item==1){
                    return 1 ;
                }else if(item==2){
                    return 2;
                } else {
                    return cumulative(item-2)+cumulative(item-1);
                }
            }
        }

25 根据完整的路径从路径中分离文件路径、文件名及扩展名,传递一个路径 c://a//b//c.avi，返回该文件的后缀名static String format(String format, Object… args) 使用指定的格式字符串和参数返回格式化的字符串。

package Demo2.Test4;

import java.util.Arrays;

public class Test25 {
    public static void main(String[] args) {
        /*
        根据完整的路径从路径中分离文件路径、文件名及扩展名,传递一个路径 c://a//b//c.avi，返回该文件的后缀名
        static String format(String format, Object... args)  使用指定的格式字符串和参数返回格式化的字符串。
         */
        String s="c://a//b//c.avi";
        s.trim();//清楚空格等
        String[] split = s.split("//");
        System.out.println(split[split.length-1]);
    }
}

26 输入一个字符串，判断该字符串是否是回文字符串（面试题）123454321

package Demo2.Test4;

import java.util.Scanner;

public class Test26 {
    public static void main(String[] args) {
        /*
        输入一个字符串，判断该字符串是否是回文字符串（面试题）123454321
         */
            String s = new Scanner(System.in).nextLine();
            if ( print(s)){
                System.out.println("是回文字符串");
            }else{
                System.out.println("不是");
            }

        }

        private static boolean print(String s) {
            for (int i = 0, j = s.length() - 1; i < s.length(); i++, j--) {
                if (s.charAt(i)!= s.charAt(j)) {
                    return false;
                }
            }
            return true;
        }
    }

27 去掉字符串中的所有空格

package Demo2.Test4;

import java.util.Scanner;

public class Test27 {
    public static void main(String[] args) {
        /*
        去掉字符串中的所有空格
         */
        System.out.println("请输入你要输入的字符##系统会自动清楚空格##");
        Scanner sc = new Scanner(System.in);
        String next = sc.nextLine();
        for (int i = 0; i < next.length(); i++) {
            char c = next.charAt(i);//先转成字符型
            String s = String.valueOf(c);//在转换为字符串型
            System.out.print(s.trim());//利用循环每次接收一个字符时,如有空格则自动删除

        }
        sc.close();
    }
}

28 将字母全部转换为大写或小写

package Demo2.Test4;

import java.util.Scanner;

public class Test28 {
    public static void main(String[] args) {
        /*
        将字母全部转换为大写或小写
         */
        Scanner sc = new Scanner(System.in);
        Scanner sc1 = new Scanner(System.in);
        System.out.println("请输入你要输入的字母");
        String s = sc1.nextLine();
        System.out.println("\t1.转为全部大写\t2.转为全部小写");
        if (sc.hasNextInt()) {
            int i = sc.nextInt();
            switch(i){
                case 1:
                    System.out.println(s.toUpperCase());break;
                case 2:
                    System.out.println(s.toLowerCase());break;
                default:
                    System.out.println("输入有误");
            }
        }

    }

}

29 接收用户输入的一句英文，将其中的单词以反序输出，“hello c sharp”→“sharp c hello”。

package Demo2.Test4;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;

public class Test29 {
    public static void main(String[] args) {
        /*
        接收用户输入的一句英文，将其中的单词以反序输出，“hello c sharp”→“sharp c hello”。
         */
        System.out.println("请输入一句英文,系统会自动反向输出");
        Scanner sc = new Scanner(System.in);
        fun(sc);
    }

    private static void fun(Scanner sc) {
        if (sc.hasNext()) {
            String s = sc.nextLine();
            String[] s1 = s.split(" ");
            for (int i = s1.length - 1; i >= 0; i--) {
                if (s1[i] == s1[s1.length - 1]) {
                    System.out.print(s1[i]);
                }else{
                    System.out.print(" "+s1[i]);
                }
            }
        }
    }
}

30 从请求地址中提取出用户名和域名http://www.163.com?userName=admin&pwd=123456

package Demo2.Test4;

import java.util.Arrays;

public class Test30 {
    public static void main(String[] args) {
        /*
        从请求地址中提取出用户名和域名http://www.163.com?userName=admin&pwd=123456
         */
        String s="http://www.163.com?userName=admin&pwd=123456";
        String[] split = s.split("\\?");
        System.out.println("用户名"+split[0]);
        System.out.println("域名"+split[1]);
    }
}

31 让用户输入一句话,找出所有"呵"的位置。

package Demo2.Test4;

import java.util.Scanner;

public class Test31 {
    public static void main(String[] args) {
        /*
        让用户输入一句话,找出所有"呵"的位置。
         */
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入字符串：");
        String s = sc.nextLine();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '呵') {
                System.out.println(i);
            }

        }
    }
}

32 让用户输入一句话,判断这句话中有没有邪恶,如果有邪恶就替换成这种形式然后输出,如:“老牛很邪恶”,输出后变成”老牛很**”

package Demo2.Test4;

import java.util.Scanner;

public class Test32 {
    public static void main(String[] args) {
        /*
        让用户输入一句话,判断这句话中有没有邪恶,如果有邪恶就替换成这种形式然后输出,如:“老牛很邪恶”,输出后变成”老牛很**”
         */
        System.out.println("请您输入一句话");
        Scanner sc = new Scanner(System.in);
        fun(sc);
    }

    private static void fun(Scanner sc){
        if(sc.hasNextLine()){
            String s = sc.nextLine();
            System.out.println(s.replace("邪恶","**"));
        }
    }
}

33 猜字游戏，计算机随机一个0~100的整数，每次用户输出字猜，提示如下：猜大了，重新猜，猜小了，重新猜，猜对了

package Demo2.Test4;

import java.util.Scanner;

public class Test33 {
    public static void main(String[] args) {
        /*
        猜字游戏，计算机随机一个0~100的整数，每次用户输出字猜，
	提示如下：
		猜大了，重新猜
		猜小了，重新猜
		猜对了
         */
        System.out.println("请输入你要猜的数字");
        while(true){
            if (!print(new Scanner(System.in))){
                System.out.println("你猜对了");
            }else{
                System.out.println("你猜错了");
            }

        }
    }
    private static boolean print(Scanner s) {
            int i = s.nextInt();
            int j = (int) (Math.random()*101);
            if(i ==j){
                return false;
            }
            return true;
        }
    }

34 猜拳游戏，石头剪刀布。随机数生成石头剪刀布（0：石头 1：剪刀 2：布）

package Demo2.Test4;

import java.util.Scanner;

public class Test34 {
    public static void main(String[] args) {
        /*
        猜拳游戏，石头剪刀布。随机数生成石头剪刀布（0：石头  1：剪刀  2：布）
         */
        Scanner sc=new Scanner(System.in);
        while(true) {
            int r=(int)(Math.random()*3);
            System.out.print("请输入你的选择（0：石头  1：剪刀  2：布）：");
            int x=sc.nextInt();
            if((r==0&&x==1)||(r==1&&x==2)||(r==2&&x==0)) {
                System.out.println("你输了");
            }else {
                System.out.println("你赢了");
            }
        }

        }
    }

35 求第n项的斐波那契数列的值

package Demo2.Test5;

public class Test1 {
    public static void main(String[] args) {
        /*
        	求第n项的斐波那契数列的值
         */
        fun1(1);
    }

    private static int fun1(int n) {
        if (n == 0) {
            return 0;
        }
        if (n == 1 || n == 2) {
            return 1;
        }
        return fun1(n - 1) + fun1(n - 2);
    }
}

36 一个人开始上楼梯，假设这个人每一次只能上一个或者两个台阶当他到达第n个台阶时，问：共有多少种走法？

package Demo2.Test5;

public class Test2 {
    public static void main(String[] args) {
        /*
        一个人开始上楼梯，假设这个人每一次只能上一个或者两个台阶当他到达第n个台阶时，问：共有多少种走法？
         */
        fun2(8);
    }

    private static void fun2(int n) {
        int num = 0;
        int x = 1;
        int y = 1;
        for (int i = 0; i <= n; i++) {
            num = x + y;
            x = y;
            y = num;
        }
        System.out.println(num);
    }
}

37 不死兔子：小明今年高考，考了700，父母，给他买了一对刚刚出生小兔子，四个月后成长为成年兔子，成年后，每过一个月，假设生出一对新的小兔子

package Demo2.Test5;

import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
   /*
不死兔子：小明今年高考，考了700，父母，给他买了一对刚刚出生小兔子，四个月后成长为成年兔子，成年后，每过一个月，假设生出一对新的小兔子

	问：第n月，小明家共有多少对兔子。
   */
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(fun(n));
    }

    public static int fun(int n) {
        if (n <= 4) {
            return 1;
        }
        return fun(n - 1) + fun(n - 4);
    }
}

38 下列哪一项是“4是奇数或-9为正数”的否定（C）

A、4是偶数或-9不是负数
B、4是奇数或-9不是负数
C、4是偶数和-9是负数
D、4是奇数和-9不是负数

39 如果A是“10110110”，B是“11100000”，C是“10100000”，下面成立的是（D）

A、 C=A|B
B、 C=~A
C、 C=~B
D、 C=A&B

40 判断一个整数是奇数还是偶数，至少有两种方式实现

package Demo2.Tt;

import java.util.Scanner;
public class Test7and8 {
    public static void main(String[] args) {
        /*
        8
         */
        Scanner s = new Scanner(System.in);
        int i = s.nextInt();
        if (i%2==0){
            System.out.println("是偶数");
        }else
        {
            System.out.println("是奇数");
        }

//        //第二种方法
//
//        if (i & 1 == 0){
//            System.out.println("是偶数");
//        }else
//        {
//            System.out.println("是奇数");
//        }
    }
}

41 输入一个数，判断这个是2的指数

package Demo2.Tt;

import java.util.Scanner;


public class Test7and8 {
    public static void main(String[] args) {
  
        System.out.println("请输入一个数");
      Scanner s1 = new Scanner(System.in);
        int i1 = s.nextInt();
        if (i1 & (i1 - 1)==0){
           System.out.println("是指数");
        }else
       {
           System.out.println("不是指数");
        }
    }
}

42 请输入10位同学的java成绩，1、求平均成绩，最高成绩、最低成绩2、对10的成绩按照从低到高的顺序排列

package Demo2.Test4;

import java.util.Arrays;
import java.util.Scanner;

public class Test35 {
    public static void main(String[] args) {
        /*
        作业1：
	请输入10位同学的java成绩，1、求平均成绩，最高成绩、最低成绩2、对10的成绩按照从低到高的顺序排列
         */
        int[] ints = new int[10];
        Scanner sc = new Scanner(System.in);
        //依次赋值
        System.out.println("请输入10为同学的成绩");
        for (int i = 0; i < ints.length; i++) {
            ints[i]=sc.nextInt();
        }
        System.out.println(Arrays.toString(ints));

        //	1、求平均成绩，最高成绩、最低成绩
        printMaxAndMinAndAverage(ints);

        //对10的成绩按照从低到高的顺序排列
        printSort(ints);
        print(ints);

    }

    private static void print(int[] ints) {
        for (int i = 0; i < ints.length; i++) {
            System.out.print( ints[i]+" ");
        }
    }

    private static void printMaxAndMinAndAverage(int[] arr) {
        int max = arr[0];
        int min = arr[0];
        int sum = 0;
        for (int i = 1; i < arr.length; i++) {
            if (max<arr[i]){
                max=arr[i];
            }
            if (min>arr[i]){
                min=arr[i];
            }
            sum+=sum+arr[i];
        }
        double average=sum/arr.length;
        System.out.println("最大数为"+max);
        System.out.println("最小数为"+min);
        System.out.println("平均数"+average);
    }
    private static void printSort(int[] arr){
        boolean flag =false;
        for (int i = 0; i < arr.length-1; i++) {
            for(int j=0;j<arr.length-i-1;j++){
                if (arr[j]>arr[j+1]){
                    flag=true;
                    swap(arr,j,j+1);
                }
            }
            if (!flag){
                break;
            }else{
                flag=true;
            }
        }


    }

    private static void swap(int[] arr, int j, int j1) {
            arr[j]=arr[j]^arr[j1];
            arr[j1]=arr[j]^arr[j1];
            arr[j]=arr[j]^arr[j1];
    }
}

43 给定一个数组，判断某个元素是否在该数组中

package Demo2.Test4;

import java.util.Scanner;

public class Test36 {
    public static void main(String[] args) {
        /*
        给定一个数组，判断某个元素是否在该数组中
         */
        String[] sts={"菜徐琨","鸡你太美","爱打篮球"};
//      判断某个元素是否在该数组中
        System.out.println("请输入一个内容");
        String s = new Scanner(System.in).nextLine();

        printEquals(sts,s);


    }

    private static void printEquals(String[] sts,String s) {
        boolean flag =false;
        for (String str:sts
             ) {
            if (str.equals(s)){
                flag=true;
                break;
            }
        }
        if (flag){
            System.out.println("在该数组中");
        }
    }
}

44 将数组中的重复数据去重

package Demo2.Test4;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class Test39 {
    public static void main(String[] args) {
        /*
        将数组中的重复数据去重
         */
        int[] array={1,2,2,2,3,4,5,6};
        Set<Integer> s = new HashSet<Integer>();

        for (int i = 0; i < array.length; i++) {
            s.add(array[i]);
        }
        Integer[] i = s.toArray(new Integer[s.size()]);


        System.out.println(Arrays.toString(i));

    }
}

45 如何将10个0-10随机存入数组中

package Demo2.Test4;

import java.util.Arrays;
import java.util.Random;

public class Test40 {
    public static void main(String[] args) {
        /*
        如何将10个0-10随机存入数组中
         */

        int[] array=new int[10];


        for (int i = 0; i < array.length; i++) {
            array[i] = (int) (Math.random()*11);
        }
        System.out.println(Arrays.toString(array));
    }
}

46 存在整数数组nums，将该数组中的所有偶数元素排列到奇数元素前在 & 运算中只有当对应的两个二进制数的对应数字都为 1 时，结果才是1。所以如果对数组中某个数进行 & 运算之后的结果为1，那么该数肯定是奇数。反之，如果结果为0，那么该数肯定是偶数

package Demo2.Test4;

import java.util.Arrays;

public class Test41 {
    public static void main(String[] args) {
        /*
        存在整数数组nums，将该数组中的所有偶数元素排列到奇数元素前在 & 运算中只有当对应的两个二进制数的对应数字都为 1 时，结果才是1。所以如果对数组中某个数进行 & 运算之后的结果为1，那么该数肯定是奇数。反之，如果结果为0，那么该数肯定是偶数
         */

        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int[] array2=new int[array.length];
        int l=0;
        int r=array.length-1;
        for (int i = 0; i < array.length; i++) {
              if ((array[i]&1)==0){
                  array2[l]=array[i];
                  l++;

              }else{
                  array2[r]=array[i];
                  r--;
              }
        }

        System.out.println(Arrays.toString(array2));
    }
}

执行下列程序的输出结果为( D )

public class Test {
 public static void main(String[] args) {
 String s1 = "HelloWorld";
 String s2 = new String("HelloWorld");
 if (s1 == s2) {
 System.out.println("s1 == s2");
 } else {
 System.out.println("s1 != s2");
 }
 if (s1.equals(s2)) {
 System.out.println("s1 equals s2");
 } else {
 System.out.println("s1 not equals s2");
 }
 }
 }

A. s1 == s2
    s1 not equals s2
B. s1 == s2
    s1 equals s2
C. s1 != s2
    s1 not equals s2
D. s1 != s2
    s1 equals s2

49 某个人进入如下一个棋盘中，要求从左上角开始走，最后从右下角出来（要求只能前进，不能后退），问题：共有多少种走法？

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

package Demo2.Test4;

import java.util.Arrays;
import java.util.Scanner;

public class Test43 {
    public static void main(String[] args) {
        /*
        某个人进入如下一个棋盘中，要求从左上角开始走，
	最后从右下角出来（要求只能前进，不能后退），
	问题：共有多少种走法？

	0 0 0 0 0 0 0 0

	0 0 0 0 0 0 0 0

	0 0 0 0 0 0 0 0

	0 0 0 0 0 0 0 0

	0 0 0 0 0 0 0 0
         */



                Scanner sc=new Scanner(System.in);
                System.out.println("请输入行数：");
                int x=sc.nextInt();
                System.out.println("请输入列数：");
                int y=sc.nextInt();
                int count=run(x,y);
                System.out.println("方法总共有"+count+"种");

            }
            public static int run(int x,int y){
                int count=0;
                while (x>0&&y>0){
                    if(x==1){
                        count++;
                        x=0;
                    }else if(y==1){
                        count++;
                        y=0;
                    }else {
                        count=run(x-1,y)+run(x,y-1);
                        break;
                    }
                }
                return count;
            }

        }

49 已知二叉树的前序遍历：ABCDEFGHK中序遍历：BDCAEHGKF,根据已有条件，画出这个二叉树，同时输出该二叉树的后序遍历

49 给定一个数字，求该数字的二进制的1的个数

package Demo2.Tt1;

import java.util.Scanner;

public class Femo3Test2 {
    public static void main(String[] args) {
//        给定一个数字，求该数字的二进制的1的个数
        System.out.println("请输入该数");

        int i = new Scanner(System.in).nextInt();

        System.out.println(i+"的二进制的1的个数为"+binary(i));

    }

    private static int binary(int i) {
        int num=0;
        while(i>0){
            i=i&(i-1);
            num++;
        }

        return num;
    }
}

49 给定一个数组，该数组中除了一个元素只出现了一次，其他元素都出现两次,找到这个没有重复的元素

package Demo2.Tt1;

public class Demo3Test1 {
    public static void main(String[] args) {
        /*
        给定一个数组，该数组中除了一个元素只出现了一次，其他元素都出现两次,找到这个没有重复的元素
         */

        int[] i={2,2,1,1,5};
        System.out.println("该数组没有重复的元素为"+print(i));


    }
    private static int print(int[] i){
        int num=0;
        for (int i1 = 0; i1 < i.length; i1++) {
            num^=i[i1];
        }
        return num;
    }
}

50 给定一个数组，数组的元素共N+1个， 元素是从1到n的联系自然数，其中一个重复值,找到这个重复的元素

package Demo2.Tt1;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Demo3Test3 {
    public static void main(String[] args) {
        /*
        给定一个数组，数组的元素共N+1个， 元素是从1到n的联系自然数，其中一个重复值,找到这个重复的元素
         */

        int[] i ={1,22,22,33,33,3,4,5};
        Set<Integer> set = new HashSet<Integer>();
        print((i),set);

    }
    private static void print(int[] i,Set<Integer> set) {
        System.out.println("重复元素有");
        for (int i1 : i) {
            int a=set.size();
            set.add(i1);
            if (set.size()==a){
                System.out.println(i1);
            }
        }

    }
}

51 定义一个Admin类，该类存在，username、password属性，实现一个控制台版的用户注册登录案例,将注册的用户写在一个数组中

package Demo2.Test4;

import java.util.Scanner;

class Admin {
    protected String username;
    protected String password;

    public Admin() {
    }

    public Admin(String username, String password) {
        this.username = username;
        this.password = password;
    }
}

class Console {
    private Admin[] admin;

    public Console() {
    }

    public Console(Admin[] admin) {
        this.admin = admin;
    }

    public void register() {

        if (!(admin[0].password.equals(" ")||admin[0].username.equals(" "))){
            System.out.println("注册用户成功"+admin[0].password);
            System.out.println("注册密码成功"+admin[0].username);
        }else{
            System.out.println("注册失败");
        }



    }

    public Admin[] getAdmin() {
        return admin;
    }
}

public class Test48 {
    public static void main(String[] args) {
        /*
        定义一个Admin类，该类存在，username、password属性，实现一个控制台版的用户注册登录案例,将注册的用户写在一个数组中
         */


        System.out.println("请输入用户号");
        String s1 = new Scanner(System.in).nextLine();

        System.out.println("请输入密码");
        String s2 = new Scanner(System.in).nextLine();

        Admin a = new Admin(s1, s2);
        //将Admin类的地址存入新的Admin自己的数组中
        Admin[] admin={a};

        Console c1 = new Console(admin);

        c1.register();

    }
}

52 定义一个猫类（Cat），该猫有名字、性别、年龄、主人、皮毛

package Demo2.Test4;

class Cat {
    private String name;
    private String sex;
    private int age;
    private String fur;//皮毛

    public Cat() {
    }

    public Cat(String name, String sex, int age, String fur) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.fur = fur;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getFur() {
        return fur;
    }

    public void setFur(String fur) {
        this.fur = fur;
    }

}

class Master {
    private String name;
    private int age;
    private String address;
    protected Cat[] cat;

    public Master() {
    }

    public Master(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

public class Test49 {
    public static void main(String[] args) {
        /*
        定义一个猫类（Cat），该猫有名字、性别、年龄、主人、皮毛
         */

        //定义猫类
        Cat cat = new Cat("小花", "女", 2, "白毛");
        Cat cat2 = new Cat("小黑", "男", 1, "黑毛");


        //定义主人类
        Master master = new Master();
        master.setName("国胜");
        master.cat = new Cat[]{cat, cat2};

        System.out.println("有什么样的猫呢?");
        for (int i = 0; i < master.cat.length; i++) {
            System.out.println(master.getName() + "的猫都有"
                    + master.cat[i].getName() + "\t性别:" + master.cat[i].getAge() + "\t年龄:" + master.cat[i].getAge() + "\t肤色:" + master.cat[i].getFur());
        }
    }
}

53 （MyInteger类）设计一个名为MyInteger的类。

●一个名为value的int型数据域，存储这个对象表示的int值。
● 一个为指定的int值创建MyInteger对象的构造方法。
● 一个返回int值的get方法。
● 如果值分别为偶数、奇数或素数，那么isEven（）、isodd（）和isPrime（）方法都会返回true。
● 如果指定值分别为偶数、奇数或素数，那么相应的静态方法isEven（int）、isodd（int）和isPrime（int）会返回true。
● 如果指定值分别为偶数、奇数或素数，那么相应的静态方法isEven（MyInteger）、isOdd（MyInteger）和isPrime（MyInteger）会返回true。
● 如果该对象的值与指定的值相等，那么equals（int）和equals（MyInteger）方法返回true。
● 静态方法 parseInt（char【】）将数字字符构成的数组转换为一个int 值。
● 静态方法 parseInt（String）将一个字符串转换为一个int 值。画出该类的UML图并实现这个类。编写客户程序测试这个类中的所有方法。

package Demo2.Test4;

import java.util.Scanner;

class MyInteger{
    private int value;//存储这个对象表示的int值


    public MyInteger(int value) {
        this.value = value;
    }                                     //为指定的int值创建MyInteger对象的构造方法
    public int getValue() {
        return value;
    }


    //返回int值的获取方法
    public boolean isEven() {
        return isEven(value);
    }
    //调用静态方法判断对象中的值是否为偶数
    public boolean isOdd() {
        return isOdd(value);
    }
    //调用静态方法判断对象中的值是否为奇数
    public boolean isPrime() {
        return isPrime(value);
    }

    //调用静态方法判断对象中的值是否为素数
    public static boolean isEven(int value) {
        if(value % 2 == 0)
            return true;
        else
            return false;
    }
    //判断指定值是否为偶数
    public static boolean isOdd(int value) {
        if(value % 2 != 0)
            return true;
        else
            return false;
    }
    //判断指定值是否为奇数
    public static boolean isPrime(int value) {
        for(int i = 2; i < value - 1; i++) {
            if(value % i == 0)
                return false;
        }
        return true;
    }

    //判断指定值是否为素数
    public static boolean isEven(MyInteger m) {
        if(m.getValue() % 2 == 0)
            return true;
        else
            return false;
    }

    //判断指定值是否为偶数
    public static boolean isOdd(MyInteger m) {
        if(m.getValue() % 2 != 0)
            return true;
        else
            return false;
    }

    //判断指定值是否为奇数
    public static boolean isPrime(MyInteger m) {
        for(int i = 2; i < m.getValue() - 1; i++) {
            if(m.getValue() % 2 == 0)
                return false;
        }
        return true;
    }
    //判断指定值是否为素数
    public boolean equals(int value) {
        if(this.value == value)
            return true;
        else
            return false;
    }
    //判断该对象的值是否与指定值相等
    public boolean equals(MyInteger m) {
        if(this.value == m.getValue())
            return true;
        else
            return false;
    }
    //判断该对象的值是否与指定值相等
}

public class Test50 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        MyInteger n1 = new MyInteger(input.nextInt());
        System.out.println("n1是偶数吗？" + '\t' + n1.isEven());
        System.out.println("n1是素数吗？" + '\t' + n1.isPrime());
        System.out.println("n1是素数吗？" + '\t' + MyInteger.isPrime(n1));
        System.out.println("-------------------");
        MyInteger n2 = new MyInteger(input.nextInt());
        System.out.println("n2是奇数吗？" + '\t' + n2.isOdd());
        System.out.println("45是奇数吗？" + '\t' + MyInteger.isOdd(45));
        System.out.println("n1与n2相等吗？" + '\t' + n1.equals(n2));
        System.out.println("n1等于5吗？" + '\t' + n1.equals(5));

        input.close();

    }
}

54 自定义String类

package Demo2.Test4;


import java.util.ArrayList;
class MyString1{
    private ArrayList<Character> list = new ArrayList<>();	//数组列表

    //指定字符数组的构造方法
    public MyString1(char[] chars) {
        for (char c : chars)
            list.add(c);
    }

    //返回指定下标元素
    public char charAt(int index) {
        return list.get(index);
    }

    //返回长度
    public int length() {
        return list.size();
    }

    //返回 begin 到 end - 1 的子串
    public MyString1 substring(int begin, int end) {
        char[] temp = new char[end - begin];

        for (int i = begin; i < end; i++)
            temp[i - begin] = list.get(i);
        return new MyString1(temp);
    }

    //返回小写的形式
    public MyString1 toLowerCase() {
        char[] temp = new char[list.size()];

        for (int i = 0; i < length(); i++)
            temp[i] = Character.toLowerCase(list.get(i));
        return new MyString1(temp);
    }

    //是否等于指定串？
    public boolean equals(MyString1 s) {
        if(length() != s.length()) return false;

        for (int i = 0; i < length(); i++)
            if(charAt(i) != s.charAt(i))
                return false;
        return true;
    }

    //将整型值转换为MyString1的静态方法
    public static MyString1 valueOf(int b) {
        return new MyString1(String.valueOf(b).toCharArray());
    }

    @Override
    public String toString() {
        StringBuffer stringBuffer = new StringBuffer(list.size());

        for (Character character : list)
            stringBuffer.append(character);
        return stringBuffer.toString();
    }
}

public class Test51 {
    /*
    Class58.自定义String类（类与对象，构造函数）
     */
    public static void main(String[] args) {
        MyString1 myString1 = new MyString1(new char[] {'a', 'b','c'});
        System.out.println(myString1.charAt(0));
        System.out.println(myString1.equals(new MyString1(new char[] {'b','c'})));
        System.out.println(myString1.toLowerCase());
        System.out.println(myString1.length());
        System.out.println(myString1.substring(0, myString1.length()));

    }
}

55 建立Stack数据结构

package Demo2.Test4;

import java.util.Arrays;

public class Stack {
    int[] data;//数据
    int top;//顶端
    int capacity;//容量

    public Stack() {
    }

    public Stack(int capacity) {
        if (capacity>0){
            this.capacity = capacity;

        }else{
            System.out.println("长度有误");
        }

    }

    //压
    public void push(int e){
        if (isEmpty()){
            System.out.println("栈为空");
            return;
        }

        data[++top]=e;

    }

    //弹
    public int pop() {
        if (isEmpty()){
            System.out.println("栈已满");
            return -1;
        }
        return data[top--];
    }

    //取头
    public int peek() {
        if (isEmpty()){
            System.out.println("栈为空,无法获取头元素");
            return -1;
        }

        return data[top];
    }

    //判断空
    public boolean isEmpty() {
            return top ==-1;
    }

    //清空
    public void clear(){
        top=-1;
    }

    //大小
    public int size() {
           return top+1;
    }

    //重写toString

    @Override
    public String toString() {
        return "Stack{" +
                "data=" + Arrays.toString(data) +
                ", top=" + top +
                ", capacity=" + capacity +
                '}';
    }
}

56 给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数大于 n/2 的元素。 [1,1,1,1,2,3,3]

思路:从第一个数开始count=1，遇到相同的就加1，遇到不同的就减1，减到0就重新换个数开始计数，总能找到最多的那个

package Demo2.Test4;

public class Test52 {
    public static void main(String[] args) {
        /*
        给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数大于  n/2 的元素。       [1,1,1,1,2,3,3]

        思路:
        从第一个数开始count=1，遇到相同的就加1，遇到不同的就减1，减到0就重新换个数开始计数，总能找到最多的那个
         */


        int[] array={1,1,1,1,1,2,3,3};
        System.out.println(major(array));

    }

    public static int major(int[] nums) {
        int num = nums[0];
        int count = 1;
        for(int a = 1; a < nums.length; a ++){
            if(count > 0){
                if(num == nums[a]) count ++;
                else count --;
            }
            else {
                num = nums[a];//当遇到不同元素就进行初始化
                count = 1;
            }
        }
        return num;
    }

}

57 定义一个抽象的"Role"类 有姓名 年龄 性别等成员变量

• 定义一个抽象的"Role"类 有姓名 年龄 性别等成员变量
  1. 要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有)
     再通过GetXXX()和SetXXX()方法对各变量进行读写。具有一个抽象的play()方法
     该方法不返回任何值 同时至少定义两个构造方法。Role类中要体现出this的几种用法。
  2. 从Role类派生出一个"Employee"类 该类具有Role类的所有成员
     构造方法除外 并扩展 salary成员变量 同时增加一个静态成员变量“职工编号 ID ”。
     同样要有至少两个构造方法 要体现出this和super的几种用法
     还要求覆盖play()方法 并提供一个final sing()方法。
  3. “Manager"类继承"Employee"类 有一个final成员变量"vehicle”
  4. 在main()方法中制造Manager和Employee对象,并测试这些对象的方法

package Demo2.Test4;

//角色
abstract class Role {
    private String name;
    private int age;
    private String sex;

    public Role() {
    }

    public Role(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public abstract void play();
}

//唱歌角色
class Employee extends Role {
    private int salary;
    public static int id;

    public Employee() {
    }

    public Employee(String name, int age, String sex, int salary) {
        super(name, age, sex);
        this.salary = salary;
    }


    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public static int getId() {
        return id;
    }


    @Override
    public void play() {

        System.out.println("下一位选手是" + this.getName() + "    年龄是" + this.getSex() + "    性别" + this.getSex());
    }

    public final void sing() {
        System.out.println("歌手菜徐琨唱出了鸡的天际");
    }
}

//经理
class Manager extends Employee {
    public final static String VEHICLE = "迈凯伦";

    public void car() {
        System.out.println("经理开着" + VEHICLE);
    }
}

public class Test53 {
    public static void main(String[] args) {
        Employee ro = new Employee("菜徐琨", 24, "男", 7172);
        ro.play();
        ro.sing();

        Manager em = new Manager();
        em.car();
    }
}

58 定义一个抽象的"Role"类 有姓名 年龄 性别等成员变量

• 品尝饮料
  1、建立一个抽象类Drink 应当 a、声明一个抽象方法taste() 该方法负责输出饮料的味道 b、声明int型常量来代表不同的饮料类型 咖啡、啤酒、牛奶 如 c、声明静态工厂方法getDrink(int drinkType) 根据传入的参数创建不同的饮料对象 并返回该对象 建议使用switch语句。该方法要求声明DrinkNotFoundException 当没有相对应的饮料类型时 抛出该异常。
  2、建立Drink的具体子类 a、分别建立Drink的子类 Coffee 代表咖啡 Beer 代表啤酒 Milk 代表牛奶 ; b、实现taste()方法 要求在控制台打印各自的味道特征。
  3、建立异常类DrinkNotFoundException a、继承Exception b、在Drink的 方 法getDrink(int drinkType)中 声 明 引 发DrinkNotFoundException异常 当传入的参数没有相对应的饮料类型时 抛出异常。 c、在使用getDrink方法的类中捕捉该异常。
  4、建立Test测试类 测试以上内容的正确性 a、编写main方法 通过命令行传参的方式传入某种饮料的类型。 b、在main方法中 调用Drink类的getDrink方法 获得相应的饮料对象。注意捕获DrinkNotFoundException。 c、然后调用该饮料对象的taste()方法 输出该饮料的味道。
  5、编译程序 并运行。
  注意事项 1、仔细审题 把题目要求理解准确 2、请注意多态性的运用 3、请注意代码的书写、命名符合规范 应有适当的注释

package Demo2.Test4;

import java.util.Scanner;

abstract class Drink {
    public abstract void taste();//味道

    int Coffee, Beer, Milk;


    static int getDrink(int drinkType) throws DrinkNotFoundException {
        switch (drinkType) {
            case 1:
                System.out.println("coffee");
                new Coffee().taste();
                break;
            case 2:
                System.out.println("beer");
                new Beer().taste();
                break;
            case 3:
                System.out.println("Milk");
                new Milk().taste();
                break;
            default:
                throw new DrinkNotFoundException();
        }
        return drinkType;

    }

    static class Coffee extends Drink {

        @Override
        public void taste() {
            System.out.println("咖啡不好喝!");
        }
    }

    static class Beer extends Drink {
        @Override
        public void taste() {
            System.out.println("啤酒是苦的!");
        }
    }

    static class Milk extends Drink {
        @Override
        public void taste() {
            System.out.println("牛奶是甜的!");
        }
    }

    public static class DrinkNotFoundException extends Exception {
    }

    public static class Test54 {
        public static void main(String[] args) {
            Scanner input = new Scanner(System.in);
            System.out.println("请输入1，2，3");
            try {
                int num = input.nextInt();

                Drink.getDrink(num);
            } catch (Exception e) {
                System.out.println("错误");
            }


        }
    }
}

59 动态数组(满足基本的增删改查)

package Use;
import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.Objects;


import java.util.Arrays;

public class A {
    public static void main(String[] args) {
        Information c = new InformationImpl();

        //添加用户
        c.addUser("菜徐琨");
        c.addUser("iKun");
        c.addUser("小黑子");
        c.addUser("时长两年半");

        //删除用户
        c.removeUser(3);

        //修改用户
        c.modifyUser(0,"菜徐琨");

        //查看指定用户
        System.out.println(c.viewUsers1("小黑子"));//true
        System.out.println(c.viewUsers1("鸡你太美"));//false

        //查找所有用户
        c.viewUsers();
    }
}


class InformationImpl implements Information {
    public Object[] data;

    public int size;//初始化为0  所以根据数组下标同步的

    public int capacity;

    public InformationImpl() {
        this.capacity = 10;//容量初始化为10
        this.data = new Object[capacity];//此时数组为10
    }

    public InformationImpl(Object[] data, int size, int capacity) {
        this.data = data;
        this.size = size;
        this.capacity = capacity;
    }


    //添加用户
    @Override
    public void addUser(Object user) {
        if (this.ifFulls()) {
            this.expansion();
        }
        this.data[this.size++] = user;
    }

    //判断容量
    private  boolean ifFulls() {
        return this.capacity==this.size;//当容量和个数相等时
    }

    //数组扩容
    public void expansion(){
        int newCapacity =this.capacity+(this.capacity>>>1);//建立新容量
        this.data= Arrays.copyOf(this.data,newCapacity);//将建立好了的数组赋值于新的数组
        this.capacity = newCapacity;//将容量更新   -----------是与size区分开的

    }

    //删除指定用户信息
    @Override
    public void removeUser(int index) {
        for (int i=index;i<this.size;i++){
            data[i] = data[i+1];
        }
        this.size--;
    }


    //修改用户
    @Override
    public void modifyUser(int index, Object user) {
        this.data[index] = user;
        System.out.println("替换成功");
    }

    //查看所有用户
    @Override
    public void viewUsers() {
        System.out.println(Arrays.toString(Arrays.copyOf(this.data, this.size)));
    }

    //查看指定用户
    @Override
    public boolean viewUsers1(Object user) {
        for (int zz=0;zz<this.size;zz++){
            if(data[zz].equals(user)||data[zz]==user){
                return true;
            }
        }
        return false;
    }

    @Override
    public String toString() {
        return "InformationImpl{" +
                "data=" + Arrays.toString(data) +
                ", size=" + size +
                ", capacity=" + capacity +
                '}';
    }

    @Override
    public  boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        InformationImpl that = (InformationImpl) o;
        return size == that.size &&
                capacity == that.capacity &&
                Arrays.equals(data, that.data);
    }
}


interface Information {
    //添加用户
    void addUser(Object user);//

    //删除用户
    void removeUser(int index);

    //修改用户
    void modifyUser(int index, Object user);//

    //查看用户
    void viewUsers();//

    //查看指定用户
    boolean viewUsers1(Object user);
}

60 栈(满足基本操作)

package Demo2.Test4;





import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.Objects;

public class Stack {
    private Object[] data;

    private int size;//0

    private int capacity;   //栈的容量

    public Stack() {
        //默认创建一个10容量的栈
        this.capacity=10;
        data = new Object[capacity];
    }

    public Stack(int capacity) {
        //默认创建一个10容量的栈
        this.capacity=capacity;
        data = new Object[capacity];
    }


    //入栈
    public void push(Object e) {
        //先判断是否栈已经满了
        if (this.isFull()){
            //扩容
            //扩容的规则是原有容量的1.5倍
            this.capacity=this.capacity+(this.capacity>>>1);
        }else{
            this.data[size++]=e;
        }
    }

    //判断是否存满
    private boolean isFull() {
        return this.capacity==this.size;//容器和存储数量满为止
    }


    //扩容或缩容容器的大小
    public void resize(int len){
        Object[] arr=new Object[len];
        for (int i=0;i<data.length;i++){
            arr[i]=data[i];
        }
        this.data=Arrays.copyOf(this.data,len);
        this.capacity=len;

    }

    //判断栈是否为空
    public boolean isEmpty() {
        return this.size==0;
    }


    //出栈 删除并返回栈顶元素
    public Object pop() {
        if(this.isEmpty()){
            throw new RuntimeException("对不起,栈中已经没有元素了");
        }
        int i = --this.size;
        return this.data[i];


    }


    //获取栈顶元素
    public Object peek() {
      return this.data[this.size-1];
    }

    //获取栈中元素的个数
    public int size() {
        return this.size;
    }


    public void clear() {
      this.size=0;
    }


    @Override
    public String toString() {
       return Arrays.toString(Arrays.copyOf(this.data, this.size));//原长度与容器长度限制匹配
//       return Arrays.toString(this.data);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Stack stack = (Stack) o;
        return size == stack.size &&
                capacity == stack.capacity &&
                Arrays.equals(data, stack.data);
    }

}

class A{
    @Test
    void testStack(){
        Stack stack = new Stack();
        //入栈
        stack.push("iKun");
        stack.push("打篮球");
        stack.push("2年半");
        stack.push(666);

        System.out.println(stack.pop());//返回该元素
        System.out.println(stack.peek());//获取栈顶元素
        System.out.println(stack.size());//获取栈个数
        

        System.out.println(stack);


    }
}

61 队列(满足基本操作,利用双向栈实现)

• Stack

package com.openlab.day18.collections;

import java.util.Arrays;

public class Stack {

	private Object[] data;
	private int size;
	private int capacity;
	
	public Stack() {
		// 默认创建一个10容量的栈
		this.capacity = 10;
		data = new Object[this.capacity];
	}
	
	public Stack(int capacity) {
		this.capacity = capacity;
		data = new Object[this.capacity];
	}
	
	//进栈一个元素
	public void push(Object e){
		// 先判断栈是否已经满了
		if (this.isFull()) {
			// 扩容
			// 扩容的规则是原有容量的1.5倍
			int length = this.capacity + (this.capacity >>> 1);
			this.resize(length);
		} else {
			this.data[size++] = e;
		}
	}		
	
	// 判断是否存满
	private boolean isFull() {
		return this.capacity == this.size;
	}
	
	// 扩容或缩容容器的大小
	private void resize(int len){
//		Object[] arr = new Object[len];
//		for (int i = 0; i < data.length; i++) {
//			arr[i] = data[i];
//		}
//		this.data = arr;
		this.data = Arrays.copyOf(this.data, len);
		this.capacity = len;
	}	
	
	// 判断栈是否为空
	public boolean isEmpty(){
		return this.size == 0;
	}			
	
	// 出栈一个元素
	public Object pop(){
		if (this.isEmpty()) {
			throw new RuntimeException("对不起，栈中已经没有元素了");
		}
		return this.data[--this.size];
	}	
	
	// 查看栈顶元素
	public Object peek(){
		return this.data[this.size - 1];
	}					
	
	// 获取栈中元素的个数
	public int size(){
		return this.size;
	}					
	
	// 清空栈
	public void clear(){
		this.size = 0;
	}
	
	// 返回栈的字符串形式
	public String toString(){
		return Arrays.toString(Arrays.copyOf(this.data, this.size));
	}	
	
	// 对比两个栈是否相等
	@Override
	public boolean equals(Object o)	{
		Stack s = (Stack) o;
		if (this.size != s.size()) {
			return false;
		}
		for (int i = 0; i < s.size() ; i++) {
			if (data[i] != s.data[i]) {
				return false;
			}
		}
		return true;
	}
}

• Queue

package com.openlab.day18.collections;

public class Queue2 {
	
	private Stack stackA;					
	private Stack stackB;		

	public Queue2() {
		stackA = new Stack();
		stackB = new Stack();
	}
	
	// 进队一个元素
	public void offer(Object e){
		this.stackA.push(e);
	}	
	
	// 出队一个元素
	public Object poll(){
		remove();
		return stackB.pop();
	}

	private void remove() {
		if (this.stackB.size() == 0) {
			while (this.stackA.size() != 0) {
				this.stackB.push(this.stackA.pop());
			}
		}
	}	
	
	// 查看队首元素
	public Object element(){
		if (this.stackB.size() != 0) {
			return this.stackB.peek();
		} else {
			remove();
		}
		return this.stackB.peek();
	}		
	
	// 获取队列中元素的个数
	public int size(){
		remove();
		return this.stackB.size();
	}		
	
	// 判断队列是否为空
	public boolean isEmpty(){
		return this.stackB.size() == 0 && this.stackA.size() == 0;
	}
	
	// 清空队列
	public void clear(){
		this.stackA.clear();
		this.stackB.clear();
	}	
	
	// 返回队列的字符串形式
	public String toString(){
		return "展示B中的值";
	}
	
	public boolean equals(Object o) {
		return true;
	}
	
}

62 链表(满足基本操作)

import java.util.Random;

public class Manage {

    public static void main(String[] args) {
        MyLinkedList<Comparable> list = new MyLinkedList();//创建单向列表对象
        Random ran = new Random();
        int num = ran.nextInt(5)+5;
        System.out.println("添加的个数为"+num);
        System.out.println("---添加---");
        for(int i=0;i<num;i++){
            list.add(i);
            System.out.print("  "+list.get(i));
        }
        System.out.println();
        System.out.println("添加后链表的Size为："+list.size());
        System.out.println();
        //设置
        list.set(1, "5");
        for(int i=0;i<num;i++){
            System.out.print("  "+list.get(i));
        }
        System.out.println();
        System.out.println("移除最后一个");
        //移除
        list.remove(num-1);
        for(int i=0;i<list.size();i++){
            System.out.print("  "+list.get(i));
        }
        System.out.println();
        System.out.println("移除链表的Size为："+list.size());
        System.out.println();
        //插入
        System.out.println("---插入---");
        list.insert(num-2, "999");
        for(int i=0;i<list.size();i++){
            System.out.print("  "+list.get(i));
        }
        System.out.println();
        System.out.println("插入链表的Size为："+list.size());
        //反转
        list.back();
        System.out.println();
        System.out.println("---反转---");
        for(int i=0;i<list.size();i++){
            System.out.print("  "+list.get(i));
        }
        System.out.println();
        System.out.println("反转链表的Size为："+list.size());
        System.out.println("---------------------------------");


        //添加循环链表
        MyLinkedList list1 = new MyLinkedList();
        for(int i=0;i<num;i++){
            list1.addfor(i);
        }

        for(int i=0;i<list1.size();i++){
            System.out.print("  "+list1.get(i));
        }
        System.out.println();

        list1.insert(0,"23");
        for(int i=0;i<list1.size();i++){
            System.out.print("  "+list1.get(i));
        }
        System.out.println();


    }

}

class MyLinkedList<E> {
    private Node root = new Node();// 空节点
    private Node next;// 下一个节点
    private Node last;// 始终表示最后一个节点
    private int size;

    public int size() {
        return size;
    }

    /**
     * 向链表添加节点的方法
     */
    public void add(E e) {
        next = new Node(e);
        if (size == 0) {// 如果是第一个节点
            root.setNext(next);// 添加到空节点后面
            last = next;// 更新最后一个节点
            size++;
        } else {
            last.setNext(next);// 添加到最后一个节点后面
            last = next;// 更新最后一个节点
            size++;
        }
    }

    /**
     * get节点元素的方法
     */
    public Object get(int index) {
        checkIndex(index);// 检查index
        Node node = root.getNext();
        for (int i = 0; i < index; i++) {// 找到下标为index的节点
            node = node.getNext();
        }
        return node.getData();

    }

    /**
     * set节点元素的方法
     */
    public void set(int index, E e) {
        checkIndex(index);// 检查index
        Node node = root.getNext();
        for (int i = 0; i < index; i++) {// 找到下标为index的节点
            node = node.getNext();
        }
        node.setData(e);

    }

    /**
     * remove节点的方法
     */
    public void remove(int index) {
        checkIndex(index);// 检查index
        Node node = root.getNext();
        if (index != 0) {//如果不是第一个节点
            for (int i = 0; i < index; i++) {// 找到下标为index的节点
                node = node.getNext();
            }
            // 找到下标为index-1的节点，即前一个节点
            Node node1 = root.getNext();
            for (int i = 0; i < index - 1; i++) {
                node1 = node1.getNext();
            }

            if (index != size - 1) {// 如果不是最后一个节点
                Node node2 = node.getNext();// 下标index的下一个节点
                node1.setNext(null);// 断开前一个节点和index节点
                node1.setNext(node2);// 将前一个节点指向后一个节点
            } else {// 是最后一个节点
                node1.setNext(null);// 断开前一个节点和index节点
            }
            node.setData(null);// 删除节点存贮的内容
            node.setNext(null);// 删除index节点指向
        } else {//移除第一个节点
            Node node4 = root.getNext();
            Node node5 = node4.getNext();
            root.setNext(null);
            root.setNext(node5);
            node4.setNext(null);

        }
        size--;
    }

    /**
     * 插入节点的方法
     */
    public void insert(int index, E e) {
        checkIndex(index);// 检查index
        // 找到下标为index的节点
        Node node = root.getNext();
        for (int i = 0; i < index; i++) {
            node = node.getNext();

        }
        Node node1 = new Node(e);
        if (index == 0) {// 如果要插入在最前面
            root.setNext(null);// 断开空节点和第一个节点
            root.setNext(node1);// 空节点指向新节点
            node1.setNext(node);// 新节点指向原第一个节点

        } else {
            // 找到下标为index节点的前一个节点
            Node node2 = root.getNext();
            for (int i = 0; i < index - 1; i++) {
                node2 = node2.getNext();
            }
            node2.setNext(null);// 断开前一个节点
            node2.setNext(node1);
            node1.setNext(node);
        }
        size++;
    }

    /**
     * 反转
     */

    public void back() {
        int num = size - 1;
        Node node = root.getNext();// 得到下标为num的点
        for (int i = 0; i < num; i++) {
            node = node.getNext();
        }
        last = node;// 更新last
        if (num > 0) {

            for (int j = 0; j < num; j++) {
                Node node1 = root.getNext();// 找到下标为num-j-1的点
                for (int i = 0; i < num - j - 1; i++) {
                    node1 = node1.getNext();
                }

                node1.setNext(null);// 该节点的引用域为空
                last.setNext(node1);// 最后一个几点指向该节点
                last = node1;// 更新最后一个节点
            }
            num--;
        }
        root.setNext(null);// 断开根节点与原第一个节点
        root.setNext(node);// 根节点指向原最后一个节点

    }

    /**
     * 添加循环链表
     */
    public void addfor(E e) {
        next = new Node(e);
        if (size == 0) {// 如果是第一个节点
            root.setNext(next);// 添加到空节点后面
            last = next;// 更新最后一个节点
            size++;
        } else {
            last.setNext(next);// 添加到最后一个节点后面
            last = next;// 更新最后一个节点
            last.setNext(null);
            last.setNext(root.getNext());// 最后一个节点指向第一个节点
            size++;
        }
    }

    /**
     * 添加双向链表
     */
    public void duladd(E e) {
        next = new Node(e);
        if (size == 0) {// 如果是第一个节点
            root.setNext(next);// 添加到空节点后面
            last = next;// 更新最后一个节点
            size++;
        } else {

            last.setNext(next);// 添加到最后一个节点后面
            next.setBefor(last);// next指向前一个节点
            last = next;// 更新最后一个节点
            size++;
        }
    }

    /**
     * 检查下标Index是否合法
     */
    private void checkIndex(int index) {
        if (index < 0 || index > size) {// 不合法报错
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    private String outOfBoundsMsg(int index) {
        return "Index: " + index + ", Size: " + size;
    }
}

class Node {
    private Object data;
    private Node next;
    private Node befor;

    public Node() {

    }
    public Node(Object data) {
        super();
        this.data = data;
    }
    public Node getBefor() {
        return befor;
    }
    public void setBefor(Node befor) {
        this.befor = befor;
    }
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }
}