第十三章、常用类
包装类
包装类的分类
1、针对八种基本数据类型相应的引用类型—包装类
2、有了类的特点，可以调用类中的方法。
3、类型
4、八个包装类的关系
（1）黄色的是同一个父类
（2）char——》Character
（3）boolean——》Boolean
包装类和基本数据类型的转换
1、jkd5之前是手动的拆箱和装箱，
（1）装箱：基本类型—》包装类型
（2）拆箱：反之
2、jdk5和5以后都是自动拆箱和装箱
3、自动装箱底层是调用v alueOf方法
（1）eg：Integer.valueOf()
（2）eg：int n2 =200；
Integer integer = n2; //自动装箱底层仍然使用Inte.valueOf(n2);
4、自动拆箱
（1）eg：int n3 = integer ; //底层是intValue()方法
包装类型和String类型的相互转换
包装类——》String类
方式一、直接字符串拼接
eg：Integer i = 100；
String str1 = i+ "";
方式二、toString()方法
eg：String str2 = i.toString();
方式三、valueOf();
eg：String str3 = String.valueOf();
String类——》包装类
方式一、parseInt()方法
eg：Integer i2 = Integer.parseInt(str4) //自动装箱
方式二、构造器
eg：Integ i3 = new Integer(str4);
String类
String类的理解
1、String对象用于保存字符串，一组字符序列
2、字符串常量对象是用双引号括起的字符序列。例如：“你好”、“12.97“等
3、使用的是Unicode字符编码，一个字符两个字节
4、常用构造器(有很多个)
（1）String s1 = new String（）；
（2）String s2= new String（String orginal）；
（3）String s3= new String（char[] a）；
（4）String s4 = new String（char[] a ,int startIndex,int count）；
5、String类实现了接口：Serializable（String 可串行化：可以网络编程）
6、String类实现了接口：Comparable（String 对象可以比较大小）
7、String 是final类，不能被其他类继承
8、String有属性 ： private final char value[];用于存放字符串内容
9、一定注意：value是一个final类型，不可修改（value地址不能修改，不能指向其他地址空间）但是单个字符可以修改
String创建对象的两种方式
1、方式一：直接调用
（1）eg： String s = “hspedu”;
2、方式二：调用构造器 String s = new String（“hspedu”）;
两种创建String对象的区别
1、方式一：先从常量池查看是否有“hsp”数据空间，如果有，直接指向；如果没有，重新创建，然后指向，s最终指向常量池的空间地址
2、方法二：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有“hsp”，重新创建，如果有，直接指向，最终指向堆中的空间分布。
3、内存分布图
4补充：Intern（）方法
（1）当调用intern方法时，如果常量池已经包含了一个等于此String对象的字符串（用equals(Object)方法确定），则返回常量池中的字符串。否则，将次String对象性添加到池中，并返回次Sring对的引用
（2）理解：最终返回的是常量池的地址（对象）
字符串的特性
1、String是一个final类，代表不可变的字符序列
2、字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的。
（1）小结：底层是
①StringBuilder sb = new StringBuilder（）;
sb.append(a)；
②sb.append(b); //是在堆中，并且append是在原来字符出的基础上追加的
③String c1 =“ab",+"cd" //常量相加，看的是池
④String c1 = a+b; //变量相加，是在堆中
String常用方法
说明：String是保存字符串常量的，每次更新都要重新开辟空间，效率低，所以java设计者提供StringBuilder和StringBuffer来增强String的功能
1、equals：区分大小比较内容是否相同
2、equalsIgnoreCase：忽略大小写比较
3、length：返回字符串长度
4、 indexOf：获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到返回-1
（1）eg：
String s1 =wesaQwste;
int index = s1.indexOf('Q'); //字符串也行
5、lastIndexOf：获取字符在字符串对象中最后一次出现的索引，索引从0开始，如果找不到返回-1
6、subString：截取指定范围的子串。
（1）eg
String name = "abcdefghijklmn"; //角标0开始
sout(name.substring(x,y)) //截取x--y范围内的保留。
sout(name.substring(x)) //截取x以后的所有字符保留
7、toUpperCase：转换为大写
8、toLowerCase：转换为小写
9、concat：字符串拼接
（1）eg
String s1 = "牛"
s1 = s1.concat("啊").concat("神仙"); //类似+
10、replace：替换字符串中的字符
（1）eg：
s1 = s1.replace("xxx","yyy"); //在s1中把所有xxx字符，替换成yyy
（2）注意：如果不赋值，则没有对s1有影响（创建新对象）
10、split：分隔字符串，对于某些分隔字符，我们需要转义，比如| \ （常用于，切割域名）
（1）eg
String poem = “xxxxx，yyyyy，zzzzz”;
String [] split = poem.split(",");
for()//输出split数组。
11、toCharArray：字符串转换成数组
（1）eg
char[] chs = s.toCharArray();
12、compareTo：比较两个字符串的大小，如果前者大，则返回正数，后者大，则返回负数，如果相等，返回0。
13、forma：格式化字符（c语言的print语法）
（1）%s：字符串
（2）%c：字符
（3）%d：整型
（4）%.2f：浮点型
（5）理解：这些是占位符由后面变量来替换
StringBuffer类
基本介绍
1、代表可变的字符序列，可以对字符串内容进行增删
2、很多地方于String相同，但StringBuffer是可变长度的
3、StringBuffer是一个容器
4、结构图
String VS StringBuffer
1、String保存的是字符串常量，里面值不能改，每次String类的更新实际上就是更改地址，效率低下 //private final char value[]
2、StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率高 //cahr [] value;
StringBuffer构造方法
String 和 StringBuffer相互转换
String——》StringBuffer
1、使用构造器
（1）注意：返回的才是StringBuffer对象，对str本身没有影响
（2）eg：
①String str = “hello tom”;
②StringBuffer StringBuffer = new StringBuffer(str);
2、使用append()方法
（1）eg：stringBuffer1 = stringBuffer1.append(str);
StringBuffer ——》String
1、toString方法
（1）eg：
①StringBuffer stringBuffer3 = new StringBuffer("啊涛好帅");
②String s = stringBuffer3.toString();
2、使用构造器
（1）eg：
①String s1 = new String(stringBuffer3);
String Buffer常用方法
1、增加：append()方法
（1）eg：
①StringBuffer s = new StringBuffer("啊涛好帅");
②s.append("大傻瓜") //在后面追加
2、删除：delet()方法
（1）eg：
①s.delete(xx,yy) //删除xx到yy的值[xx-yy).前闭后开
3、替换：replace()
（1）eg：
①s.replace(xx,yy,mesg)//替换xx到yy的值，mesg为想要替换的信息
4、查找指定子串在字符串第一次出现的索引，如果找不到返回-1
（1）indexOf()方法
（2）eg：
①int indexOf = s.indexOf("涛") //1
5、插入字符串：insert()方法
（1）eg：
①s.insert(xx,"mesg") //在索引位置为xx的位置插入“mesg”，原有位置自动后移
StringBuilder类
基本介绍
1、一个可变的字符序列，此类提供一个与StringBuffer兼容的API，但不保证同步（StringBuilder不是线程安全）。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议先采用该类，大多数情况，StringBuilder比StringBuffer快
2、在StringBuilder 上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。
3、结构示意图
4、注意
（1）StringBUilder继承AbstractStringBuilder类
（2）实现了Serializable，说明StringBuilder对象是可以串行化（对象是可以网络传输，可以保存到文件）
（3）StringBuilder是final类，不能被继承
（4）StringBuilder对象字符序列仍然是存放在其父类AbstractStringBuilder的char[] value;因此，字符序列是堆中
（5）StringBuilder的方法，没有做互斥处理，即没有synchronized关键字，因此在单线程的情况下使用StringBuilder
StringBuilder和String和StringBuffer比较
1、内容比较：
（1）StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样。
（2）String：不可变字符序列，效率低，但是复用率高
（3）StringBuffer：可变字符序列，效率高（增删），线程安全
（4）StringBuilder：可变字符序列，效率最高，线程不安全
（5）String使用说明：string实际上原来的“a“字符串对象以及丢弃了，现在有产生了一个字符，如果多次执行，效率极低。
①结论：如果我们对String做大量修改，不要使用String
2、使用原则！
（1）如果字符串存在大量修改操作，一般使用StringBuffer或StringBuilder
（2）如果字符串存在大量修改操作，并在单线程的情况，使用StringBuilder
（3）如果字符串存在大量修改操作，并在多线程的情况，使用StringBuffer
（4）如果我们字符串很少修改，被多个对象引用，使用String，比如数据库信息配置等
Math类
常用方法
1、Math.abs：绝对值
2、Math.pow(x，y)：x的y次方
3、Math.ceil():向上取整，返回>=该参数的最小整数
（1）eg：Math.ceil(-3.0001) //结果为：-3
4、Math.floor()：向下取整，返回<=该参数的最大整数
5、Math.round()：四舍五入，Math.floor(该参数+0.5)
6、Math.sqrt()：开方。
7、Math.random：求随机数，返回的是0-1之间的随机小数，前闭后开
8、Math.min()：返回最小值
9、Math.max()：返回最大值
Arrays类
常用方法
1、toString()：返回数组的字符串形式
(1)eg：
Arrays.toString(arr)
2、sort()：升序排序
（1）eg：
Arrays.sort(arr);
（2）因为数组是引用类型，所以通过sort排序后，会直接影响到实参arr
（3）定制排序
3、binarySearch：二分法搜索查找。
（1）注意：
①要求必须数组是有序的，无须则无法使用binarySeach
②如果数组中不存在该元素，则返回-1
（2）用法：int index = Arrays.binarySeach(arr,0);
Sout("index = " + index);
（3）如果找不到该元素，则返回return -(low +1); //low是成功那个
4、copyOf()：数组元素的复制
（1）Integer newArr = Arrays.copyOf(arr, arr.length);
（2）理解：从arr数组中，拷贝arr.length个元素到newArr数组中
（3）如果拷贝长度>arr.length就在新数组后面，增加null
（4）如果拷贝长度<0就抛出异常NegativeArraySizeException
（5）该方法低层使用的是System.arraycopy()
5、fill()方法：数组元素的填充
（1）eg：
①：Integer[] num = new Integer[] {9,3,2};
②：Arrays.fill(num,99);
③：理解：使用99去填充num数组，可以理解成是替换原理的元素
6、equals：比较两个数组元素内容是否完全一致
（1）eg：
①：boolean equals = Arrays.equals(arr,arr2);
//比较arr，arr2数组元素是否完全一致
7、aList将一组数值，转换成list
（1）aList方法，会将（2,3,4,5,6,1）数据转成一个List集合
（2）返回的asList编译类型List(接口)
System类
1、exit：退出当前程序
2、arraycopy：赋值数组元素，比较适合低层调用，一般使用Arrays.copyOf完成复制数组
（1）eg：int [] src = {1,2,3};
int [] dest = new int[3];
System.out.println(src,0,dest,0,3);
（2）理解：
①src表示：原来的数组
②0表示：从索引哪个位置开始拷贝
③dest：目标数组，把原数组拷贝到dest数组
④0表示：拷贝到目标数组的哪个索引位置
⑤3：表示从原数组拷贝多少个到原数组
3、currentTimeMillens:返回当前时间距离1970-1-1的毫秒数
4、gc：运行垃圾回收机制System.gc();
BigInteger和BigDecimal类
BigInteger和BigDecimal介绍
BigInteger
1、应用场景
（1）BigInteger适合保存比较大的整型
（2）BigDecimal适合保存进度更高的浮点数（小数）
2、BigInteger理解
（1）低层是转化为字符串
（2）四则运算需要调用方法
①add：加
②subtract：减
③multiply：乘
④divide：除
3、eg：
（1）BigInteger bgI = new BigInteger（“999999999999999999999999999999999999999999999999”）;
（2）BigInteger add = bgI.add(new BigInteger("8888888"))；
（3）sout(add);
BigDecimal
1、理解：和BigInteger类似
2、不同
（1）如果在调用divide方法时，指定精度即可.BigDecimal.ROUND_CEILING
（2）如果有无限循环小数，就会保留分子的进度
（3）eg：
①BigInteger bgI = new BigInteger（“99999999999.9999999999999999999999999999999999999”）;
②sout.println(bigDecimal.divide(bigDecimal2,BigDecimal.ROUND_CEILING));
日期类
第一代日期类
1、Date：精确到毫秒，代表特定的瞬间
（1）新建对象，对象就会输出一个默认的日期格式，一般为国外的方式，所以需要进行格式转换
2、SimpleDateFormat：格式和解析日期的类
（1）可以指定格式
（2）在新建SimpleDateFormat对象创建，传入（“日期格式”）
（3）eg：
SimpleDateFormat sp = new SimpleDateFormat("yyyyddmmhhmmss E")
String format = sp.format(d1);
3、SimpleDateFormat格式和解析日期的具体类。
（1）它允许进行格式化（日期—>文本）
（2）允许解析：（文本—>日期）和规范化
4、通过毫秒数进行时间的运算
（1）Date d2 = new Date(888888);
5、格式化字符串转成Date
（1）日期格式一定要正确（匹配和设置的日期一定要匹配）
（2）eg：
String a = "2022年12月19日。06:22:11 星期一";
Date parse = sdf.parse(a);
System.out.println(sdf.format(parse));第二代日期类
1、是一个抽象类、构造器是protected，
2、可以通过getINstance()来获取实例
3、提供大量的方法和字段
4、方法c.get(Calendar.MONTH)
Calendar c = Calendar.getInstance();
System.out.println("c="+ c);
System.out.println("年："+c.get(Calendar.YEAR));
System.out.println("月："+c.get(Calendar.MONTH)+1);
System.out.println("日："+c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时："+c.get(Calendar.HOUR));
System.out.println("钟："+c.get(Calendar.MINUTE));
System.out.println("秒："+c.get(Calendar.SECOND));5、Calendar没有提供专门的格式化方法，所以需要程序员自己来组合显示
6、如果想显示24小时
（1）把字段改成：HOUR_OF_DAY
第三代日期类
1、因为Calendar也存在问题
（1）可变性：像日期和时间这样的类应该是不可变的。
（2）偏移性：Date中的年份是从1900开始，而月份都是从0开始（所以要+1）
（3）格式化：格式化只对Date有用，Calendar则不行。
（4）此外，它们也不是线程安全的；不能处理闰秒等（每隔两天，多出1s）
常用方法
1、LocalDate（日期/年月日）
2、LocalTime（时间/时分秒）
3、LocalDateTime（日期时间/年月日时分秒）
（1）使用now()返回表示当前日期时间的对象
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);
（2）3包含了1和2
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);
System.out.println("年"+ldt.getYear());
System.out.println("月"+ldt.getMonth());
System.out.println("日"+ldt.getMonthValue());
System.out.println("时"+ldt.getHour());
System.out.println("分"+ldt.getMinute());
System.out.println("秒"+ldt.getSecond());
LocalDate now =LocalDate.now();//可以获取年月日
LocalTime now2 =LocalTime.now();//获取到时分秒
System.out.println(now);
System.out.println(now2);4、DateTimeFormat对象来进行格式化 //jdk1.8才有
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
System.out.println(dateTimeFormatter);
String format = dateTimeFormatter.format(ldt);
System.out.println(format);
5、Instant时间戳
（1）类似于Date
（2）提供了一些列和Date的转换方式
（3）Instant—>Date：Date.from(instant);
（4）Date—>Instant：date.toInstant();
//静态 now() 获取表示当前时间戳的对象
Instant now = Instant.now();
System.out.println(now);
//通过from可以把Instant转换成Date
Date date = Date.from(now);
Instant instant = date.toInstant();6、提供plus肯minus方法可以对当前时间进行加或者减
（1）plus();
//添加800天后输出
LocalDateTime localDateTime=ldt.plusDays(800);
System.out.println(localDateTime);（2）Minus();
// 在3456分钟前是什么时候， 把年月日时分秒打印
LocalDateTime localDateTime2 =ldt.minusMinutes(3456);
System.out.println(localDateTime2);