- 包装类
- 基本介绍
- 装箱和拆箱
- 包装类和String类的转换
- String类
- 基本介绍
- 创建流程
- 常用方法
- StringBuffer类StringBuilder类
- 基本介绍
- String的构造方法
- String和StringBuffer的转换
- StringBuilder类
- Date日期类，Calendar日历类和新的日期
- 第一代日期类
- 第二代日期类
- 第三代日期类
- 时间戳Instant
- System类
- Arrays类
- BigInteger类和BigDecimal类
1.针对8种基本数据类型相应的引用类型—包装类。
2.有了类的特点，就可以调用相应的方法。
JDK5前的手动装箱和拆箱方式：装箱------基本类型到包装类型，拆箱------包装类型->基本类型。
JDK5以后有了自动装箱和拆箱方式，其实底层调用的还是之前的方法。
int n1 = 100;
//手动装箱和拆箱
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);
int n2 = integer.intValue();
//自动装箱和拆箱
Integer integer2 = n1;
int n3 = integer2;
包装类和String类的转换
//包装类(Integer)->String
//方式1
Integer integer3 = 20;
String str1 = integer3 + "";//这种方式integer3的类型没有转变
//方式2
String str2 = integer3.toString();
//方式3
String str3 = String.valueOf(integer3);
//String->包装类(Integer)
//方法1
String s1 = "12345";
Integer i1 = Integer.parseInt(s1);//使用了自动装箱
//方法2
Integer i2 = new Integer(s1);//使用了Integer的构造器
==运算符判断时，如果两边其中有一个是基本数据类型，那么判断的要求就是两边的值是否相等。
String类 基本介绍1.字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节。
2.String类实现了接口Serializable，表示可以串行化：可以在网络中传输
实现了接口Comparable，表示它的对象可以比较大小。
1.String是final类，它不能被继承。
2.String有属性 private final char value[ ] ，用于存放字符串内容。
3.value是被final修饰的，表示 value 指向的地址是不能变化的，即不能进行数组间的赋值。
创建流程
(1).方法1 : 先从常量池查看是否有"hsp"数据空间，如果有，直接指向，如果没有，则重新创建，然后指向，s最终指向的是常量池的空间地址。
(2) 方法2 : 先在堆中创建空间，里面维护了value属性，指向常量池的"hsp"空间，如果常量池中没有"hsp"，重新创建。
常用方法 //1.equals 它的比较区分大小写
String str1 = "hello";
String str2 = "Hello";
System.out.println(str2.equals(str1));
//2.equalsIgnoreCase 它的比较忽略大小写
String username = "johN";
if("john".equalsIgnoreCase(username)){
System.out.println("success!");
}else{
System.out.println("failure!");
}
//3.length 获取字符的个数
System.out.println(str1.length());
//4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1
String s1 = "1234567";
System.out.println(s1.indexOf('2'));
//5.lastIndexOf 获取字符在字符串对象中最后一次出现的索引，索引从0开始，如果找不到，返回-1
String s2 = "qwersdwe";
System.out.println(s2.lastIndexOf('w'));
//substring 截取指定范围的子串
String name = "hello,张三";
System.out.println(name.substring(6));//从下标6开始截取
System.out.println(name.substring(0,5));//从下标0截取到4
//1.toUpperCase转成大写
String s1 = "hello";
System.out.println(s1.toUpperCase());
//2.toLowerCase转成小写
System.out.println(s1.toLowerCase());
//3.concat拼接字符串
String s2 = "abc";
System.out.println(s2.concat("def").concat("gh"));
//4.replace 替换字符串中的字符
String s3 = "123 234 123 abc abc";
System.out.println(s3.replace("123","a"));//s3未改变
System.out.println(s3);
//5.split 分割字符串 返回一个数组，如果有特殊符号，需要加入转义符
String poem = "E:\aaa\bbb";
String[] split = poem.split("\\");
for (int i = 0; i < split.length; i++) {
System.out.println(split[i]);
}
//6.toCharArray 转化成字符数组
String s = "happy";
char[] chs = s.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.println(chs[i]);
}
StringBuffer类StringBuilder类
基本介绍
1.很多方法和String是类似的，但是StringBuffer是可变长度的。
2.StringBuffer是一个容器。
3.StringBuffer 实现了 Serializable, 即 StringBuffer 的对象可以串行化。
4.在父类中 AbstractStringBuilder 有属性 char[] value,不是 final ， 该 value 数组存放 字符串内容，是放在堆中的。
5.StringBuffer 是一个 final 类，不能被继承。
6.因为 StringBuffer 字符内容是存在 char[] value, 所有变化(增加/删除) 不用每次都更换地址(即不是每次创建新对象)，(除非空间不够)， 所以效率高于 String。
String和StringBuffer的比较：
1.保存的是字符串常量，里面的值不能更改，每次String 类的更新实际上就是更改地址，效率极低。
2.StringBuffer保存的是字符串变量，里面的值可以更改，不用每次更新地址，效率极高。
String的构造方法//char[] value数组的长度为16
StringBuffer stringBuffer = new StringBuffer();
//char[] value数组的长度为20
StringBuffer stringBuffer1 = new StringBuffer(20);
//char[] value数组的长度为hello.length+16
StringBuffer stringBuffer2 = new StringBuffer("hello");
String和StringBuffer的转换
//String-->StringBuffer
String str = "hello";
//1.利用构造器,对str没有影响
StringBuffer SB1 = new StringBuffer(str);
//2.利用append方法
SB1 = SB1.append(str);
//StringBuffer--->String
//方法1.利用toString方法
String str2 = SB1.toString();
//方法2.直接new
String s = new String(SB1);
StringBuilder类
基本介绍：一个可变的字符序列，此类提供一个StringBuffer兼容的API，但不保证同步（StringBuilder不是线程安全），此类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用时，如果可能，优先使用该类，因为在大多数实现中，它比StringBuffer要快。
在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接收任意类型的数据。
- StringBuilder 继承 AbstractStringBuilder 类
2.实现了 Serializable ,说明 StringBuilder 对象是可以串行化(对象可以网络传输,可以保存到文件)
- StringBuilder 是 final 类, 不能被继承
4.StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder 的 char[] value，存放在堆中的。
5.StringBuilder 的方法，没有做互斥的处理,即没有 synchronized 关键字,因此在单线程的情况下使用。
Date日期类，Calendar日历类和新的日期 第一代日期类 //Date的三种使用方式
//第一种方式
Date d1 = new Date();//此时默认输出的日期格式是国外的方式, 因此通常需要对格式进行转换
//创建 SimpleDateFormat 对象，可以指定相应的格式
//这里的格式使用的字母是规定好，不能乱写
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
String format = sdf.format(d1);
System.out.println(format);
//第二种使用方式
//通过输入一个long型数表示毫秒来获取时间
Date d2 = new Date(1234568);
System.out.println(d2);
//第三种方式，恰好与第一种相反，将一个格式化的转换为默认的形式
//在把 String -> Date ， 使用的 sdf 格式需要和你给的 String 的格式一样，否则会抛出转换异常
String s1 = "2019年12月12日 12:23:24 星期三";
System.out.println(sdf.parse(s1));
第二代日期类
//1. Calendar 是一个抽象类， 并且构造器是 private
//2. 可以通过 getInstance() 来获取实例
//3. 提供大量的方法和字段提供给程序员
Calendar c1= Calendar.getInstance();
System.out.println("年: "+c1.get(Calendar.YEAR));
//这里为什么要 + 1, 因为 Calendar 返回月时候，是按照 0 开始编号
System.out.println("月: "+(c1.get(Calendar.MONTH)+1));
System.out.println("日：" + c1.get(Calendar.DAY_OF_MONTH));
System.out.println("小时：" + c1.get(Calendar.HOUR_OF_DAY));
System.out.println("分钟：" + c1.get(Calendar.MINUTE));
System.out.println("秒：" + c1.get(Calendar.SECOND));
第三代日期类
//使用now方法创建当前时间的对象
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.getDayOfMonth());
System.out.println("时=" + ldt.getHour());
System.out.println("分=" + ldt.getMinute());
System.out.println("秒=" + ldt.getSecond());
//使用DateTimeFormatter对象将时间进行格式化
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String s = dtf.format(ldt);
System.out.println(s);
时间戳Instant
//通过 静态方法 now() 获取表示当前时间戳的对象
Instant i1 = Instant.now();
System.out.println(i1);
//2. 通过 from 可以把 Instant 转成 Date
Date d1 = Date.from(i1);
System.out.println(d1);
//3. 通过 date 的 toInstant() 可以把 date 转成 Instant对象
Instant i2 = d1.toInstant();
System.out.println(i2);
System类
//exit(0)表示程序退出
//0表示一个状态，正常的状态
System.out.println("123");
System.exit(0);
System.out.println("234");
//arraycopy:复制数组元素，比较适合底层使用。
//传入的参数意义分别为：源数组，从源数组那个下标开始拷贝，目标数组，从目标数组那个下标开始存放
//拷贝的元素个数
System.arraycopy(src,0,dest,0,src.length);
//currentTimeMillens:返回当前时间距离1970-1-1的毫秒数
System.out.println(System.currentTimeMillens());
Arrays类
Integer[] integers = {1, -4, 23, 12, 35};
//返回数组的字符串形式
System.out.println(Arrays.toString(integers));
//sort方法的使用，这个是从小到大排序
Arrays.sort(integers);
System.out.println(Arrays.toString(integers));
//sort方法在Arrays类中实现了重载，可以实现从大到小排序
// System.out.println(Arrays.toString(integers));
//binarySearch 通过二分搜索法进行查找，要求必须排好
//如果数组中不存在该元素，就返回 return -(low + 1);
System.out.println(Arrays.binarySearch(integers, 2));
//copyOf 数组元素的复制
//1. 从 arr 数组中，拷贝 arr.length 个元素到 newArr 数组中
// 2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
// 3. 如果拷贝长度 < 0 就抛出异常 NegativeArraySizeException
Integer[] integers1 = Arrays.copyOf(integers,3);
System.out.println("拷贝完成后：");
System.out.println(Arrays.toString(integers1));
//equals 比较两个数组元素内容是否完全一致
Integer[] integers2 = {-4, 1, 12, 23, 35};
System.out.println(Arrays.equals(integers,integers2));
//asList 将一组值，转换成 list
// asList 运行类型 java.util.Arrays$ArrayList
List integers3 = Arrays.asList(1, 23, 4, 5, 6);
System.out.println(integers3);
System.out.println("integers3的运行类型是："+ integers3.getClass());
BigInteger类和BigDecimal类
应用场景：
1.BigInteger适合保存比较大的整型。
//在对BigInteger进行加减乘除时，需要使用对应的方法，不能直接使用+ ， -，*，
BigInteger BigNum1 = new BigInteger("1234567890123");
BigInteger BigNum2 = new BigInteger("123456789");
System.out.println(BigNum1.add(BigNum2));
System.out.println(BigNum1.subtract(BigNum2));
2.BigDecimal:适合保存精度更高的浮点型(小数)。
BigDecimal digDecimal1 = new BigDecimal("1234.234513243123123");
BigDecimal digDecimal2 = new BigDecimal("1.1");
System.out.println(digDecimal1.add(digDecimal2));
//使用除法时可能会抛出异常，如果除不尽的话会有异常，因此使用以下方法解决
//商的小数点后的位数和被除数保持一致
System.out.println(digDecimal1.divide(digDecimal2,BigDecimal.ROUND_CEILING));
