Java从0到1（B站学系黑马Java课程）（2）

Day10

1.API

1.1API概述

• 什么是API

  API (Application Programming Interface) ：应用程序编程接口

• java中的API

  指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

• api文档  文档 密码：u64r 
  --来自百度网盘超级会员V5的分享​​​​​​​

1.2如何使用API帮助文档

• 打开帮助文档

• 找到索引选项卡中的输入框

• 在输入框中输入Random

• 看类在哪个包下

• 看类的描述

• 看构造方法

• 看成员方法

2.String类

2.1String类概述

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！

2.2String类的特点

• 字符串不可变，它们的值在创建后不能被更改

• 虽然 String 的值是不可变的，但是它们可以被共享

• 字符串效果上相当于字符数组( char[] )，但是底层原理是字节数组( byte[] )

2.3String类的构造方法

• 常用的构造方法

  方法名	说明
  public String()	创建一个空白字符串对象，不含有任何内容
  public String(char[] chs)	根据字符数组的内容，来创建字符串对象
  public String(byte[] bys)	根据字节数组的内容，来创建字符串对象
  String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc

• 示例代码

  public class StringDemo01 {
      public static void main(String[] args) {
          //public String()：创建一个空白字符串对象，不含有任何内容
          String s1 = new String();
          System.out.println("s1:" + s1);
  ​
          //public String(char[] chs)：根据字符数组的内容，来创建字符串对象
          char[] chs = {'a', 'b', 'c'};
          String s2 = new String(chs);
          System.out.println("s2:" + s2);
  ​
          //public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
          byte[] bys = {97, 98, 99};
          String s3 = new String(bys);
          System.out.println("s3:" + s3);
  ​
          //String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc
          String s4 = "abc";
          System.out.println("s4:" + s4);
      }
  }

2.4创建字符串对象两种方式的区别

• 通过构造方法创建

  通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同

• 直接赋值方式创建

  以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

• 键盘输入的scanner也是new出来的字符串

2.5字符串的比较

2.5.1==号的作用

• 比较基本数据类型：比较的是具体的值

• 比较引用数据类型：比较的是对象地址值

2.5.2equals方法的作用

• 方法介绍

  public boolean equals(String s)     比较两个字符串内容是否相同、区分大小写

• 示例代码

  public class StringDemo02 {
      public static void main(String[] args) {
          //构造方法的方式得到对象
          char[] chs = {'a', 'b', 'c'};
          String s1 = new String(chs);
          String s2 = new String(chs);
  ​
          //直接赋值的方式得到对象
          String s3 = "abc";
          String s4 = "abc";
  ​
          //比较字符串对象地址是否相同
          System.out.println(s1 == s2);
          System.out.println(s1 == s3);
          System.out.println(s3 == s4);
          System.out.println("--------");
  ​
          //比较字符串内容是否相同
          System.out.println(s1.equals(s2));
          System.out.println(s1.equals(s3));
          System.out.println(s3.equals(s4));
      }
  }

2.6用户登录案例

2.6.1案例需求

已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示

2.6.2代码实现

public class Test1登录案例 {
    public static void main(String[] args) {
        //1.定义两个变量用来记录正确的用户名和密码
        String rightUsername = "itheima";
        String rightPassword = "1234qwer";
​
        //2.键盘录入用户名和密码
        //ctrl + alt + T 选择包裹方式
​
        for (int i = 0; i < 3; i++) {//0 1 2
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名");
            String username = sc.next();
            System.out.println("请输入密码");
            String password = sc.next();
​
            //3.判断比较
            if (username.equals(rightUsername) && password.equals(rightPassword)) {
                System.out.println("登录成功");
                //如果正确，循环结束
                break;
            } else {
                //最后一次机会
                if(i == 2){
                    System.out.println("账户" + username + "被锁定，请联系黑马程序员官方小姐姐：XXXXXXX");
                }else{
                    //不是最后一次机会
                    System.out.println("用户名或密码错误，登录失败,还剩下" + (2 - i) + "次机会");//2 1 0
                }
            }
        }
​
    }
}
​

2.7遍历字符串案例

2.7.1案例需求

键盘录入一个字符串，使用程序实现在控制台遍历该字符串

2.7.2直接遍历字符串

public class Test2字符串直接遍历 {
    public static void main(String[] args) {
        //两个方法：
        //charAt()：会根据索引获取对应的字符
        //length(): 会返回字符串的长度
​
​
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String str = sc.next();
        System.out.println(str);
​
        //2.遍历
        for (int i = 0; i < str.length(); i++) {
            //i 依次表示字符串的每一个索引
            //索引的范围：0 ~  长度-1
​
            //根据索引获取字符串里面的每一个字符
            //ctrl + alt + V 自动生成左边的接受变量
            char c = str.charAt(i);
            System.out.println(c);
        }
    }
}
​

2.8统计字符次数案例

2.8.1案例需求

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)

2.8.2代码实现

public class Test4统计个数 {
    public static void main(String[] args) {
        //键盘录入一个字符串，统计大写，小写，数字出现的次数
​
​
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
​
​
        //2.统计 --- 计数器count
        //此时我要统计的有3样东西，所以要定义3个计数器分别进行统计
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        //得到这个字符串里面每一个字符
        for (int i = 0; i < str.length(); i++) {
            //i 表示字符串中的索引
            //c 表示字符串中的每一个字符
            char c = str.charAt(i);
​
            //对c进行判断
            if (c >= 'a' && c <= 'z') {
                smallCount++;
            }else if(c >= 'A' && c <= 'Z'){
                bigCount++;
            }else if(c >= '0' && c <= '9'){
                numberCount++;
            }
        }
​
        //3.当循环结束之后，三个变量记录的就是对应的个数
        System.out.println("大写字符有:" + bigCount + "个");
        System.out.println("小写字符有:" + smallCount + "个");
        System.out.println("数字字符有:" + numberCount + "个");
    }
}
​

2.9字符串拼接案例

2.9.1案例需求

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，

并在控制台输出结果。例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

2.9.2代码实现

public class Test5数组拼接成字符串 {
    public static void main(String[] args) {
        //定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
        //并在控制台输出结果。例如，数组为 int[] arr = {1,2,3};
        //执行方法后的输出结果为：[1, 2, 3]
​
​
        int[] arr = {1, 2, 3, 4, 5};
​
        String str = arrToString(arr);
        System.out.println(str);
​
    }
​
​
    //作用：把一个数组变成字符串
    public static String arrToString(int[] arr) {
        String s = "";
        //拼接左括号
        s = s + "["; //此时是拿着长度为0的字符串，跟[进行拼接，产生一个新的字符串。
        //把新的字符串再赋值给s，此时变量s记录的就是新的字符串"["的地址值
​
        //下面我想得到数组里面的每一个元素并进行拼接
        //那么就需要遍历数组，得到每一个元素才行
        for (int i = 0; i < arr.length; i++) {
            //假设第一次循环:i = 0 获取的就是0索引上的元素
            //在拼接的时候："[" + 1 + ", " 拼接完毕之后产生一个新的字符串 "[1, "
            //第二次循环：i = 1 获取的就是1索引上的元素
            //在拼接的时候： 此时s就是第一次循环结束后拼接完毕的结果："[1, "
            //在拼接的时候："[1, " + 2 + ", " 拼接完毕之后产生一个新的字符串 "[1, 2, "
            //...
           if(i == arr.length - 1){
               //如果是最后一个元素，那么不需要拼接逗号空格
               s = s + arr[i];
           }else{
               //如果不是最后一个元素，需要拼接元素和逗号空格
               s = s + arr[i] + ", ";
           }
        }
​
        //等循环结束之后，再拼接最后一个右括号
        s = s + "]";
​
        return s;
​
    }
​
​
    //用来遍历数组
    public static void printArr(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
        System.out.println("]");
​
        //[1, 2, 3, 4, 5]
        //我们现在要知道，这个最终结果是怎么来的？
        //从到右依次打印得来的。
    }
}
​

2.10字符串反转案例

2.10.1案例需求

定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果

例如，键盘录入 abc，输出结果 cba

2.10.2代码实现

public class Test6反转字符串 {
    public static void main(String[] args) {
        /*定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
        例如，键盘录入 abc，输出结果 cba*/
​
​
​
        //1.定义一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        //2.定义一个方法，反转字符串
        //abc  --->  cba
        //可以把字符串倒着遍历，再拼接
        String result = reverse(str);
        System.out.println(result);
​
​
    }
​
    //注释：方法的作用就是反转字符串
    //把传递进来的字符串进行反转
    public static String reverse(String str){//abc
        //核心思想：倒着遍历并进行拼接就可以了
        //fori :正着遍历  forr：倒着遍历
        String s = "";
        for (int i = str.length() - 1; i >= 0; i--) {
            //i 依次表示字符串里面的每一个索引（倒着的）
            //我们就可以拿到里面的每一个字符并拼接
            s = s + str.charAt(i);
        }
​
        //把倒着拼接之后的结果返回即可
        return s;
​
    }
}
​

2.11 金额转换

2.11.1 案例需求

把2135变成：零佰零拾零万贰仟壹佰叁拾伍元

把789变成：零佰零拾零万零仟柒佰捌拾玖元

2.11.2 代码实现

package com.itheima.stringdemo;
​
import java.util.Scanner;
​
public class StringDemo9 {
    public static void main(String[] args) {
        //1.键盘录入一个金额
        Scanner sc = new Scanner(System.in);
        int money;
        while (true) {
            System.out.println("请录入一个金额");
            money = sc.nextInt();
            if (money >= 0 && money <= 9999999) {
                break;
            } else {
                System.out.println("金额无效");
            }
        }
​
        //定义一个变量用来表示钱的大写
        String moneyStr = "";
​
        //2.得到money里面的每一位数字,再转成中文
        while (true) {//2135
            //从右往左获取数据，因为右侧是数据的个位
            int ge = money % 10;
            String capitalNumber = getCapitalNumber(ge);
            //把转换之后的大写拼接到moneyStr当中
            moneyStr = capitalNumber + moneyStr;
            //第一次循环 ： "伍" + "" = "伍"
            //第二次循环 ： "叁" + "伍" = "叁伍"
            //去掉刚刚获取的数据
            money = money / 10;
​
            //如果数字上的每一位全部获取到了，那么money记录的就是0，此时循环结束
            if (money == 0) {
                break;
            }
        }
​
        //3.在前面补0，补齐7位
        int count = 7 - moneyStr.length();
        for (int i = 0; i < count; i++) {
            moneyStr = "零" + moneyStr;
        }
        System.out.println(moneyStr);//零零零贰壹叁伍
​
        //4.插入单位
        //定义一个数组表示单位
        String[] arr = {"佰","拾","万","仟","佰","拾","元"};
        //               零    零   零   贰   壹   叁   伍
​
        //遍历moneyStr，依次得到 零    零   零   贰   壹   叁   伍
        //然后把arr的单位插入进去
​
        String result = "";
        for (int i = 0; i < moneyStr.length(); i++) {
            char c = moneyStr.charAt(i);
            //把大写数字和单位拼接到result当中
            result = result + c + arr[i];
        }
​
        //5.打印最终结果
        System.out.println(result);
​
    }
​
​
    //定义一个方法把数字变成大写的中文
    //1 -- 壹
    public static String getCapitalNumber(int number) {
        //定义数组，让数字跟大写的中文产生一个对应关系
        String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        //返回结果
        return arr[number];
    }
​
}
​
​

2.12 手机号屏蔽

需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽

最终效果为：131****9468

代码实现：

public class Test8手机号屏蔽 {
    public static void main(String[] args) {
        /*以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
        最终效果为：131****9468*/
​
        //1.键盘录入一个手机号码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号码");
        String phoneNumber = sc.next();//13112349408
​
        //2.截取手机号码中的前三位
        String star = phoneNumber.substring(0, 3);
​
        //3.截取手机号码中的最后四位
        //此时我用substring方法，是用1个参数的，还是两个参数的？1个参数的会更好
        //因为现在我要截取到最后，所以建议使用1个参数的。
        String end = phoneNumber.substring(7);
​
        //4.拼接
        String result = star + "****" + end;
​
        System.out.println(result);
​
    }
}
​
​

2.13 敏感词替换

需求1：键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换

public class Test9敏感词替换 {
    public static void main(String[] args) {
        //1.定义一个变量表示骂人的话
        String talk = "后裔你玩什么啊，TMD";
​
​
        //2.把这句话中的敏感词进行替换
        String result = talk.replace("TMD", "***");
​
        //3.打印
        System.out.println(talk);
        System.out.println(result);
    }
}
​
​

需求2：如果要替换的敏感词比较多怎么办？

public class Test10多个敏感词替换 {
    public static void main(String[] args) {
        //实际开发中，敏感词会有很多很多
​
        //1.先键盘录入要说的话
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要说的话");
        String talk = sc.next();//后裔你玩什么啊，TMD,GDX,ctmd,ZZ
​
        //2.定义一个数组用来存多个敏感词
        String[] arr = {"TMD","GDX","ctmd","ZZ","lj","FW","nt"};
​
        //3.把说的话中所有的敏感词都替换为***
​
        for (int i = 0; i < arr.length; i++) {
            //i 索引
            //arr[i] 元素 --- 敏感词
            talk = talk.replace(arr[i],"***");
        }
​
        //4.打印结果
        System.out.println(talk);//后裔你玩什么啊，***,***,***,***
​
    }
}
​
​

2.14 身份证信息查看

身份证的每一位都是有固定的含义：

• 1、2位：省份

• 3、4位：城市

• 5、6位：区县

• 7-14位：出生年、月、日

• 15、16位：所在地派出所

• 17位：性别（奇数男性，偶数女性）

• 18位：个人信息码（随机产生）

要求打印内容方式如下：

人物信息为：

出生年月日：XXXX年X月X日

性别为：男/女

package com.itheima.stringdemo;
​
public class StringDemo11 {
    public static void main(String[] args) {
        //1.定义一个字符串记录身份证号码
        String id = "321281202001011234";
​
        //2.获取出生年月日
        String year = id.substring(6, 10);
        String month = id.substring(10, 12);
        String day = id.substring(12, 14);
​
​
        System.out.println("人物信息为：");
        System.out.println("出生年月日:" + year + "年" + month + "月" + day + "日");
​
        //3.获取性别
        char gender = id.charAt(16);//'3'  ---> 3
        //利用ASCII码表进行转换
        //'0' --->  48
        //'1' --->  49
        //'2' --->  50
        //'3' --->  51
        //'4' --->  52
        //'5' --->  53
        //'6' --->  54
        //'7' --->  55
        //'8' --->  56
        //'9' --->  57
​
       int num = gender - 48;
        if(num % 2 == 0){
            System.out.println("性别为:女");
        }else{
            System.out.println("性别为:男");
        }
    }
}
​

3.StringBuilder

StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的。

当我们在拼接字符串和反转字符串的时候会使用到.

当我们直接打印StringBuilder时，打印的是其属性值，而不是其地址，Java底层设置的

3.1 基本使用

使用场景：

1. 字符串的拼接

2. 字符串的反转

public class StringBuilderDemo3 {
    public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb = new StringBuilder("abc");
​
        //2.添加元素
        /*sb.append(1);
        sb.append(2.3);
        sb.append(true);*/
        //反转
        sb.reverse();
​
        //获取长度
        int len = sb.length();
        System.out.println(len);
        //打印
        //普及：
        //因为StringBuilder是Java已经写好的类
        //java在底层对他做了一些特殊处理。
        //打印对象不是地址值而是属性值。
        System.out.println(sb);
    }
}

3.2 链式编程

public class StringBuilderDemo4 {
    public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb = new StringBuilder();
​
        //2.添加字符串
        sb.append("aaa").append("bbb").append("ccc").append("ddd");
​
        System.out.println(sb);//aaabbbcccddd
​
        //3.再把StringBuilder变回字符串
        String str = sb.toString();
        System.out.println(str);//aaabbbcccddd
​
    }
}
​

4. StringJoiner

• StringJoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。

• 作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用。

• JDK8出现的

基本使用：

//1.创建一个对象，并指定中间的间隔符号
StringJoiner sj = new StringJoiner("---");
//2.添加元素
sj.add("aaa").add("bbb").add("ccc");
//3.打印结果
System.out.println(sj);//aaa---bbb---ccc
​

//1.创建对象
StringJoiner sj = new StringJoiner(", ","[","]");
//2.添加元素
sj.add("aaa").add("bbb").add("ccc");
int len = sj.length();
System.out.println(len);//15
//3.打印
System.out.println(sj);//[aaa, bbb, ccc]
String str = sj.toString();
System.out.println(str);//[aaa, bbb, ccc]
​

关于字符串的小扩展：

1. 字符串存储的内存原理

   String s = “abc”；直接赋值

   特点：

   此时字符串abc是存在字符串常量池中的。

   先检查字符串常量池中有没有字符串abc，如果有，不会创建新的，而是直接复用。如果没有abc，才会创建一个新的。

   所以，直接赋值的方式，代码简单，而且节约内存。

2. new出来的字符串

   看到new关键字，一定是在堆里面开辟了一个小空间。

   String s1 = new String（“abc”）；

   String s2 = “abc”；

   s1记录的是new出来的，在堆里面的地址值。

   s2是直接赋值的，所以记录的是字符串常量池中的地址值。

3. ==号比较的到底是什么？

   如果比较的是基本数据类型：比的是具体的数值是否相等。

   如果比较的是引用数据类型：比的是地址值是否相等。

   结论：==只能用于比较基本数据类型。不能比较引用数据类型。

4. 字符串拼接的底层原理

   没有变量参与，全部都是字符串时，“a”+“b”，触发字符串优化机制，在编译时就已经形成了最终结果（class中存的已经是ab了，相当于s=“ab”）。

   有变量参与，s1+“a”；JDK8以前，底层使用stringbuilder来拼接，相当于先创建一个stringbuilder对象，利用append把字符串池中的内容添加到其中，再转为string，即new StringBuilder().append(s1).apppend("b").toString();在JDK8以后，会预估创建一个数组，然后把字符全部放到数组中，再把数组转为字符串。

   String s1 = “abc”；

   String s2 =“a”+“b”+“c”；

   s1 = = s2 相等注意，s2拼接中没有变量，所以直接在字符串常量池中查找复用。其地址值一致。

5. StringBuilder提高效率原理图

6. StringBuilder源码分析

   • 默认创建一个长度为16的字节数组

• 添加内容长度小于16，直接存

  • 添加的内容大于16会扩容（原来的容量*2+2）

  • 如果扩容后还不够，以实际长度为准

Day11

1.ArrayList

集合和数组的优势对比：

1. 长度可变

2. 添加数据的时候不需要考虑索引，默认将数据添加到末尾

3. 集合创建时要在后边写泛型<>,用来限定集合中存储的数据类型

1.1 ArrayList类概述

• 什么是集合

  提供一种存储空间可变的存储模型，存储的数据容量可以发生改变

• ArrayList集合的特点

  长度可以变化，只能存储引用数据类型。基本类型要转为对应的包装类

• 泛型的使用

  用于约束集合中存储元素的数据类型

1.2 ArrayList类常用方法

1.2.1 构造方法

方法名	说明
public ArrayList()	创建一个空的集合对象

1.2.2 成员方法

方法名	说明
public boolean add(要添加的元素)	将指定的元素追加到此集合的末尾
public boolean remove(要删除的元素)	删除指定元素,返回值表示是否删除成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中的元素的个数

1.2.3 示例代码

public class ArrayListDemo02 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> array = new ArrayList<String>();
​
        //添加元素
        array.add("hello");
        array.add("world");
        array.add("java");
​
        //public boolean remove(Object o)：删除指定的元素，返回删除是否成功
        //        System.out.println(array.remove("world"));
        //        System.out.println(array.remove("javaee"));
​
        //public E remove(int index)：删除指定索引处的元素，返回被删除的元素
        //        System.out.println(array.remove(1));
​
        //IndexOutOfBoundsException
        //        System.out.println(array.remove(3));
​
        //public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
        //        System.out.println(array.set(1,"javaee"));
​
        //IndexOutOfBoundsException
        //        System.out.println(array.set(3,"javaee"));
​
        //public E get(int index)：返回指定索引处的元素
        //        System.out.println(array.get(0));
        //        System.out.println(array.get(1));
        //        System.out.println(array.get(2));
        //System.out.println(array.get(3)); //？？？？？？ 自己测试
​
        //public int size()：返回集合中的元素的个数
        System.out.println(array.size());
​
        //输出集合
        System.out.println("array:" + array);
    }
}

1.3 ArrayList存储字符串并遍历

1.3.1 案例需求

创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合

1.3.2 代码实现

public class ArrayListDemo3 {
    public static void main(String[] args) {
        //1.创建集合对象
        ArrayList<String> list = new ArrayList<>();
​
        //2.添加元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
​
        //3.遍历
        //快捷键: list.fori 正向遍历
        //list.forr 倒着遍历
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            //i 依次表示集合里面的每一个索引
​
            if(i == list.size() - 1){
                //最大索引
                System.out.print(list.get(i));
            }else{
                //非最大索引
                System.out.print(list.get(i) + ", ");
            }
        }
        System.out.print("]");
    }
}
​

1.4 ArrayList存储学生对象并遍历

1.4.1 案例需求

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

1.4.2 代码实现

public class ArrayListDemo4 {
    public static void main(String[] args) {
        //1.创建集合对象，用来存储数据
        ArrayList<Student> list = new ArrayList<>();
​
        //2.创建学生对象
        Student s1 = new Student("zhangsan",16);
        Student s2 = new Student("lisi",15);
        Student s3 = new Student("wangwu",18);
​
        //3.把学生对象添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);
​
        //4.遍历
        for (int i = 0; i < list.size(); i++) {
            //i 依次表示集合中的每一个索引
            Student stu = list.get(i);
            System.out.println(stu.getName() + ", " + stu.getAge());
        }
​
​
​
    }
}
​

1.5 查找用户的索引

需求：

1，main方法中定义一个集合，存入三个用户对象。

用户属性为：id，username，password

2，要求：定义一个方法，根据id查找对应的学生信息。

如果存在，返回索引

如果不存在，返回-1

代码示例：

public class ArrayListDemo6 {
    public static void main(String[] args) {
        /*需求：
        1，main方法中定义一个集合，存入三个用户对象。
        用户属性为：id，username，password
        2，要求：定义一个方法，根据id查找对应的学生信息。
        如果存在，返回索引
        如果不存在，返回-1*/
​
​
        //1.创建集合对象
        ArrayList<User> list = new ArrayList<>();
​
        //2.创建用户对象
        User u1 = new User("heima001", "zhangsan", "123456");
        User u2 = new User("heima002", "lisi", "1234");
        User u3 = new User("heima003", "wangwu", "1234qwer");
​
        //3.把用户对象添加到集合当中
        list.add(u1);
        list.add(u2);
        list.add(u3);
​
        //4.调用方法，通过id获取对应的索引
        int index = getIndex(list, "heima001");
​
        System.out.println(index);
​
    }
​
​
    //1.我要干嘛？  根据id查找对应的学生信息
    //2.我干这件事情需要什么才能完成？   集合 id
    //3.方法的调用处是否需要继续使用方法的结果？
    //要用必须返回，不要用可以返回也可以不返回
    //明确说明需要有返回值 int
    public static int getIndex(ArrayList<User> list, String id) {
        //遍历集合得到每一个元素
        for (int i = 0; i < list.size(); i++) {
            User u = list.get(i);
            String uid = u.getId();
            if(uid.equals(id)){
                return i;
            }
        }
        //因为只有当集合里面所有的元素都比较完了，才能断定id是不存在的。
        return -1;
    }
}
​

1.6 判断用户的是否存在

public class ArrayListDemo5 {
    public static void main(String[] args) {
       /* 需求：
        1，main方法中定义一个集合，存入三个用户对象。
        用户属性为：id，username，password
        2，要求：定义一个方法，根据id查找对应的学生信息。
        如果存在，返回true
        如果不存在，返回false*/
​
        //1.定义集合
        ArrayList<User> list = new ArrayList<>();
​
        //2.创建对象
        User u1 = new User("heima001","zhangsan","123456");
        User u2 = new User("heima002","lisi","12345678");
        User u3 = new User("heima003","wangwu","1234qwer");
​
        //3.把用户对象添加到集合当中
        list.add(u1);
        list.add(u2);
        list.add(u3);
​
        //4.调用方法，查询id是否存在
        boolean result = contains(list, "heima001");
        System.out.println(result);
​
    }
​
    //定义在测试类中的方法需要加static
    //1.我要干嘛？ 我要根据id查询学生是否存在
    //2.我干这件事情，需要什么才能完成？ 集合 id
    //3.方法的调用处是否需要使用方法的结果？
    //如果要用，必须返回，如果不用，可以返回也可以不返回
    //但是本题明确说明需要返回
    public static boolean contains(ArrayList<User> list, String id){
        //循环遍历集合，得到集合里面的每一个元素
        //再进行判断
​
        for (int i = 0; i < list.size(); i++) {
            //i 索引  list.get(i); 元素
            User u = list.get(i);
            //判断id是否存在，我是拿着谁跟谁比较
            //需要把用户对象里面的id拿出来再进行比较。
            String uid = u.getId();
            if(id.equals(uid)){
                return true;//return 关键字：作用就是结束方法。
            }
        }
        //只有当集合里面所有的元素全部比较完毕才能认为是不存在的。
        return false;
    }
​
}
​

2.包装类

包装类用于把基本数据类型转化为引用类型，达到在集合中，限定数据输入类型的要求。

byte-- > Byte

short-- > Short

char--> Character

int--> Integer

long--> Long

float--> Float

double--> Double

boolean--> Boolean

Arraylist自己写的对象遍历费劲，可以重写他的tostring方法，使其遍历。

假如你查询结束后，需要返回集合，可以在方法中新建一个集合，把其添加进去，最后返回ArrayList<phone> ,限制泛型

终止循环，除了使用return，还可以标号 loop ；给循环起名字，想跳哪里跳哪里。System.exit(0);也可以。

Day12

学生管理系统升级版（项目经验）

做项目，第一步，需求分析，首先把项目核心展示页面画出来，将其分为几个大模块。

实现第一步的大模块之后，分析大模块之间的先后逻辑关系，在去按照顺序填充每个小的。

验证用户名时候，先验证格式是否正确，在验证是否存在。因为以后的数据都是存在数据库里。

Day13

1.static关键字

1.1 概述

static 关键字的使用，它可以用来修饰成员变量和成员方法，被static修饰的成员是属于类的是放在静态区中，没有static修饰的成员变量和方法则是属于对象的。

1.2 定义格式和使用

static是静态的意思。 static可以修饰成员变量或者修饰方法。

1.2.1静态变量及其访问

定义格式

修饰符 static 数据类型 变量名 = 初始值；    

静态成员变量的访问:

格式：类名.静态变量

1.2.2 静态方法及其访问

多用在测试类和工具类中。

类名.方法名称即可访问。

public class Student{
public static void study(){
        System.out.println("我们都在黑马程序员学习");   
    }
}

静态成员变量的访问:

格式：类名.静态方法

public static void  main(String[] args){
    Student.study();
}

1.2.3 小结

static修饰的成员属于类，会存储在静态区，是随着类的加载而加载的，且只加载一次，所以只有一份，节省内存。存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。它优先于对象存在，所以，可以被所有对象共享。

静态方法中没有this关键字

普通的成员方法有一个隐含的this，在形参的最前面。静态方法中不存在this关键字

静态方法只能访问静态变量和静态方法

静态方法没有this，所以也不能访问对象的变量和方法，访问对象本质是this.变量名

非静态方法可以访问静态变量或静态方法，也可以访问非静态的成员变量和非静态的成员方法

调用静态可以用类也可以用对象，因此，在非静态方法，他代表一个对象，可以用其调用。this.静态方法名

静态内存

静态和非静态加载进内存的时机不同，静态随着类的启动而加载，而非静态的生命周期随着对象的生命周期，创建存在，没有在指向对象的调用则消亡。

栈：加载要运行的方法

堆：new出来的 静态区：存放静态的变量和方法

方法区：加载class字节码文件，方法区有类底下的方法的临时区，存储方法的临时内容（变量，方法）。

1.3 三种类的总结

JavaBean类

用来描述一类事物的类。

测试类

检查其他类是否正确的，带有main方法，是程序的入口。

工具类

不描述事务，帮助做一些事的类。

1. 类名见名知意

2. 构造方法私有，创建他无意义

3. 方法全部定义为static

2.继承

2.1 概述

假如多个类中存在相同属性和行为时，我们可以将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可.

继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

好处：

1. 提高代码的复用性（减少代码冗余，相同代码重复利用）。

2. 使类与类之间产生了关系。

2.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
    ...
}
​
class 子类 extends 父类 {
    ...
}

需要注意：Java是单继承的，一个类只能继承一个直接父类，跟现实世界很像，但是Java中的子类是更加强大的。

只能单继承，万物继承object，只能继承非私有的属性和方法。

2.4 子类不能继承的内容

构造方法 非私有 不能 private 不能

（假如能继承子类名和父类构造方法名冲突，不满足构造方法的定义）

成员变量 非私有 能 private 能

（均能继承，但是私有的无法访问）

成员方法 非私有 能 private 不能

子类不能继承父类的构造方法。

值得注意的是子类可以继承父类的私有成员（成员变量，方法），只是子类无法直接访问而已，可以通过getter/setter方法访问父类的private成员变量。

有无继承创建对象时内存的不一样之处，无继承时加载字节码进方法区，只加载自己的，有继承的，除了加载自己的字节码，还要加载父类的字节码文件。

还有一个不同，在加载对象时堆空间有一部分是存储父类的成员变量，一部分是存储自己的成员变量 。

2.5 继承后的特点—成员变量

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。

子父类中出现了同名的成员变量时，先访问局部变量，在然后子类会优先访问自己对象中的成员变量。想访问父类成员变量可以使用super关键字。访问本类用this。

2.6 继承后的特点—成员方法

当发生继承时，要调用方法时，并不是一级级的在父类中去查找方法是否存在，而是当子类继承父类时，父类会维护一个虚方法表，将他的方法中非private，static，final修饰的方法全部添加到虚方法表中，把表传递给子类，一层层的传递。

子父类方法同名时，如果方法不能满足子类，子类可以重写，加上@override，本质是在虚方法表中把其替换了。

重写：子类重写父类方法时，方法名称，形参列表必须与父类中的一致，访问权限修饰符必须大于等于子类，返回值类型，必须小于等于父类，私有方法不能重写，不能重写静态方法，只能重写加载到虚方法表中的方法。

2.7 继承后的特点—构造方法

父类中的构造方法不会被子类继承。但是可以通过super调用。

子类中所有的构造方法默认先访问父类中的无参构造，再执行自己（子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据，子类初始化前，一定要先调 用父类构造方法先完成父类数据空间的初始化）

子类构造方法的第一行语句默认都是super(),不写也存在，如果想调用父类有参构造，必须手动写super进行调用。

当自动生成构造方法时，要设置上他的super（传参）设置其中的值

关键字	访问成员变量	访问成员方法	访问构造方法
this	this.成员变量	this.成员方法	this（...）
super	super.成员变量	super.成员方法	super（...）

2.8 this和super总结

this：理解为一个变量，表示当前方法调用者的地址

super：代表父类存储空间

Day14

1.多态

1.1多态的概念

同类型的对象，表现出的不同形式

好处：使用父类型作为参数，可以接收所有的子类对象，体现多态的扩展性与便利

1.2多态的形式

父类类型 对象名称 = 子类对象；

1.3多态的使用

1. 前提

   • 有继承/实现关系

   • 有父类引用指向子类对象 Fu f = new zi();

   • 有方法重写

2. 多态调用成员的特点

   • 变量调用：编译看左边，运行也看左边

     Animal a = new dog（）； 用a去调用name，子类会继承父类的属性，所以调用时显示的是父类的属性

   • 方法调用：编译看左边，运行看右边

     Animal a = new dog（）；用a去调用show()方法，因为子类继承时已经在虚方法表里边重写覆盖了父类的方法，所以显示子类

1.4多态的优劣

1. 优势

   • 在多态形势下，右边对象可以实现解耦合，便于拓展和维护

     Person p = new Student(); p.work(); // 业务逻辑发生变化时，后续代码无需修改

   • 定义方法时，使用父类型作为参数，可以接收所以的子类型对象

2.劣势

• 声名的对象不能调用子类特有方法 Person p = new Student()； p.study();不存在

  解决办法，将其再变为子类类型，大转小，需要强制转化 Student s = （Student）p

  如果写了很多个继承类，可以用instanceof 判断对象属于那个子类对象，是哪个就调用那个的转化方法

  if(a instanceof Dog){
      Dog d = (Dog) a;
      d.lookhome();
  }
  //jdk14后
  if(a instanceof Dog d){
      d.lookhome();
  }

• 自动类型转化（小转大）Person p = new Student（）；

  • 强制类型转化 Student s = （Student）p；

2.包

文件夹，用来管理各种不同功能的Java类

com.itheima.domain.Student 全类名，全限定名

导包：

同一个包中的类，lang不需要导包

同时使用两个包中的同名类，需要使用全类名

3.final

3.1 方法

表明方法是最终方法，不能被重写

（方法是规则，不允许被修改）

3.2 类

表明该类是最终类，不能被继承

3.3 变量

叫做常量，只能被赋值一次

基本类型：值不能变

引用类型：地址值不能变，内部属性值可以变

4.权限修饰符

4.1概念

控制一个成员能够被访问的范围

可以修饰的有，成员变量，方法，构造方法，内部类

4.2分类

访问修饰符

	本类	本包其他类	其他包子类	其他包
public（公有的）	√	√	√	√
protected（保护的）	√	√	√
默认的	√	√
private（私有的）	√

如果方法中的代码是抽取其他方法中共性代码，这个方法一般也私有。

5.代码块

5.1局部代码块

写在方法里边的代码块（节约内存）当执行结束时候，变量从内存中消失

5.2构造代码块（会被多次执行）

写在成员位置的代码块

优先于构造方法执行

将构造方法里重复的部分，抽取到构造代码块中

现在已经不怎么使用了，我们可以把要重复的代码，在构造方法中用this调用，传值的时候，把其他的值传为空或者0

5.3静态代码块（只执行一次）

static{}

需要使用static关键字修饰，随着类的加载而加载，自动触发，执行一次

在类加载时候，做一些数据初始化的时候，只想让他执行一次，使用（优先级最高）

Day15

1.抽象类

1.1概念

抽取共性，不确定的方法体是抽象

1.2定义格式

抽象类：类上用abstract修饰

抽象方法：方法上用abstract修饰，没有方法体

1.3注意事项

不能实例化

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象方法

可以有构造方法：作用，创建子类对象时为其属性赋值

抽象类的子类：要么重写抽象方法，要么创建抽象子类

1.4意义

共性的东西，抽象到父类，不确定的方法体定义为抽象，便于统一，强制子类按照某种方法书写

2.接口

对行为的抽象，是一种规则，限制写法，谁要写这个，就必须按照这个形式来写

抽象类表示一类事务（对象），接口表示一种行为行为（方法）

2.1定义

public interface 接口名{}

2.2实现

public class 类名 implements 接口类{}

接口的子类：要么重写抽象方法，要么创建抽象子类

2.3接口中成员的特点

• 成员变量

  只能是常量，默认修饰符：public static final

• 构造方法

  没有

• 成员方法

  jdk7以前，只能定义抽象方法，jdk8，9.定义有方法体的方法（默认，静态）。定义私有方法

  public abstract 默认修饰符

2.4接口和类的关系

• 类和类：只能单继承，不能多继承，可以多层继承

• 类和接口：实现关系，可以单实现或者多实现，还可以继承的同时实现多个接口

  实现多个接口，要重新里边的所以方法，当有重名的时候，只写一次，相当于两个都实现了

• 接口和接口的关系：可以单继承，也可以多继承

2.5注意细节

• jdk7以前：接口中只能定义抽象方法。

• jdk8以后接口中新增有方法体的方法（默认静态）

  允许定义默认方法，需要用default修饰

  • 作用：解决接口升级问题

  • 默认方法的定义格式： public default 返回值类型 方法名（参数列表）{}

  • 注意事项：默认方法不是抽象方法，不强制重写，如果被重写，重写时候去掉default关键字；

  • 实现了多个接口，多个接口存在相同名字的默认方法，子类必须对方法重写

• jdk9接口中可以定义私有方法

• 私有方法分为两种，普通私有（针对普通方法），静态私有（针对静态方法）

2.6接口的应用

• 让某个类拥有某种行为规则

• 作为参数传递，传入所有实现接口的类的对象（接口多态） 接口类型 j = new 实现类对象（）；

2.7适配器设计模式

当一个接口中抽象类太多时，写一个中间的抽象类xxxAdapter，空实现所有的抽象方法，再写一个真正的实现类实现中间抽象类xxxAdapter的特定抽象方法，简化代码阅读。

内存分析工具的使用

1.首先，idea以管理员身份运行，创建一个scanner 让其一直运行，控制台写jps，得到运行Java进程的id

3.内部类

3.1 类的五大成员

属性，方法，构造方法，代码块，内部类

一个类内部定义的类，属于外部类的一部分，但是单独存在无意义。比如：汽车的发动机，Arraylist的迭代器

3.2访问特点

内部类可以直接访问外部类的成员，包括私有

外部类要访问内部类的成员，必须创建对象 内部类名 对象名 = new 内部类名（）；

3.3内部类的分类

• 成员内部类（写在成员位置的）

• 静态内部类 类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)

• 局部内部类 类定义在方法内

• 匿名内部类 没有名字的内部类，可以在方法中，也可以在类中方法外。

4.成员内部类

成员内部类特点：

• 无static修饰的内部类，属于外部类对象的。

• 宿主：外部类对象。

内部类的使用格式：

 外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类

获取成员内部类对象的两种方式：

方式一：外部直接创建成员内部类的对象

外部类.内部类 变量 = new 外部类（）.new 内部类（）;

方式二：在外部类中定义一个方法提供内部类的对象

案例演示

方式一：
public class Test {
    public static void main(String[] args) {
        //  宿主：外部类对象。
       // Outer out = new Outer();
        // 创建内部类对象。
        Outer.Inner oi = new Outer().new Inner();
        oi.method();
    }
}
​
class Outer {
    // 成员内部类，属于外部类对象的。
    // 拓展：成员内部类不能定义静态成员。
    public class Inner{
        // 这里面的东西与类是完全一样的。
        public void method(){
            System.out.println("内部类中的方法被调用了");
        }
    }
}
​
​
方式二：
public class Outer {
    String name;
    private class Inner{
        static int a = 10;
    }
    public Inner getInstance(){
        return new Inner();
    }
}
​
public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        
        System.out.println(o.getInstance());//返回的是一个内部类对象，打印输出的是他的地址值
​
​
    }
}

4.2 成员内部类的细节

1. 成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等

2. 在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。

3. 创建内部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值。（请参见3.6节的内存图）

详解：

内部类被private修饰，外界无法直接获取内部类的对象，只能通过3.3节中的方式二获取内部类的对象

被其他权限修饰符修饰的内部类一般用3.3节中的方式一直接获取内部类的对象

内部类被static修饰是成员内部类中的特殊情况，叫做静态内部类下面单独学习。

内部类如果想要访问外部类的成员变量，外部类的变量必须用final修饰，JDK8以前必须手动写final，JDK8之后不需要手动写，JDK默认加上。

5.静态内部类

5.1定义

特殊的成员内部类。加static修饰。

5.2创建静态内部类对象

Outer.Inner oi = new Outer.Inner();

5.3调用静态内部类中的方法

非静态方法：先创建对象，用对象调用

静态方法：外部类名.内部类名.方法名（）；

6.局部内部类

1. 将内部类定义在方法中就叫做局部内部类，类似于方法中的局部变量。

2. 外界是无法直接使用，需要在方法内部创建对象并使用。

3. 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

7.匿名内部类

7.1定义和格式

隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置。

new 类名或者接口名（）{

重写方法；

}；

1. 继承/实现

2. 方法的重写

3. 创建对象

7.2使用场景

实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用是为了简化代码。

7.3 匿名内部类前提和格式

匿名内部类必须继承一个父类或者实现一个父接口。

匿名内部类格式

new 父类名或者接口名(){ // 方法重写 @Override public void method() { // 执行语句 } };

7.4 使用方式

以接口为例，匿名内部类的使用，代码如下：

interface Swim {
    public abstract void swimming();
}
​
public class Demo07 {
    public static void main(String[] args) {
        // 使用匿名内部类
        new Swim() {
            @Override
            public void swimming() {
                System.out.println("自由泳...");
            }
        }.swimming();
​
        // 接口 变量 = new 实现类(); // 多态,走子类的重写方法
        Swim s2 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蛙泳...");
            }
        };
​
        s2.swimming();
        s2.swimming();
    }
}

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

interface Swim {
    public abstract void swimming();
}
​
public class Demo07 {
    public static void main(String[] args) {
        // 普通方式传入对象
        // 创建实现类对象
        Student s = new Student();
        
        goSwimming(s);
        // 匿名内部类使用场景:作为方法参数传递
        Swim s3 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蝶泳...");
            }
        };
        // 传入匿名内部类
        goSwimming(s3);
​
        // 完美方案: 一步到位
        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("大学生, 蛙泳...");
            }
        });
​
        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("小学生, 自由泳...");
            }
        });
    }
​
    // 定义一个方法,模拟请一些人去游泳
    public static void goSwimming(Swim s) {
        s.swimming();
    }
}

Day17

常用的API

Math

数学工具类，里边的方法都是那个静态的

常用方法：

我们要学习的Math的常见方法如下所示：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">int</span> <span style="color:#0000ff">abs</span>(<span style="color:#008855">int</span> <span style="color:#000000">a</span>)    <span style="color:#000000">absEXact</span>                <span style="color:#aa5500">// 返回参数的绝对值</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">double</span> <span style="color:#0000ff">ceil</span>(<span style="color:#008855">double</span> <span style="color:#000000">a</span>)             <span style="color:#aa5500">// 返回大于或等于参数的最小整数</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">double</span> <span style="color:#0000ff">floor</span>(<span style="color:#008855">double</span> <span style="color:#000000">a</span>)            <span style="color:#aa5500">// 返回小于或等于参数的最大整数</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">int</span> <span style="color:#0000ff">round</span>(<span style="color:#770088">float</span> <span style="color:#000000">a</span>)                <span style="color:#aa5500">// 按照四舍五入返回最接近参数的int类型的值</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">int</span> <span style="color:#0000ff">max</span>(<span style="color:#008855">int</span> <span style="color:#000000">a</span>,<span style="color:#008855">int</span> <span style="color:#000000">b</span>)              <span style="color:#aa5500">// 获取两个int值中的较大值</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">int</span> <span style="color:#0000ff">min</span>(<span style="color:#008855">int</span> <span style="color:#000000">a</span>,<span style="color:#008855">int</span> <span style="color:#000000">b</span>)              <span style="color:#aa5500">// 获取两个int值中的较小值</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">double</span> <span style="color:#0000ff">pow</span> (<span style="color:#008855">double</span> <span style="color:#000000">a</span>,<span style="color:#008855">double</span> <span style="color:#000000">b</span>)    <span style="color:#aa5500">// 计算a的b次幂的值</span>
    <span style="color:#000000">sqrt（开平方根）</span> <span style="color:#000000">cbrt（开立方根）</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">double</span> <span style="color:#0000ff">random</span>()                   <span style="color:#aa5500">// 返回一个[0.0,1.0)的随机值</span>
​</span></span>

System

我们要学习的System类中的常见方法如下所示：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">long</span> <span style="color:#0000ff">currentTimeMillis</span>()          <span style="color:#aa5500">// 获取当前时间所对应的毫秒值（当前时间为0时区所对应的时间即就是英国格林尼治天文台旧址所在位置）</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">void</span> <span style="color:#0000ff">exit</span>(<span style="color:#008855">int</span> <span style="color:#000000">status</span>)             <span style="color:#aa5500">// 终止当前正在运行的Java虚拟机，0表示正常退出，非零表示异常退出</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#770088">native</span> <span style="color:#008855">void</span> <span style="color:#0000ff">arraycopy</span>(<span style="color:#008855">Object</span> <span style="color:#000000">src</span>,  <span style="color:#008855">int</span>  <span style="color:#000000">srcPos</span>, <span style="color:#008855">Object</span> <span style="color:#000000">dest</span>, <span style="color:#008855">int</span> <span style="color:#000000">destPos</span>, <span style="color:#008855">int</span> <span style="color:#000000">length</span>); <span style="color:#aa5500">// 进行数值元素copy</span></span></span>

Runtime

我们要学习的Object类中的常见方法如下所示：

<span style="background-color:#f8f8f8"><span style="color:#333333">public static Runtime getRuntime()		//当前系统的运行环境对象
public void exit(int status)			//停止虚拟机
public int availableProcessors()		//获得CPU的线程数
public long maxMemory()				    //JVM能从系统中获取总内存大小（单位byte）
public long totalMemory()				//JVM已经从系统中获取总内存大小（单位byte）
public long freeMemory()				//JVM剩余内存大小（单位byte）
public Process exec(String command) 	//运行cmd命令
</span></span>

代码示例：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#770088">class</span> <span style="color:#0000ff">RunTimeDemo1</span> {
    <span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">void</span> <span style="color:#000000">main</span>(<span style="color:#008855">String</span>[] <span style="color:#000000">args</span>) <span style="color:#770088">throws</span> <span style="color:#000000">IOException</span> {
        <span style="color:#aa5500">/*</span>
            <span style="color:#aa5500">public static Runtime getRuntime() 当前系统的运行环境对象</span>
            <span style="color:#aa5500">public void exit(int status) 停止虚拟机</span>
            <span style="color:#aa5500">public int availableProcessors() 获得CPU的线程数</span>
            <span style="color:#aa5500">public long maxMemory() JVM能从系统中获取总内存大小(单位byte)</span>
            <span style="color:#aa5500">public long totalMemory() JVM已经从系统中获取总内存大小(单位byte)</span>
            <span style="color:#aa5500">public long freeMemory() JVM剩余内存大小(单位byte)</span>
            <span style="color:#aa5500">public Process exec(string command) 运行cmd命令</span>
        <span style="color:#aa5500">*/</span>
​
        <span style="color:#aa5500">//1.获取Runtime的对象</span>
        <span style="color:#aa5500">//Runtime r1 =Runtime.getRuntime();</span>
​
        <span style="color:#aa5500">//2.exit 停止虚拟机</span>
        <span style="color:#aa5500">//Runtime.getRuntime().exit(0);</span>
        <span style="color:#aa5500">//System.out.println("看看我执行了吗?");</span>
​
​
        <span style="color:#aa5500">//3.获得CPU的线程数</span>
        <span style="color:#000000">System</span>.<span style="color:#000000">out</span>.<span style="color:#000000">println</span>(<span style="color:#000000">Runtime</span>.<span style="color:#000000">getRuntime</span>().<span style="color:#000000">availableProcessors</span>());<span style="color:#aa5500">//8</span>
        <span style="color:#aa5500">//4.总内存大小,单位byte字节</span>
        <span style="color:#000000">System</span>.<span style="color:#000000">out</span>.<span style="color:#000000">println</span>(<span style="color:#000000">Runtime</span>.<span style="color:#000000">getRuntime</span>().<span style="color:#000000">maxMemory</span>() <span style="color:#981a1a">/</span> <span style="color:#116644">1024</span> <span style="color:#981a1a">/</span> <span style="color:#116644">1024</span>);<span style="color:#aa5500">//4064</span>
        <span style="color:#aa5500">//5.已经获取的总内存大小,单位byte字节</span>
        <span style="color:#000000">System</span>.<span style="color:#000000">out</span>.<span style="color:#000000">println</span>(<span style="color:#000000">Runtime</span>.<span style="color:#000000">getRuntime</span>().<span style="color:#000000">totalMemory</span>() <span style="color:#981a1a">/</span> <span style="color:#116644">1024</span> <span style="color:#981a1a">/</span> <span style="color:#116644">1024</span>);<span style="color:#aa5500">//254</span>
        <span style="color:#aa5500">//6.剩余内存大小</span>
        <span style="color:#000000">System</span>.<span style="color:#000000">out</span>.<span style="color:#000000">println</span>(<span style="color:#000000">Runtime</span>.<span style="color:#000000">getRuntime</span>().<span style="color:#000000">freeMemory</span>() <span style="color:#981a1a">/</span> <span style="color:#116644">1024</span> <span style="color:#981a1a">/</span> <span style="color:#116644">1024</span>);<span style="color:#aa5500">//251</span>
​
        <span style="color:#aa5500">//7.运行cmd命令</span>
        <span style="color:#aa5500">//shutdown :关机</span>
        <span style="color:#aa5500">//加上参数才能执行</span>
        <span style="color:#aa5500">//-s :默认在1分钟之后关机</span>
        <span style="color:#aa5500">//-s -t 指定时间 : 指定关机时间</span>
        <span style="color:#aa5500">//-a :取消关机操作</span>
        <span style="color:#aa5500">//-r: 关机并重启</span>
        <span style="color:#000000">Runtime</span>.<span style="color:#000000">getRuntime</span>().<span style="color:#000000">exec</span>(<span style="color:#aa1111">"shutdown -s -t 3600"</span>);
​
​
    }
}</span></span>

Object

我们要学习的Object类中的常见方法如下所示：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#008855">String</span> <span style="color:#0000ff">toString</span>()                <span style="color:#aa5500">//返回该对象的字符串表示形式(可以看做是对象的内存地址值)</span>
<span style="color:#770088">public</span> <span style="color:#008855">boolean</span> <span style="color:#0000ff">equals</span>(<span style="color:#008855">Object</span> <span style="color:#000000">obj</span>)       <span style="color:#aa5500">//比较两个对象地址值是否相等；true表示相同，false表示不相同</span>
<span style="color:#770088">protected</span> <span style="color:#008855">Object</span> <span style="color:#0000ff">clone</span>()                <span style="color:#aa5500">//对象克隆</span></span></span>

1.toString

Object类中toString方法的源码，如下所示：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#008855">String</span> <span style="color:#0000ff">toString</span>() {      <span style="color:#aa5500">// Object类中toString方法的源码定义</span>
    <span style="color:#770088">return</span> <span style="color:#000000">getClass</span>().<span style="color:#000000">getName</span>() <span style="color:#981a1a">+</span> <span style="color:#aa1111">"@"</span> <span style="color:#981a1a">+</span> <span style="color:#008855">Integer</span>.<span style="color:#000000">toHexString</span>(<span style="color:#000000">hashCode</span>());
}
​</span></span>

其中getClass().getName()对应的结果就是：com.itheima.api.system.demo04.Student；Integer.toHexString(hashCode())对应的结果就是3f3afe78。

小结：

1. 在通过输出语句输出一个对象时，默认调用的就是toString()方法

2. 输出地址值一般没有意义，我们可以通过重写toString方法去输出对应的成员变量信息（快捷键：atl + insert ， 空白处 右键 -> Generate -> 选择toString）

3. toString方法的作用：以良好的格式，更方便的展示对象中的属性值

4. 一般情况下Jdk所提供的类都会重写Object类中的toString方法

2.equals

代码如下所示：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#770088">class</span> <span style="color:#0000ff">ObjectDemo02</span> {
​
    <span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">void</span> <span style="color:#000000">main</span>(<span style="color:#008855">String</span>[] <span style="color:#000000">args</span>) {
​
        <span style="color:#aa5500">// 创建两个学生对象</span>
        <span style="color:#000000">Student</span> <span style="color:#000000">s1</span> <span style="color:#981a1a">=</span> <span style="color:#770088">new</span> <span style="color:#000000">Student</span>(<span style="color:#aa1111">"itheima"</span> , <span style="color:#aa1111">"14"</span>) ;
        <span style="color:#000000">Student</span> <span style="color:#000000">s2</span> <span style="color:#981a1a">=</span> <span style="color:#770088">new</span> <span style="color:#000000">Student</span>(<span style="color:#aa1111">"itheima"</span> , <span style="color:#aa1111">"14"</span>) ;
​
        <span style="color:#aa5500">// 比较两个对象是否相等</span>
        <span style="color:#000000">System</span>.<span style="color:#000000">out</span>.<span style="color:#000000">println</span>(<span style="color:#000000">s1</span> <span style="color:#981a1a">==</span> <span style="color:#000000">s2</span>);
​
    }
​
}</span></span>

运行程序进行测试，控制台的输出结果如下所示：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#221199">false</span></span></span>

因为"=="号比较的是对象的地址值，而我们通过new关键字创建了两个对象，它们的地址值是不相同的。因此比较结果就是false。

查看一下Object类中equals方法的源码，如下所示：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#008855">boolean</span> <span style="color:#0000ff">equals</span>(<span style="color:#008855">Object</span> <span style="color:#000000">obj</span>) {     <span style="color:#aa5500">// Object类中的equals方法的源码</span>
    <span style="color:#770088">return</span> (<span style="color:#770088">this</span> <span style="color:#981a1a">==</span> <span style="color:#000000">obj</span>);
}</span></span>

通过源码我们可以发现默认情况下equals方法比较的也是对象的地址值。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；

小结：

1. 默认情况下equals方法比较的是对象的地址值

2. 比较对象的地址值是没有意义的，因此一般情况下我们都会重写Object类中的equals方法

3.clone

把A对象的属性值完全拷贝给B对象，也叫对象拷贝,对象复制

对象克隆的分类：

深克隆和浅克隆

浅克隆：

不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来

基本数据类型拷贝过来的是具体的数据，引用数据类型拷贝过来的是地址值。

Object类默认的是浅克隆

深克隆：

基本数据类型拷贝过来，字符串复用，引用数据类型会重新创建新的

代码实现：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">package</span> <span style="color:#0000ff">com</span>.<span style="color:#000000">itheima</span>.<span style="color:#000000">a04objectdemo</span>;
​
<span style="color:#770088">public</span> <span style="color:#770088">class</span> <span style="color:#0000ff">ObjectDemo4</span> {
    <span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">void</span> <span style="color:#000000">main</span>(<span style="color:#008855">String</span>[] <span style="color:#000000">args</span>) <span style="color:#770088">throws</span> <span style="color:#000000">CloneNotSupportedException</span> {
        <span style="color:#aa5500">// protected object clone(int a) 对象克隆 </span>
​
        <span style="color:#aa5500">//1.先创建一个对象</span>
        <span style="color:#008855">int</span>[] <span style="color:#000000">data</span> <span style="color:#981a1a">=</span> {<span style="color:#116644">1</span>, <span style="color:#116644">2</span>, <span style="color:#116644">3</span>, <span style="color:#116644">4</span>, <span style="color:#116644">5</span>, <span style="color:#116644">6</span>, <span style="color:#116644">7</span>, <span style="color:#116644">8</span>, <span style="color:#116644">9</span>, <span style="color:#116644">10</span>, <span style="color:#116644">11</span>, <span style="color:#116644">12</span>, <span style="color:#116644">13</span>, <span style="color:#116644">14</span>, <span style="color:#116644">15</span>, <span style="color:#116644">0</span>};
        <span style="color:#000000">User</span> <span style="color:#000000">u1</span> <span style="color:#981a1a">=</span> <span style="color:#770088">new</span> <span style="color:#000000">User</span>(<span style="color:#116644">1</span>, <span style="color:#aa1111">"zhangsan"</span>, <span style="color:#aa1111">"1234qwer"</span>, <span style="color:#aa1111">"girl11"</span>, <span style="color:#000000">data</span>);
​
        <span style="color:#aa5500">//2.克隆对象</span>
        <span style="color:#aa5500">//细节:</span>
        <span style="color:#aa5500">//方法在底层会帮我们创建一个对象,并把原对象中的数据拷贝过去。</span>
        <span style="color:#aa5500">//书写细节:</span>
        <span style="color:#aa5500">//1.重写Object中的clone方法</span>
        <span style="color:#aa5500">//2.让javabean类实现Cloneable接口</span>
        <span style="color:#aa5500">//3.创建原对象并调用clone就可以了</span>
        <span style="color:#aa5500">//User u2 =(User)u1.clone();</span>
​
        <span style="color:#aa5500">//验证一件事情：Object中的克隆是浅克隆</span>
        <span style="color:#aa5500">//想要进行深克隆，就需要重写clone方法并修改里面的方法体</span>
        <span style="color:#aa5500">//int[] arr = u1.getData();</span>
        <span style="color:#aa5500">//arr[0] = 100;</span>
​
        <span style="color:#aa5500">//System.out.println(u1);</span>
        <span style="color:#aa5500">//System.out.println(u2);</span>
​
​
        <span style="color:#aa5500">//以后一般会用第三方工具进行克隆</span>
        <span style="color:#aa5500">//1.第三方写的代码导入到项目中</span>
        <span style="color:#aa5500">//2.编写代码</span>
        <span style="color:#aa5500">//Gson gson =new Gson();</span>
        <span style="color:#aa5500">//把对象变成一个字符串</span>
        <span style="color:#aa5500">//String s=gson.toJson(u1);</span>
        <span style="color:#aa5500">//再把字符串变回对象就可以了</span>
        <span style="color:#aa5500">//User user =gson.fromJson(s, User.class);</span>
​
        <span style="color:#aa5500">//int[] arr=u1.getData();</span>
        <span style="color:#aa5500">//arr[0] = 100;</span>
​
        <span style="color:#aa5500">//打印对象</span>
        <span style="color:#aa5500">//System.out.println(user);</span>
​
    }
}
​
<span style="color:#770088">package</span> <span style="color:#0000ff">com</span>.<span style="color:#000000">itheima</span>.<span style="color:#000000">a04objectdemo</span>;
​
<span style="color:#770088">import</span> <span style="color:#000000">java</span>.<span style="color:#000000">util</span>.<span style="color:#000000">StringJoiner</span>;
​
​
​
<span style="color:#aa5500">//Cloneable</span>
<span style="color:#aa5500">//如果一个接口里面没有抽象方法</span>
<span style="color:#aa5500">//表示当前的接口是一个标记性接口</span>
<span style="color:#aa5500">//现在Cloneable表示一旦实现了，那么当前类的对象就可以被克降</span>
<span style="color:#aa5500">//如果没有实现，当前类的对象就不能克隆</span>
<span style="color:#770088">public</span> <span style="color:#770088">class</span> <span style="color:#0000ff">User</span> <span style="color:#770088">implements</span> <span style="color:#000000">Cloneable</span> {
    <span style="color:#770088">private</span> <span style="color:#008855">int</span> <span style="color:#000000">id</span>;
    <span style="color:#770088">private</span> <span style="color:#008855">String</span> <span style="color:#000000">username</span>;
    <span style="color:#770088">private</span> <span style="color:#008855">String</span> <span style="color:#000000">password</span>;
    <span style="color:#770088">private</span> <span style="color:#008855">String</span> <span style="color:#000000">path</span>;
    <span style="color:#770088">private</span> <span style="color:#008855">int</span>[] <span style="color:#000000">data</span>;
​
​
​
​
    <span style="color:#770088">public</span> <span style="color:#000000">User</span>() {
    }
​
    <span style="color:#770088">public</span> <span style="color:#000000">User</span>(<span style="color:#008855">int</span> <span style="color:#000000">id</span>, <span style="color:#008855">String</span> <span style="color:#000000">username</span>, <span style="color:#008855">String</span> <span style="color:#000000">password</span>, <span style="color:#008855">String</span> <span style="color:#000000">path</span>, <span style="color:#008855">int</span>[] <span style="color:#000000">data</span>) {
        <span style="color:#770088">this</span>.<span style="color:#000000">id</span> <span style="color:#981a1a">=</span> <span style="color:#000000">id</span>;
        <span style="color:#770088">this</span>.<span style="color:#000000">username</span> <span style="color:#981a1a">=</span> <span style="color:#000000">username</span>;
        <span style="color:#770088">this</span>.<span style="color:#000000">password</span> <span style="color:#981a1a">=</span> <span style="color:#000000">password</span>;
        <span style="color:#770088">this</span>.<span style="color:#000000">path</span> <span style="color:#981a1a">=</span> <span style="color:#000000">path</span>;
        <span style="color:#770088">this</span>.<span style="color:#000000">data</span> <span style="color:#981a1a">=</span> <span style="color:#000000">data</span>;
    }
​
    <span style="color:#aa5500">/**</span>
     <span style="color:#aa5500">* 获取</span>
     <span style="color:#aa5500">*</span>
     <span style="color:#aa5500">* @return id</span>
     <span style="color:#aa5500">*/</span>
    <span style="color:#770088">public</span> <span style="color:#008855">int</span> <span style="color:#000000">getId</span>() {
        <span style="color:#770088">return</span> <span style="color:#000000">id</span>;
    }
​
    <span style="color:#aa5500">/**</span>
     <span style="color:#aa5500">* 设置</span>
     <span style="color:#aa5500">*</span>
     <span style="color:#aa5500">* @param id</span>
     <span style="color:#aa5500">*/</span>
    <span style="color:#770088">public</span> <span style="color:#008855">void</span> <span style="color:#000000">setId</span>(<span style="color:#008855">int</span> <span style="color:#000000">id</span>) {
        <span style="color:#770088">this</span>.<span style="color:#000000">id</span> <span style="color:#981a1a">=</span> <span style="color:#000000">id</span>;
    }
​
    <span style="color:#aa5500">/**</span>
     <span style="color:#aa5500">* 获取</span>
     <span style="color:#aa5500">*</span>
     <span style="color:#aa5500">* @return username</span>
     <span style="color:#aa5500">*/</span>
    <span style="color:#770088">public</span> <span style="color:#008855">String</span> <span style="color:#000000">getUsername</span>() {
        <span style="color:#770088">return</span> <span style="color:#000000">username</span>;
    }
​
    <span style="color:#aa5500">/**</span>
     <span style="color:#aa5500">* 设置</span>
     <span style="color:#aa5500">*</span>
     <span style="color:#aa5500">* @param username</span>
     <span style="color:#aa5500">*/</span>
    <span style="color:#770088">public</span> <span style="color:#008855">void</span> <span style="color:#000000">setUsername</span>(<span style="color:#008855">String</span> <span style="color:#000000">username</span>) {
        <span style="color:#770088">this</span>.<span style="color:#000000">username</span> <span style="color:#981a1a">=</span> <span style="color:#000000">username</span>;
    }
​
    <span style="color:#aa5500">/**</span>
     <span style="color:#aa5500">* 获取</span>
     <span style="color:#aa5500">*</span>
     <span style="color:#aa5500">* @return password</span>
     <span style="color:#aa5500">*/</span>
    <span style="color:#770088">public</span> <span style="color:#008855">String</span> <span style="color:#000000">getPassword</span>() {
        <span style="color:#770088">return</span> <span style="color:#000000">password</span>;
    }
​
    <span style="color:#aa5500">/**</span>
     <span style="color:#aa5500">* 设置</span>
     <span style="color:#aa5500">*</span>
     <span style="color:#aa5500">* @param password</span>
     <span style="color:#aa5500">*/</span>
    <span style="color:#770088">public</span> <span style="color:#008855">void</span> <span style="color:#000000">setPassword</span>(<span style="color:#008855">String</span> <span style="color:#000000">password</span>) {
        <span style="color:#770088">this</span>.<span style="color:#000000">password</span> <span style="color:#981a1a">=</span> <span style="color:#000000">password</span>;
    }
​
    <span style="color:#aa5500">/**</span>
     <span style="color:#aa5500">* 获取</span>
     <span style="color:#aa5500">*</span>
     <span style="color:#aa5500">* @return path</span>
     <span style="color:#aa5500">*/</span>
    <span style="color:#770088">public</span> <span style="color:#008855">String</span> <span style="color:#000000">getPath</span>() {
        <span style="color:#770088">return</span> <span style="color:#000000">path</span>;
    }
​
    <span style="color:#aa5500">/**</span>
     <span style="color:#aa5500">* 设置</span>
     <span style="color:#aa5500">*</span>
     <span style="color:#aa5500">* @param path</span>
     <span style="color:#aa5500">*/</span>
    <span style="color:#770088">public</span> <span style="color:#008855">void</span> <span style="color:#000000">setPath</span>(<span style="color:#008855">String</span> <span style="color:#000000">path</span>) {
        <span style="color:#770088">this</span>.<span style="color:#000000">path</span> <span style="color:#981a1a">=</span> <span style="color:#000000">path</span>;
    }
​
    <span style="color:#aa5500">/**</span>
     <span style="color:#aa5500">* 获取</span>
     <span style="color:#aa5500">*</span>
     <span style="color:#aa5500">* @return data</span>
     <span style="color:#aa5500">*/</span>
    <span style="color:#770088">public</span> <span style="color:#008855">int</span>[] <span style="color:#000000">getData</span>() {
        <span style="color:#770088">return</span> <span style="color:#000000">data</span>;
    }
​
    <span style="color:#aa5500">/**</span>
     <span style="color:#aa5500">* 设置</span>
     <span style="color:#aa5500">*</span>
     <span style="color:#aa5500">* @param data</span>
     <span style="color:#aa5500">*/</span>
    <span style="color:#770088">public</span> <span style="color:#008855">void</span> <span style="color:#000000">setData</span>(<span style="color:#008855">int</span>[] <span style="color:#000000">data</span>) {
        <span style="color:#770088">this</span>.<span style="color:#000000">data</span> <span style="color:#981a1a">=</span> <span style="color:#000000">data</span>;
    }
​
    <span style="color:#770088">public</span> <span style="color:#008855">String</span> <span style="color:#000000">toString</span>() {
        <span style="color:#770088">return</span> <span style="color:#aa1111">"角色编号为："</span> <span style="color:#981a1a">+</span> <span style="color:#000000">id</span> <span style="color:#981a1a">+</span> <span style="color:#aa1111">"，用户名为："</span> <span style="color:#981a1a">+</span> <span style="color:#000000">username</span> <span style="color:#981a1a">+</span> <span style="color:#aa1111">"密码为："</span> <span style="color:#981a1a">+</span> <span style="color:#000000">password</span> <span style="color:#981a1a">+</span> <span style="color:#aa1111">", 游戏图片为:"</span> <span style="color:#981a1a">+</span> <span style="color:#000000">path</span> <span style="color:#981a1a">+</span> <span style="color:#aa1111">", 进度:"</span> <span style="color:#981a1a">+</span> <span style="color:#000000">arrToString</span>();
    }
​
​
    <span style="color:#770088">public</span> <span style="color:#008855">String</span> <span style="color:#000000">arrToString</span>() {
        <span style="color:#000000">StringJoiner</span> <span style="color:#000000">sj</span> <span style="color:#981a1a">=</span> <span style="color:#770088">new</span> <span style="color:#000000">StringJoiner</span>(<span style="color:#aa1111">", "</span>, <span style="color:#aa1111">"["</span>, <span style="color:#aa1111">"]"</span>);
​
        <span style="color:#770088">for</span> (<span style="color:#008855">int</span> <span style="color:#000000">i</span> <span style="color:#981a1a">=</span> <span style="color:#116644">0</span>; <span style="color:#000000">i</span> <span style="color:#981a1a"><</span> <span style="color:#000000">data</span>.<span style="color:#000000">length</span>; <span style="color:#000000">i</span><span style="color:#981a1a">++</span>) {
            <span style="color:#000000">sj</span>.<span style="color:#000000">add</span>(<span style="color:#000000">data</span>[<span style="color:#000000">i</span>] <span style="color:#981a1a">+</span> <span style="color:#aa1111">""</span>);
        }
        <span style="color:#770088">return</span> <span style="color:#000000">sj</span>.<span style="color:#000000">toString</span>();
    }
​
    <span style="color:#555555">@Override</span>
    <span style="color:#770088">protected</span> <span style="color:#008855">Object</span> <span style="color:#000000">clone</span>() <span style="color:#770088">throws</span> <span style="color:#000000">CloneNotSupportedException</span> {
        <span style="color:#aa5500">//调用父类中的clone方法</span>
        <span style="color:#aa5500">//相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去。</span>
​
        <span style="color:#aa5500">//先把被克隆对象中的数组获取出来</span>
        <span style="color:#008855">int</span>[] <span style="color:#000000">data</span> <span style="color:#981a1a">=</span> <span style="color:#770088">this</span>.<span style="color:#000000">data</span>;
        <span style="color:#aa5500">//创建新的数组</span>
        <span style="color:#008855">int</span>[] <span style="color:#000000">newData</span> <span style="color:#981a1a">=</span><span style="color:#770088">new</span> <span style="color:#008855">int</span>[<span style="color:#000000">data</span>.<span style="color:#000000">length</span>];
        <span style="color:#aa5500">//拷贝数组中的数据</span>
        <span style="color:#770088">for</span> (<span style="color:#008855">int</span> <span style="color:#000000">i</span> <span style="color:#981a1a">=</span> <span style="color:#116644">0</span>; <span style="color:#000000">i</span> <span style="color:#981a1a"><</span> <span style="color:#000000">data</span>.<span style="color:#000000">length</span>; <span style="color:#000000">i</span><span style="color:#981a1a">++</span>) {
            <span style="color:#000000">newData</span>[<span style="color:#000000">i</span>] <span style="color:#981a1a">=</span> <span style="color:#000000">data</span>[<span style="color:#000000">i</span>];
        }
        <span style="color:#aa5500">//调用父类中的方法克隆对象</span>
            <span style="color:#000000">User</span> <span style="color:#000000">u</span><span style="color:#981a1a">=</span>(<span style="color:#000000">User</span>)<span style="color:#770088">super</span>.<span style="color:#000000">clone</span>();
        <span style="color:#aa5500">//因为父类中的克隆方法是浅克隆，替换克隆出来对象中的数组地址值</span>
        <span style="color:#000000">u</span>.<span style="color:#000000">data</span> <span style="color:#981a1a">=</span><span style="color:#000000">newData</span>;
        <span style="color:#770088">return</span> <span style="color:#000000">u</span>;
    }
}
​</span></span>

Objects

我们要重点学习的Objects类中的常见方法如下所示：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">String</span> <span style="color:#0000ff">toString</span>(<span style="color:#008855">Object</span> <span style="color:#000000">o</span>)                     <span style="color:#aa5500">// 获取对象的字符串表现形式</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">boolean</span> <span style="color:#0000ff">equals</span>(<span style="color:#008855">Object</span> <span style="color:#000000">a</span>, <span style="color:#008855">Object</span> <span style="color:#000000">b</span>)            <span style="color:#aa5500">// 比较两个对象是否相等</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">boolean</span> <span style="color:#0000ff">isNull</span>(<span style="color:#008855">Object</span> <span style="color:#000000">obj</span>)                    <span style="color:#aa5500">// 判断对象是否为null</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#008855">boolean</span> <span style="color:#0000ff">nonNull</span>(<span style="color:#008855">Object</span> <span style="color:#000000">obj</span>)                   <span style="color:#aa5500">// 判断对象是否不为null</span></span></span>

我们要了解的Objects类中的常见方法如下所示：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#981a1a"><</span><span style="color:#000000">T</span><span style="color:#981a1a">></span> <span style="color:#000000">T</span> <span style="color:#0000ff">requireNonNull</span>(<span style="color:#000000">T</span> <span style="color:#000000">obj</span>)   <span style="color:#aa5500">// 检查对象是否不为null,如果为null直接抛出异常；如果不是null返回该对象；</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#981a1a"><</span><span style="color:#000000">T</span><span style="color:#981a1a">></span> <span style="color:#000000">T</span> <span style="color:#0000ff">requireNonNullElse</span>(<span style="color:#000000">T</span> <span style="color:#000000">obj</span>, <span style="color:#000000">T</span> <span style="color:#000000">defaultObj</span>) <span style="color:#aa5500">// 检查对象是否不为null，如果不为null，返回该对象；如果为null返回defaultObj值</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#981a1a"><</span><span style="color:#000000">T</span><span style="color:#981a1a">></span> <span style="color:#000000">T</span> <span style="color:#0000ff">requireNonNullElseGet</span>(<span style="color:#000000">T</span> <span style="color:#000000">obj</span>, <span style="color:#000000">Supplier</span><span style="color:#981a1a"><?</span> <span style="color:#770088">extends</span> <span style="color:#000000">T</span><span style="color:#981a1a">></span> <span style="color:#000000">supplier</span>)    <span style="color:#aa5500">// 检查对象是否不为null，如果不为null，返回该对象；如果                                                            // 为null,返回由Supplier所提供的值</span></span></span>

上述方法中的T可以理解为是Object类型。

BigInteger

构造方法

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#000000">BigInteger</span>(<span style="color:#008855">int</span> <span style="color:#000000">num</span>, <span style="color:#000000">Random</span> <span style="color:#000000">rnd</span>)      <span style="color:#aa5500">//获取随机大整数，范围：[0 ~ 2的num次方-1]</span>
<span style="color:#770088">public</span> <span style="color:#000000">BigInteger</span>(<span style="color:#008855">String</span> <span style="color:#000000">val</span>)               <span style="color:#aa5500">//获取指定的大整数 字符串中的数字必须是整数</span>
<span style="color:#770088">public</span> <span style="color:#000000">BigInteger</span>(<span style="color:#008855">String</span> <span style="color:#000000">val</span>, <span style="color:#008855">int</span> <span style="color:#000000">radix</span>)    <span style="color:#aa5500">//获取指定进制的大整数</span>
    
<span style="color:#000000">下面这个不是构造，而是一个静态方法获取BigInteger对象</span>
<span style="color:#770088">public</span> <span style="color:#770088">static</span> <span style="color:#000000">BigInteger</span> <span style="color:#0000ff">valueOf</span>(<span style="color:#008855">long</span> <span style="color:#000000">val</span>)  <span style="color:#aa5500">//静态方法获取BigInteger的对象，内部有优化 -16 -16之间地址值优化相同</span></span></span>

构造方法小结：

• 如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取。

• 如果BigInteger表示的超出long的范围，可以用构造方法获取。

• 对象一旦创建，BigInteger内部记录的值不能发生改变。

• 只要进行计算都会产生一个新的BigInteger对象

常见成员方法

BigDecimal类中使用最多的还是提供的进行四则运算的方法，如下：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#000000">BigInteger</span> <span style="color:#0000ff">add</span>(<span style="color:#000000">BigInteger</span> <span style="color:#000000">val</span>)                   <span style="color:#aa5500">//加法</span>
<span style="color:#770088">public</span> <span style="color:#000000">BigInteger</span> <span style="color:#0000ff">subtract</span>(<span style="color:#000000">BigInteger</span> <span style="color:#000000">val</span>)              <span style="color:#aa5500">//减法</span>
<span style="color:#770088">public</span> <span style="color:#000000">BigInteger</span> <span style="color:#0000ff">multiply</span>(<span style="color:#000000">BigInteger</span> <span style="color:#000000">val</span>)              <span style="color:#aa5500">//乘法</span>
<span style="color:#770088">public</span> <span style="color:#000000">BigInteger</span> <span style="color:#0000ff">divide</span>(<span style="color:#000000">BigInteger</span> <span style="color:#000000">val</span>)                <span style="color:#aa5500">//除法</span>
<span style="color:#770088">public</span> <span style="color:#000000">BigInteger</span>[] <span style="color:#0000ff">divideAndRemainder</span>(<span style="color:#000000">BigInteger</span> <span style="color:#000000">val</span>)   <span style="color:#aa5500">//除法，获取商和余数</span>
<span style="color:#770088">public</span>  <span style="color:#008855">boolean</span> <span style="color:#0000ff">equals</span>(<span style="color:#008855">Object</span> <span style="color:#000000">x</span>)                        <span style="color:#aa5500">//比较是否相同</span>
<span style="color:#770088">public</span>  <span style="color:#000000">BigInteger</span> <span style="color:#0000ff">pow</span>(<span style="color:#008855">int</span> <span style="color:#000000">exponent</span>)                    <span style="color:#aa5500">//次幂、次方</span>
<span style="color:#770088">public</span>  <span style="color:#000000">BigInteger</span> <span style="color:#000000">max</span><span style="color:#981a1a">/</span><span style="color:#000000">min</span>(<span style="color:#000000">BigInteger</span> <span style="color:#000000">val</span>)              <span style="color:#aa5500">//返回较大值/较小值</span>
<span style="color:#770088">public</span>  <span style="color:#008855">int</span> <span style="color:#0000ff">intValue</span>(<span style="color:#000000">BigInteger</span> <span style="color:#000000">val</span>)                    <span style="color:#aa5500">//转为int类型整数，超出范围数据有误</span></span></span>

BigDecimal

在使用float或者double类型的数据在进行数学运算的时候，很有可能会产生精度丢失问题。我们都知道计算机底层在进行运算的时候，使用的都是二进制数据； 当我们在程序中写了一个十进制数据 ，在

进行运算的时候，计算机会将这个十进制数据转换成二进制数据，然后再进行运算，计算完毕以后计算机会把运算的结果再转换成十进制数据给我们展示； 如果我们使用的是整数类型的数据进行计算，那

么在把十进制数据转换成二进制数据的时候不会存在精度问题； 如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的

趋近于这个十进数的二进制数据； 这样使用一个不太准确的数据进行运算的时候， 最终就会造成精度丢失；为了提高精度，Java就给我们提供了BigDecimal供我们进行数据运算。

构造方法

要用BigDecimal类，那么就需要首先学习一下如何去创建BigDecimal的对象。通过查看API文档，我们可以发现Jdk中针对BigDecimal类提供了很多的构造方法，但是最常用的构造方法是：

了解完常见的构造方法以后，我们接下来就重点介绍一下常见的成员方法。

还有一个静态方法：BigDecimal.valueof();

优化了0-10之间的存储，必须是整数

常见成员方法

BigDecimal类中使用最多的还是提供的进行四则运算的方法，如下：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#770088">public</span> <span style="color:#000000">BigDecimal</span> <span style="color:#0000ff">add</span>(<span style="color:#000000">BigDecimal</span> <span style="color:#000000">value</span>)             <span style="color:#aa5500">// 加法运算</span>
<span style="color:#770088">public</span> <span style="color:#000000">BigDecimal</span> <span style="color:#0000ff">subtract</span>(<span style="color:#000000">BigDecimal</span> <span style="color:#000000">value</span>)        <span style="color:#aa5500">// 减法运算</span>
<span style="color:#770088">public</span> <span style="color:#000000">BigDecimal</span> <span style="color:#0000ff">multiply</span>(<span style="color:#000000">BigDecimal</span> <span style="color:#000000">value</span>)        <span style="color:#aa5500">// 乘法运算</span>
<span style="color:#770088">public</span> <span style="color:#000000">BigDecimal</span> <span style="color:#0000ff">divide</span>(<span style="color:#000000">BigDecimal</span> <span style="color:#000000">value</span>)          <span style="color:#aa5500">// 除法运算  如果除不尽，会报错，需要指定舍入的位数，以及舍入模式，</span></span></span>

正则表达式

做数据校验时可以反过来写，先把异常过滤，使得代码结构清晰一点。

正则表达式-字符类

• 语法示例：

1. [abc]：代表a或者b，或者c字符中的一个。

2. [^abc]：代表除a,b,c以外的任何字符。

3. [a-z]：代表a-z的所有小写字符中的一个。

4. [A-Z]：代表A-Z的所有大写字符中的一个。

5. [0-9]：代表0-9之间的某一个数字字符。

6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。

7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符。

正则表达式-逻辑运算符

• 语法示例：

  1. &&：并且

  2. | ：或者

  3. \ ：转义字符

正则表达式-预定义字符

• 语法示例：

  1. "." ： 匹配任何字符。

  2. "\d"：任何数字[0-9]的简写；

  3. "\D"：任何非数字[^0-9]的简写；

  4. "\s"： 空白字符：[ \t\n\x0B\f\r] 的简写

  5. "\S"： 非空白字符：[^\s] 的简写

  6. "\w"：单词字符：[a-zA-Z_0-9]的简写

  7. "\W"：非单词字符：[^\w]

正则表达式-数量词

• 语法示例：

  1. X? : 0次或1次

  2. X* : 0次到多次

  3. X+ : 1次或多次

  4. X{n} : 恰好n次

  5. X{n,} : 至少n次

  6. X{n,m}: n到m次(n和m都是包含的)

忽略大小写(?i)aa

作用：

1. 校验信息

2. 查找匹配文本

爬虫

Pattern ：表示正则表达式

Matcher ：文本匹配器，作用：按照正则规则从大串寻找符合规则的字串。

本地匹配：

<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#008855">String</span> <span style="color:#000000">s</span> <span style="color:#981a1a">=</span> <span style="color:#aa1111">"Java7非哈才能够你何必，Java11，Java"</span>;
        <span style="color:#aa5500">//1.获取正则表达式对象</span>
        <span style="color:#000000">Pattern</span> <span style="color:#000000">p</span> <span style="color:#981a1a">=</span> <span style="color:#000000">Pattern</span>.<span style="color:#000000">compile</span>(<span style="color:#aa1111">"Java\\d{0,2}"</span>);
        <span style="color:#aa5500">//2.获取文本匹配器对象</span>
        <span style="color:#aa5500">//拿着m去读取给出的串s，寻找其中符合规则p的子串</span>
        <span style="color:#000000">Matcher</span> <span style="color:#000000">m</span> <span style="color:#981a1a">=</span> <span style="color:#000000">p</span>.<span style="color:#000000">matcher</span>(<span style="color:#000000">s</span>);
        <span style="color:#aa5500">//3.利用循环去获取</span>
        <span style="color:#770088">while</span> (<span style="color:#000000">m</span>.<span style="color:#000000">find</span>()){
            <span style="color:#aa5500">//当他找到符合的子串时</span>
            <span style="color:#008855">String</span> <span style="color:#000000">s1</span> <span style="color:#981a1a">=</span> <span style="color:#000000">m</span>.<span style="color:#000000">group</span>();
            <span style="color:#aa5500">//把这个字串s1截取出来</span>
            <span style="color:#000000">System</span>.<span style="color:#000000">out</span>.<span style="color:#000000">println</span>(<span style="color:#000000">s1</span>);
            <span style="color:#aa5500">//打印在控制台上</span>
        }
​</span></span>

网络匹配：

Java(？=xx）: 表示Java后边可以拼接的数据，但是在获取的时候，只获取前半部分

？： 包含后边的数据

？！ 去除后边的数据

贪婪爬取： 默认

非贪婪爬取： + 或者*后加？

正则表达式在字符串中的使用

split ： 截取

replaceAll

捕获分组：（） 后续还要使用本组数据

正则内部分组：\\1 用在验证一致性 以（）的进出栈顺序来判断组号

正则外部分组：$1

非捕获分组：后续不再使用此数据，仅仅是作为普通分组 ?: ?! ?=