一文了解JAVA的常用API

常用kpi

学习目的：

了解类名和类的作用
养成查阅api文档的习惯

`math`

工具类。因为是工具类，因此直接通过类名.方法名(形参)即可直接调用

abs：获取参数绝对值

bug：传递的数必须在对应数据类型的取值范围内有相反数和他对应，如byte-128到127，-128没有值与之对应
ceil：向上取值，即向数轴的正方向取值（注意不是四舍五入）
floor：向下取值，即向数轴的负方向取值（注意不是四舍五入）
round：四舍五入，入到较近的偶数，如：

12.51->13

-12.49->-12
max、min：取最值，底层是三元运算符

max：两者之间取大值

min：两者之间取小值
pow：获取a的b次幂
sqrt:返回开平方根后的值
cbrt：返回开立方根后的值
random：注意这里是math工具类中的random方法，不是Random类中的。math中的random底层还是创建了Random的对象然后采用nextDouble，math中的random：获取[0.0,1.0)之间的随机小数。

`System`

工具类。

计算机的时间原点：1970年1月1日 00:00:00->C语言的生日，我国：1970年1月1日 08:00:00

成员变量：

out：静态变量，因此可以用System.out调用，返回一个打印的对象

成员方法：

exit：终止虚拟机的运行，返回状态码，0是虚拟机正常停止；非0是虚拟机异常停止。不管是非0还是0，后面代码都不会执行
currenTimeMillis：返回当前系统的时间，以毫秒形式
arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数)：数组拷贝。
- 细节1：如果两数组都是基本数据类型，那么它们必须是同一种数据类型，否则会报错。type mismatch异常
- 细节2：需要考虑数组的长度，如果超出范围会报错。index out of bounds索引越界异常
- 细节3：如果两数组都是引用数据类型，那么子类类型可以赋值给父类类型
  - 细节中的细节：如果此时想要将目的地数组中的父类地址打印出来，除了常规的for遍历、定义一个子类对象临时储存器之外，注意这时候要将父类强转后再赋值给子类对象临时储存器，不强转会报错（底层？)。可以类似理解成小可以自动转大，大则需要强转小，也是用水杯和水桶来理解。

`Runtime`

表示当前虚拟机的运行环境。

getRuntime：获取当前系统的运行环境对象。
- 底层：Runtime类私有化了构造方法，不给外界创建对象，因此提供了get方法获取他的对象，不管在哪个类中，每次调用这个方法获取到的对象都是唯一的
exit：停止虚拟机。非静态，需要创建Runtime对象调用
availableProcessors：获取CPU的线程数
maxMemory：JVM能从系统中获得的总内存大小，单位字节
totalMemory：JVM已经从系统中获得的总内存大小，单位字节
freeMemory：JVM剩余内存大小
exec：运行cmd命令。比如指定时间关机选项。

`Object`

Java中的顶级父类。

特点：

没有成员变量，因为不可能所有子类都能抽取出一个共性来。
只有无参构造，没有有参构造。

成员方法：

toString：返回对象的字符串表现形式。该方法被public修饰，因此所有类的对象都可以在其虚方法表中调用这个方法，因为所有对象的类都默认继承于Object。
- System.out.println(s)的底层：当我们在形参中输入一个对象类型的s时候，底层会尝试调用对象的toString方法，先在这个对象的类的成员方法中找，如果没有则在它的虚方法表中找，发现有该方法（从Object继承下来的），因此就会调用，把对象变成字符串。然后再打印在控制台上，打印完毕进行换行。toString的结论：如果不想这个对象打印字符串形式，而是想看到对象的内部属性（成员变量等），那么我们在该对象的类中重写Object的toString方法即可，在这个重写的方法的代码体中就可以打印对象的成员属性了

equals：比较两个对象是否相等。

equals的底层：用==号判断两个地址值是否相同，返回true和false。一般地址值对我们意义不大，如果不想比较地址值，想比较两个对象中的内部属性值，则在调用者的那个类重写equals方法即可。

//用equals方法比较String和StringBuilder
package com.itheima.a04objectdemo;
public class ObjectDemo3 {
    public static void main(String[] args) {
        String s = "abc";
        StringBuilder sb = new StringBuilder("abc");

        System.out.println(s.equals(sb));// false
        //因为equals方法是被s调用的，而s属于String类，所以equals要看String类中的equals方法，而String类中的equals方法，源码是先判断形参sb是否为字符串，如果是字符串，再比较内部的属性，但是如果参数不是字符串，直接返回false


        System.out.println(sb.equals(s));// false
        //因为equals方法是被sb调用的，而sb是StringBuilder，所以这里的equals方法要看StringBuilder中的equals方法。而在StringBuilder当中，没有重写equals方法，使用的是Object中的，在Object当中默认是使用==号比较两个对象的地址值，而这里的s和sb记录的地址值是不一样的，所以结果返回false
    }
}

clone：把A对象的属性值完全拷贝给B对象，也叫对象拷贝、复制。方法在底层会帮我们创建一个对象，并帮我们把原对象（调用者）的数据拷贝过去。

**一些书写细节：**1、要让调用者子类重写Object中的clone方法，因为clone在Object中是用protected修饰的，在测试类中没有权限访问；2、让JavaBean类实现Cloneable接口；3、创建原对象并调用clone。
- **浅克隆：**基本数据类型直接拷贝数据值，引用数据类型拷贝地址值。Object中的clone方法用的就是浅克隆。
- 浅拷贝的内存图：

**深克隆：**基本数据类型直接拷贝数据值，引用数据类型重新创建一个对象，特殊：对于直接赋值的字符串，是在串池管理的，这些会直接复用而不会创建新的空间
深克隆的内存图：

**实现深克隆的方式：**在重写的clone方法中自己改代码或者使用第三方工具类。
- 方法一：自己重写方法

//这是一个JavaBean类User，实现了一个接口Cloneable，表示这是可被克隆的，但是这个接口中没有抽象方法。如果一个接口里面没有抽象方法表示当前的接口是一个标记性接口。现在cloneable表示一旦实现了，那么当前类的对象就可以被克隆；如果没有实现，当前类的对象就不能克隆。（这里不懂，貌似是关于什么异常处理？）
public class User implements Cloneable {
    private int id;
    private String username;
    private String password;
    private String path;
    private int[] data;  
----------------------------------------------------------------------------------------------
//这里还是上面的JavaBean类User。重写Object类中的clone方法，以实现深克隆。
   @Override
    protected Object clone() throws CloneNotSupportedException {
        //先把被克隆对象中的数组获取出来
        int[] data = this.data;
        //创建新的数组
        int[] newData =new int[data.length];
        //拷贝数组中的数据
        for (int i = 0; i < data.length; i++) {
            newData[i] = data[i];
        }
        //调用父类中的方法克隆对象
            User u=(User)super.clone();
        //因为父类中的克隆方法是浅克隆，替换克隆出来对象中的数组地址值
        u.data =newData;
        return u;
    }

方法2：采用第三方工具类。选中jar文件复制->在当前模块下新建一个包lib（library，可以把第三方代码都放在这）->粘贴->OK->导入后右键新导入的jar点击Add as Library->OK

`Objects`

工具类，提供了一些方法，免得我们自己做非空判断。

equals：先做非空判断，再判断两个对象。
- 底层：方法的底层会判断s1是否为null，如果为null，直接返回false；如果s1不为null，那么就利用s1再次调用equals方法
  此时s1是student类型，所以最终还是会调用student中的equals方法。如果没有重写，比较地址值，如果重写了，就比较属性值。
isNull：判断对象是否为null，为null则返回true，否则返回false
nonNull：和isNull相反

`BigInteger`

用来创建很大的大整数。

构造方法：对象一旦创建，内部的值不能发生改变
在这里插入图片描述
构造方法注意：

打印BigInteger对象是其中的数据值，不是地址值，因为在它的底层重写了父类Object的toString方法，使得打印出来的数据是其中的内容
第二种方法中，如果字符串里面有小数和字母就会报错，只能是一个整数
第三个方法中，输入的整数形式必须和进制形式吻合
第四个方法中，输入的整数只能在Long的范围内，因此和第二种方法相比，取值范围更小；第四种方法在内部对常用的数字进行了优化，提前把-16 ~ 16 先创建好BigInteger的对象，如果多次获取不会重新创建新的对象，而是直接指向之前创建好的对象。

构造方法小结：
在这里插入图片描述
成员方法：

成员方法注意：

这里都是方法，必须创建对象后调用方法才能进行运算
equals重写了，比较的是BigInteger对象当中的数据值不是地址值
intValue方法不能超出int范围

BigInteger的底层存储方式（了解，跳过）

`BigDecima`

用于小数的精确运算 / 用来表达很大的小数。

两个构造方法示例：

public Bigdecima(double val)：这种方式有可能是不精确的，不建议使用
public Bigdecima(String val)：根据传递的字符串创建小数，结果精确

**静态方法valueOf：**如果我们传递的是0~10之间的整数，包含0，包含10，那么方法会返回已经创建好的对象，不会重新new；如果传递的是是小数，那么底层返回的是帮我们new出来的Bigdecima

建议：
在这里插入图片描述
成员方法：

成员方法注意

使用divide(BigDecima val)的时候必须保证两个数之间除得尽，如10.0和2.0，8.0和4.0等，不然会报错
舍入模式是一个类RoundingMode，当中有很多静态常量供我们选择，它们表示不同的舍入模式。只需要掌握一个舍入模式HALF_UP（四舍五入），如果与两个相邻数字距离相等，则向上舍入（远离零的方向，如4.5变5，2.5变3，-2.5变-3）；其他的不会查文档即可。

BigDecima的底层存储方式（跳过）

遍历输入的字符串，转换成字符数组，然后存储ASCII码表对应数字。

正则表达式

实际开发正则表达式的用法：1、下载插件，导入常用的正则表达式；2、用AI写、百度找；3、查API文档，自己写。

自己写的心得：按照正确的数据，从左往右依次匹配字符

API文档中：Pattern类，只要掌握字符、字符类、预定义字符类、Greedy 数量词即可。

作用一：校验字符串是否满足规则。如校验用户名、校验密码、校验身份证等字符串。

作用二：在一段文本中查找想要的内容。

matches方法：
在这里插入图片描述
预定义字符示例：

package com.itheima.a08regexdemo;
public class RegexDemo3 {
    public static void main(String[] args) {
        // \ 转义字符 改变后面那个字符原本的含义
        //此时\表示转义字符，改变了后面那个双引号原本的含义
        //把他变成了一个普普通通的双引号而已。
        System.out.println("\"");

        // \表示转义字符
        //两个\的理解方式：前面的\是一个转义字符，改变了后面\原本的含义，把他变成一个普普通通的\而已。
        System.out.println("c:Users\\moon\\IdeaProjects\\basic-code\\myapi\\src\\com\\itheima\\a08regexdemo\\RegexDemo1.java");

        //.表示任意一个字符
        System.out.println("你".matches("..")); //false
        System.out.println("你".matches(".")); //true
        System.out.println("你a".matches(".."));//true

        // \\d 表示任意的一个数字
        // \\d只能是任意的一位数字
        // 简单来记:两个\表示一个\
        System.out.println("a".matches("\\d")); // false
        System.out.println("3".matches("\\d")); // true
        System.out.println("333".matches("\\d")); // false

        //\\w只能是一位单词字符[a-zA-Z_0-9]
        System.out.println("z".matches("\\w")); // true
        System.out.println("2".matches("\\w")); // true
        System.out.println("21".matches("\\w")); // false
        System.out.println("你".matches("\\w"));//false

        // \\W非单词字符
        System.out.println("你".matches("\\W")); // true
        System.out.println("---------------------------------------------");
        // 以上正则匹配只能校验单个字符。

        // 必须是数字 字母 下划线 至少 6位
        System.out.println("2442fsfsf".matches("\\w{6,}"));//true
        System.out.println("244f".matches("\\w{6,}"));//false

        // 必须是数字和字符 必须是4位
        System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//true
        System.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//false
        System.out.println("23dF".matches("[\\w&&[^_]]{4}"));//true
        System.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false
    }
}

正则表达式练习：

        //邮箱号码
        //3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn
        //思路:
        //在书写邮箱号码正则的时候需要把正确的数据分为三部分
        //第一部分:@的左边 \\w+
        //      任意的字母数字下划线，至少出现一次就可以了
        //第二部分:@ 只能出现一次
        //第三部分:
        //      3.1         .的左边[\\w&&[^_]]{2,6}
        //                  任意的字母加数字，总共出现2-6次(此时不能出现下划线)
        //      3.2         . \\.为什么是//.？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
        //      3.3         大写字母，小写字母都可以，只能出现2-3次[a-zA-Z]{2,3}
        //      我们可以把3.2和3.3看成一组，这一组可以出现1次或者两次
        String regex3 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";
        System.out.println("3232323@qq.com".matches(regex3));
        System.out.println("zhangsan@itcast.cnn".matches(regex3));
        System.out.println("dlei0009@163.com".matches(regex3));
        System.out.println("dlei0009@pci.com.cn".matches(regex3));
    }
}

忽略大小写：

//忽略大小写的书写方式
//在匹配的时候忽略abc的大小写
String regex4 = "a((?i)b)c";
System.out.println("------------------------------");
System.out.println("abc".matches(regex4));//true
System.out.println("ABC".matches(regex4));//false
System.out.println("aBc".matches(regex4));//true

正则表达式符号总结（眼熟即可）：
在这里插入图片描述

包装类

基本数据类型所对应的引用数据类型。如int->Integer。通俗来说：用对象把基本数据包起来。

内存图
在这里插入图片描述
应用场景：**

方法中需要接受一个对象类型的时候，如method(Object obj)，这时候基本数据类型就接收不了
集合只能存储对象类型的数据

八大数据类型对应的包装类

两个特殊

获取Integer对象的方式（了解）

JDK5后对此进行了优化。JDK5前需要自己构造或者调用静态方法

采用构造方法创建对象

Integer i = new Integer(1);

采用静态方法创建对象

Integer i = Integer.valueOf(123);

获取Integer对象两种方式的区别（掌握）

对于valueOf静态方法，查看源码可以发现，底层帮助我们将-128~127（byte类型的取值范围）对应的对象事先创建好并存储在了数组当中，因此用==号比较地址值需要注意。

应用背景：
因为在实际开发中，-128~127之间的数据，用的比较多。
如果每次使用都是new对象，那么太浪费内存了
所以，提前把这个范围之内的每一个数据都创建好对象
如果要用到了不会创建新的，而是返回已经创建好的对象。

        Integer i6 = Integer.valueOf(127);
        Integer i7 = Integer.valueOf(127);
        System.out.println(i6 == i7);//true
        
        Integer i8 = Integer.valueOf(128);
        Integer i9 = Integer.valueOf(128);
        System.out.println(i8 == i9);//false

JDK5以后包装类的新特性

自动装箱和自动拆箱（JDK5以后）

自动装箱：把基本数据类型自动变成包装类。举例：

//JDK5以前，需要手动创建对象
Integer i = new Integer(1);
//或者手动调用静态方法
Integer i = Integer.valueOf(1);

//JDK5以后，自动装箱。把基本数据类型1直接赋值给包装类对象i，在底层就帮我们创建好1的包装类对象
Integer i = 1;

自动拆箱：把包装类自动变成对应基本数据类型。举例：

//把包装类对象Integer i赋值给对应的基本数据类型变量int i。底层会帮我们进行拆箱，即把包装类对象转换为基本数据类型，再参与计算
int a =i;

结论：在JDK5以后，int和Integer可以看做是同一个东西，因为在内部可以自动转化。

以后不需要new创建对象，也不需要调用静态方法，直接将基本数据赋值给包装类对象即可。

对于包装类的计算，我们可以直接采用变量名参与计算即可。

Integer i1 = 1;
Integer i2 = 2;
Integer i3 = i1 +i2;
print(i3);//3

包装类Integer的成员方法

应用1：得到某个整数的不同进制下的数据

    public static void main(String[] args) {
        /*
            public static string tobinarystring(int i)传入int类型的整数，得到二进制
            public static string tooctalstring(int i) 传入int类型的整数，得到八进制
            public static string toHexstring(int i) 传入int类型的整数，得到十六进制
            public static int parseInt(string s) 传入字符串，将字符串类型的整数转成int类型的整数
        */
        //1.把整数转成二进制，十六进制
        String str1 = Integer.toBinaryString(100);
        System.out.println(str1);//1100100

        //2.把整数转成八进制
        String str2 = Integer.toOctalString(100);
        System.out.println(str2);//144

        //3.把整数转成十六进制
        String str3 = Integer.toHexString(100);
        System.out.println(str3);//64

        //4.将字符串类型的整数转成int类型的整数
        //java是强类型语言:每种数据在java中都有各自的数据类型，在计算的时候，如果不是同一种数据类型，是无法直接计算的。
        int i = Integer.parseInt("123");
        System.out.println(i);
        System.out.println(i + 1);//124
        //细节1:
        //在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错
            //细节2:
        //8种包装类当中，除了Character都有对应的parseXxx的方法，进行类型转换
        String str = "true";
        boolean b = Boolean.parseBoolean(str);
        System.out.println(b);


    }
}

应用2：用parsexxx方法改写键盘录入

public class A05_IntegerDemo5 {
    public static void main(String[] args) {
        //键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        /* String str = sc.next();
        System.out.println(str);*/
        //当我们在使用next，nextInt，nextDouble在接收数据的时候，弊端:遇到空格，回车，制表符的时候就停止了
        //键盘录入的是123 123 那么此时只能接收到空格前面的数据,而不是想要的是接收一整行数据
        //建议:以后我们如果想要键盘录入，不管什么类型，统一使用nextLine，可以接收一整行数据，特点:遇到回车才停止
        //这个接收的line是字符串类型的
        String line = sc.nextLine();
        System.out.println(line);
        //将得到的一整行数据再去调用parsexxx静态方法转成自己想要的数据类型
        //如Double.parseDouble方法，将传入的字符串类型的小数转成double类型的小数
        double v = Double.parseDouble(line);
        System.out.println(v);
    }
}

参考学习资料：https://www.bilibili.com/video/BV17F411T7Ao/?spm_id_from=333.1007.top_right_bar_window_default_collection.content.click&vd_source=b3f048c1c718e510d2f25b81161f3479