目录
1.包装类
1.1包装类的分类
1.1.1Integer面试
1.2为啥么要使用包装类
1.3包装类的使用场合
2.String
2.1字符串特性
2.2字符串的常用方法
2.3StringBuffer类
2.3.1细节
2.4 StringBuilder
2.5String、StringBuffer 和 StringBuilder 的比较
2.6 String、StringBuffer 和 StringBuilder 的选择
3.Math 类
4.Arrays 类
4.1练习
5.System类
6.BigInteger 和 BigDecimal 类
7.第三代日期类
7.1DateTimeFormatter 格式日期类
7.2Instant 时间戳
1.包装类
1.1包装类的分类
-
针对八种基本数据类型相对应的引用类型-包装类
-
有了类的特点,就可以调用类中的方法
-
基本数据类型 包装类 boolean Boolean char Character byte Byte short Short int Integer long Long float Float double Double
Byte,Short,Integer,Long,Float,Doule的父类为Number
1.1.1Integer面试
Integer i1=new Integer(127);
Integer i2=new Integer(127);
System.out.println(i1==i2);
-
针对八种基本数据类型相对应的引用类型-包装类
-
有了类的特点,就可以调用类中的方法
-
基本数据类型 包装类 boolean Boolean char Character byte Byte short Short int Integer long Long float Float double Double Byte,Short,Integer,Long,Float,Doule的父类为Number
1.1.1Integer面试
Integer i1=new Integer(127);
Integer i2=new Integer(127);
System.out.println(i1==i2);
注意:只要是new出来一定是不同的对象,所以不相等
Integer i1=127; Integer i2=127; System.out.println(i1==i2);
注意:在-128~127之间底层为Integer.valueOf();不在这个区间就是为new出来的,故此,这个为真
Integer i1=127; Integer i2=new Integer(127); System.out.println(i1==i2);
注意:上面这个是从数组里面取的,但是下面的是new了一个新对象,故此为假
Integer i1=127; int i2=127; System.out.println(i1==i2);
注意:只要有基本数据类型,判断的是值是否相等,真
1.2为啥么要使用包装类
-
在某些场合不能使用 基本数据类的必须使用包装类
比如集合能接受的类型为Object,基本类型是无法添加进去的,还有泛型也必须使用包装类
-
包装类可以为null值,基本类型不能
假设我们要定义一个变量表示分数,如果用基本类型表示的话:int score;默认值为零,如果我想表示分数为空也就是没有参加考试就没办法表现了因为值类型是无法赋空值的,如果使用包装类到Integer score,就可以表示这种情况,因为Integer的默认值为空。
-
包装类是引用类型,里面有一些有用的属性和方法
它里面有那些属性和方法那?每个包装类型和基本数据类型都是大同小异,我们拿Integer和int举例说明:
假设有这样一个场景,我接收到一个String类型的数据想把它转化为整型,如果没有这个包装类这个操作是无法完成的,有了包装类我们可以这样做:
String num1="123";
int num2=Integer.parseInt(num1);
parseInt就是Integer包装类提供的一个将字符转化成int类型的方法
除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型
-
包装类还有一个很重要的特性就是数据缓存:
还是那Integer来举例,在-128~127区间的数都会被缓存,当类加载的时候就创建这256个数对应的对象,并放到名为cache的数组中,调用valueOf()方法是会先判断是否在-128~127的区间,如果在则直接获取数组中该对象的引用,如果不在则创建该对象。
1.3包装类的使用场合
-
控制器中的参数
如果在控制器中接收一个参数该参数定义成了基本数据类型int,那么传过来的参数如果为空则会报空指针错误,如果定义为其包装类型Integer则不会报错,而得到一个null值。所有在RPC方法里面参数和返回值类型都需要用包装类。
-
pojo(实体)类的属性
实体类中如果定义基本类型,数据库中对应的字段为空的时候映射时会出问题。因为基本类型不能赋null。所以在实体类中数据类型都需要定义成包装类。
如果是局部变量我们一般定义成基本类型,因为基本类型存储在栈上,方法执行完毕,栈上的内存空间也随之释放
2.String
2.1字符串特性
-
String是一个final类,代表不可变的字符序列
-
字符串是不可变的。一个字符串对象一旦被分配,其内容是不可变的
String s1="hello";
s1="world";
注意:输出的结果虽然是world,但是这个还是创建了两个对象,只是指针的指向了第二个值所在的地址
-
String s1="hello"+"world";
注意:这种就是创建了一个对象,编译器做了一个优化判断创建的常量池对象,是否有引用指向
String s1="helloworld"
-
String s1="hello";
s2="world";
String s3=S1+S2;
这个就有三个对象,但是s3的底层是
StringBuilder sb = new StringBuilder();
sb.append(a);
sb.append(b);
sb是在堆中,并且append是在原来字符串的基础上追加的。
重要规则:String c1="ab"+"cd";常量相加,看的是池,String c1=a+b;变量相加,是在堆中
2.2字符串的常用方法
在某些场合不能使用 基本数据类的必须使用包装类
比如集合能接受的类型为Object,基本类型是无法添加进去的,还有泛型也必须使用包装类
包装类可以为null值,基本类型不能
假设我们要定义一个变量表示分数,如果用基本类型表示的话:int score;默认值为零,如果我想表示分数为空也就是没有参加考试就没办法表现了因为值类型是无法赋空值的,如果使用包装类到Integer score,就可以表示这种情况,因为Integer的默认值为空。
包装类是引用类型,里面有一些有用的属性和方法
它里面有那些属性和方法那?每个包装类型和基本数据类型都是大同小异,我们拿Integer和int举例说明:
假设有这样一个场景,我接收到一个String类型的数据想把它转化为整型,如果没有这个包装类这个操作是无法完成的,有了包装类我们可以这样做:
String num1="123"; int num2=Integer.parseInt(num1);
parseInt就是Integer包装类提供的一个将字符转化成int类型的方法
除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型
包装类还有一个很重要的特性就是数据缓存:
还是那Integer来举例,在-128~127区间的数都会被缓存,当类加载的时候就创建这256个数对应的对象,并放到名为cache的数组中,调用valueOf()方法是会先判断是否在-128~127的区间,如果在则直接获取数组中该对象的引用,如果不在则创建该对象。
-
控制器中的参数
如果在控制器中接收一个参数该参数定义成了基本数据类型int,那么传过来的参数如果为空则会报空指针错误,如果定义为其包装类型Integer则不会报错,而得到一个null值。所有在RPC方法里面参数和返回值类型都需要用包装类。
-
pojo(实体)类的属性
实体类中如果定义基本类型,数据库中对应的字段为空的时候映射时会出问题。因为基本类型不能赋null。所以在实体类中数据类型都需要定义成包装类。
如果是局部变量我们一般定义成基本类型,因为基本类型存储在栈上,方法执行完毕,栈上的内存空间也随之释放
2.String
2.1字符串特性
-
String是一个final类,代表不可变的字符序列
-
字符串是不可变的。一个字符串对象一旦被分配,其内容是不可变的
String s1="hello";
s1="world";
注意:输出的结果虽然是world,但是这个还是创建了两个对象,只是指针的指向了第二个值所在的地址
-
String s1="hello"+"world";
注意:这种就是创建了一个对象,编译器做了一个优化判断创建的常量池对象,是否有引用指向
String s1="helloworld"
-
String s1="hello";
s2="world";
String s3=S1+S2;
这个就有三个对象,但是s3的底层是
StringBuilder sb = new StringBuilder();
sb.append(a);
sb.append(b);
sb是在堆中,并且append是在原来字符串的基础上追加的。
重要规则:String c1="ab"+"cd";常量相加,看的是池,String c1=a+b;变量相加,是在堆中
2.2字符串的常用方法
-
String是一个final类,代表不可变的字符序列
-
字符串是不可变的。一个字符串对象一旦被分配,其内容是不可变的
String s1="hello"; s1="world";
注意:输出的结果虽然是world,但是这个还是创建了两个对象,只是指针的指向了第二个值所在的地址
-
String s1="hello"+"world";
注意:这种就是创建了一个对象,编译器做了一个优化判断创建的常量池对象,是否有引用指向
String s1="helloworld"
-
String s1="hello"; s2="world"; String s3=S1+S2;
这个就有三个对象,但是s3的底层是
StringBuilder sb = new StringBuilder(); sb.append(a); sb.append(b);
sb是在堆中,并且append是在原来字符串的基础上追加的。
重要规则:String c1="ab"+"cd";常量相加,看的是池,String c1=a+b;变量相加,是在堆中
2.2字符串的常用方法
String类是保存字符串常量的。每次更新都需要重新开辟空间,效率较低,因此Java设计者提供了StringBuilder和StringBuffer来增强String的功能,并且提高效率。
public class Test{
public static void print(String s){
System.out.println(s);
}
//String builder
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder("String");//初始化StringBuilder对象
print("初始化对象:"+stringBuilder);//String
stringBuilder.append("Builder");//添加Builder到初始化的对象中
print("添加Builder后:"+stringBuilder);//StringBuilder
stringBuilder.reverse();//反转初始化的对象
print("反转字符串后为:"+stringBuilder);//redliuBgnirtS
stringBuilder.reverse();//反转回来
stringBuilder.delete(1, 3);//删除索引为[1,3)的内容
print("删除索引1到2的元素:"+stringBuilder);//SingBuilder
stringBuilder.insert(1, 432123);//将整数432123添加在索引为1的位置
print("将数字432123添加到从索引为1的位置开始添加:"+stringBuilder);//Si4323ngBuilder
stringBuilder.replace(1, 7, "tr");//将[1,7)索引的内容替换为tr
print("替换索引1到7的内容为tr:"+stringBuilder);//StringBuilder
System.out.println("i第一次出现在索引为:"+stringBuilder.indexOf("i")+"的位置");//返回第一次出现i时的索引值
System.out.println("i在索引为5的位置之后第一次出现在索引为:"+stringBuilder.indexOf("i", 5)+"的位置");//从索引为5的字符后开始查找i的位置
System.out.println("字符串的长度为:"+stringBuilder.length());//返回字符串长度
System.out.println("字符串索引为4的元素为:"+stringBuilder.charAt(4));//返回字符串中索引值为4的字符
System.out.println("从索引为5的元素后开始打印:"+stringBuilder.substring(5));//从索引为5开始打印后边的子字符串
System.out.println("从索引为3的位置打印到索引为5的位置:"+stringBuilder.substring(3, 6));//打印索引为[3,6)的子字符串
System.out.println("将初始化对象以字符串形式打印:"+stringBuilder.toString());//将初始化对象以字符串形式打印
}
}
2.3StringBuffer类
2.3.1细节
-
java.lang.StringBuffer代表可变的字符序列,可以堆字符串进行增删
-
很多方法与String相同,但StringBuffer是可变长度的
-
StringBuffer是一个容器
-
StringBuffer的直接父类是AbstactStringBuilder
-
StringBuffer实现了Serializable,即StringBuffer的对象可以串行化
-
在父类中AbstactStringBuilder有属性char [] value,不是final,该value数组存放字符串内容,引出存放在堆中
-
StringBuffer是一个final类,不能被继承
-
因为StringBuffer字符内容是存在char [] value,所以在变化(增加/删除),不用每次都更换地址(即不是每次创建新对象),所有效率高于String
2.4 StringBuilder
-
StringBubilder继承AbstactStringBuilder类
-
实现了Serializable,说明StringBuilder对对象是可以串行化(对象可以网络传输,可以保存到文件)
-
StringBuilder对象字符序列仍然是存放在其父类AbstactStringBuilder的char[] value;因此字符序列是在堆中
-
StringBuilder是final类,不能被继承
-
StringBuilder的方法,没有做互斥的处理,即没有synchronized关键字,因此在单线程的情况下使用StringBuilder
2.5String、StringBuffer 和 StringBuilder 的比较
-
StringBuilder和StringBuffer非常相似,均代表可变的字符序列,而且方法也一样
-
String:不可变字符序列,效率低,但是复用率高
-
StringBuffer:可变字符序列,效率较高(增删),线程安全
-
StringBuilder:可变序列,效率最高,线程不安全
-
String使用注意说明:
String s ="a";//创建了一个字符串
s + = "b";//实际上原来的"a"字符串已经丢弃了,现在又产生了一个字符串s + "b"(也就是"ab")。如果多次操作这次额改变串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响查询的性能
结论:如果我们对String做大量修改,不要使用String
2.6 String、StringBuffer 和 StringBuilder 的选择
-
java.lang.StringBuffer代表可变的字符序列,可以堆字符串进行增删
-
很多方法与String相同,但StringBuffer是可变长度的
-
StringBuffer是一个容器
-
StringBuffer的直接父类是AbstactStringBuilder
-
StringBuffer实现了Serializable,即StringBuffer的对象可以串行化
-
在父类中AbstactStringBuilder有属性char [] value,不是final,该value数组存放字符串内容,引出存放在堆中
-
StringBuffer是一个final类,不能被继承
-
因为StringBuffer字符内容是存在char [] value,所以在变化(增加/删除),不用每次都更换地址(即不是每次创建新对象),所有效率高于String
2.4 StringBuilder
-
StringBubilder继承AbstactStringBuilder类
-
实现了Serializable,说明StringBuilder对对象是可以串行化(对象可以网络传输,可以保存到文件)
-
StringBuilder对象字符序列仍然是存放在其父类AbstactStringBuilder的char[] value;因此字符序列是在堆中
-
StringBuilder是final类,不能被继承
-
StringBuilder的方法,没有做互斥的处理,即没有synchronized关键字,因此在单线程的情况下使用StringBuilder
2.5String、StringBuffer 和 StringBuilder 的比较
-
StringBuilder和StringBuffer非常相似,均代表可变的字符序列,而且方法也一样
-
String:不可变字符序列,效率低,但是复用率高
-
StringBuffer:可变字符序列,效率较高(增删),线程安全
-
StringBuilder:可变序列,效率最高,线程不安全
-
String使用注意说明:
String s ="a";//创建了一个字符串
s + = "b";//实际上原来的"a"字符串已经丢弃了,现在又产生了一个字符串s + "b"(也就是"ab")。如果多次操作这次额改变串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响查询的性能
结论:如果我们对String做大量修改,不要使用String
2.6 String、StringBuffer 和 StringBuilder 的选择
StringBubilder继承AbstactStringBuilder类
实现了Serializable,说明StringBuilder对对象是可以串行化(对象可以网络传输,可以保存到文件)
StringBuilder对象字符序列仍然是存放在其父类AbstactStringBuilder的char[] value;因此字符序列是在堆中
StringBuilder是final类,不能被继承
StringBuilder的方法,没有做互斥的处理,即没有synchronized关键字,因此在单线程的情况下使用StringBuilder
-
StringBuilder和StringBuffer非常相似,均代表可变的字符序列,而且方法也一样
-
String:不可变字符序列,效率低,但是复用率高
-
StringBuffer:可变字符序列,效率较高(增删),线程安全
-
StringBuilder:可变序列,效率最高,线程不安全
-
String使用注意说明:
String s ="a";//创建了一个字符串 s + = "b";//实际上原来的"a"字符串已经丢弃了,现在又产生了一个字符串s + "b"(也就是"ab")。如果多次操作这次额改变串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响查询的性能
结论:如果我们对String做大量修改,不要使用String
2.6 String、StringBuffer 和 StringBuilder 的选择
使用的原则,结论:
-
如果字符串存在大量的修改操作,一般使用StringBuffer或StringBuilder
-
如果字符串存在大量的修改操作,并在单线程的情况,使用StringBuilder
-
如果字符串存在大量的修改操作,并在多线程的情况下,使用StringBuffer
-
如果我们字符串很少修改,被多个对下个引用,使用String,比如配置信息等
StringBuilder和StringBuffer的方法使用是一样的
3.Math 类
public class MathMethod {
public static void main(String[] args) {
//看看Math常用的方法(静态方法)
//1.abs 绝对值
int abs = Math.abs(-9);
System.out.println(abs);//9
//2.pow 求幂
double pow = Math.pow(2, 4);//2的4次方
System.out.println(pow);//16
//3.ceil 向上取整,返回>=该参数的最小整数(转成double);
double ceil = Math.ceil(3.9);
System.out.println(ceil);//4.0
//4.floor 向下取整,返回<=该参数的最大整数(转成double)
double floor = Math.floor(4.001);
System.out.println(floor);//4.0
//5.round 四舍五入 Math.floor(该参数+0.5)
long round = Math.round(5.51);
System.out.println(round);//6
//6.sqrt 求开方
double sqrt = Math.sqrt(9.0);
System.out.println(sqrt);//3.0
//7.random 求随机数
// random 返回的是 0 <= x < 1 之间的一个随机小数
// 思考:请写出获取 a-b之间的一个随机整数,a,b均为整数 ,比如 a = 2, b=7
// 即返回一个数 x 2 <= x <= 7
// 老韩解读 Math.random() * (b-a) 返回的就是 0 <= 数 <= b-a
// (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
// (2) 使用具体的数给小伙伴介绍 a = 2 b = 7
// (int)(a + Math.random() * (b-a +1) ) = (int)( 2 + Math.random()*6)
// Math.random()*6 返回的是 0 <= x < 6 小数
// 2 + Math.random()*6 返回的就是 2<= x < 8 小数
// (int)(2 + Math.random()*6) = 2 <= x <= 7
// (3) 公式就是 (int)(a + Math.random() * (b-a +1) )
for(int i = 0; i < 100; i++) {
System.out.println((int)(2 + Math.random() * (7 - 2 + 1)));
}
//max , min 返回最大值和最小值
int min = Math.min(1, 9);
int max = Math.max(45, 90);
System.out.println("min=" + min);
System.out.println("max=" + max);
}
}
4.Arrays 类
-
toString返回数组的字符串形式
Arrays.toString(arr);
-
sort排序(自然排序和定制排序)
-
binarySearch通过二分搜索法进行查找,要求必须排好序
int index=Arrays.binarySearch(arr,3);
-
copyOf数组元素的复制
Integer[] newArr=Arrays.copyOf(arr,arr.length);
-
fill数组元素的填充
Integer[] num=new Integer[9,3,2]{};
Arrays.fill(num,99); -
equals比较凉饿数组元素内容是否一致
boolean equals_=Arrays.equals(arr,arr2);
-
asList将一组值,转换成list
List asList_=Arrays.asList(2,3,4,6,1);
4.1练习
public static void main(String[] args) {
Integer[] arr = {1, 2, 90, 123, 567};
// binarySearch 通过二分搜索法进行查找,要求必须排好
//1. 使用 binarySearch 二叉查找
//2. 要求该数组是有序的. 如果该数组是无序的,不能使用binarySearch
//3. 如果数组中不存在该元素,就返回 return -(low + 1); // key not found.
int index = Arrays.binarySearch(arr, 567);
System.out.println("index=" + index);
//copyOf 数组元素的复制
//1. 从 arr 数组中,拷贝 arr.length个元素到 newArr数组中
//2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
//3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
//4. 该方法的底层使用的是 System.arraycopy()
Integer[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("==拷贝执行完毕后==");
System.out.println(Arrays.toString(newArr));
//ill 数组元素的填充
Integer[] num = new Integer[]{9,3,2};
//1. 使用 99 去填充 num数组,可以理解成是替换原理的元素
Arrays.fill(num, 99);
System.out.println("==num数组填充后==");
System.out.println(Arrays.toString(num));
//equals 比较两个数组元素内容是否完全一致
Integer[] arr2 = {1, 2, 90, 123};
//1. 如果arr 和 arr2 数组的元素一样,则方法true;
//2. 如果不是完全一样,就返回 false
boolean equals = Arrays.equals(arr, arr2);
System.out.println("equals=" + equals);
//asList 将一组值,转换成list
//1. asList方法,会将 (2,3,4,5,6,1)数据转成一个List集合
//2. 返回的 asList 编译类型 List(接口)
//3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的
// 静态内部类 private static class ArrayList extends AbstractList
// implements RandomAccess, java.io.Serializable
List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println("asList=" + asList);
System.out.println("asList的运行类型" + asList.getClass());
}
5.System类
-
exit退出当前程序
-
arraycopy:复制数组元素,比较适合底层调用,一般使用Arrays.copyOf完成复制数组
//arraycopy :复制数组元素,比较适合底层调用,
// 一般使用Arrays.copyOf完成复制数组
int[] src={1,2,3};
int[] dest = new int[3];// dest 当前是 {0,0,0}
//1. 主要是搞清楚这五个参数的含义
//2.
// 源数组
// * @param src the source array.
// srcPos: 从源数组的哪个索引位置开始拷贝
// * @param srcPos starting position in the source array.
// dest : 目标数组,即把源数组的数据拷贝到哪个数组
// * @param dest the destination array.
// destPos: 把源数组的数据拷贝到 目标数组的哪个索引
// * @param destPos starting position in the destination data.
// length: 从源数组拷贝多少个数据到目标数组
// * @param length the number of array elements to be copied.
System.arraycopy(src, 0, dest, 0, src.length);
// int[] src={1,2,3};
System.out.println("dest=" + Arrays.toString(dest));//[1, 2, 3] -
currentTimeMillens:返回当前时间距离 1970-1-1 的毫秒数
-
gc:运行垃圾回收机制
System.gc();
6.BigInteger 和 BigDecimal 类
-
toString返回数组的字符串形式
Arrays.toString(arr);
-
sort排序(自然排序和定制排序)
-
binarySearch通过二分搜索法进行查找,要求必须排好序
int index=Arrays.binarySearch(arr,3);
-
copyOf数组元素的复制
Integer[] newArr=Arrays.copyOf(arr,arr.length);
-
fill数组元素的填充
Integer[] num=new Integer[9,3,2]{}; Arrays.fill(num,99); -
equals比较凉饿数组元素内容是否一致
boolean equals_=Arrays.equals(arr,arr2);
-
asList将一组值,转换成list
List
asList_=Arrays.asList(2,3,4,6,1);
4.1练习
public static void main(String[] args) {
Integer[] arr = {1, 2, 90, 123, 567};
// binarySearch 通过二分搜索法进行查找,要求必须排好
//1. 使用 binarySearch 二叉查找
//2. 要求该数组是有序的. 如果该数组是无序的,不能使用binarySearch
//3. 如果数组中不存在该元素,就返回 return -(low + 1); // key not found.
int index = Arrays.binarySearch(arr, 567);
System.out.println("index=" + index);
//copyOf 数组元素的复制
//1. 从 arr 数组中,拷贝 arr.length个元素到 newArr数组中
//2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
//3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
//4. 该方法的底层使用的是 System.arraycopy()
Integer[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("==拷贝执行完毕后==");
System.out.println(Arrays.toString(newArr));
//ill 数组元素的填充
Integer[] num = new Integer[]{9,3,2};
//1. 使用 99 去填充 num数组,可以理解成是替换原理的元素
Arrays.fill(num, 99);
System.out.println("==num数组填充后==");
System.out.println(Arrays.toString(num));
//equals 比较两个数组元素内容是否完全一致
Integer[] arr2 = {1, 2, 90, 123};
//1. 如果arr 和 arr2 数组的元素一样,则方法true;
//2. 如果不是完全一样,就返回 false
boolean equals = Arrays.equals(arr, arr2);
System.out.println("equals=" + equals);
//asList 将一组值,转换成list
//1. asList方法,会将 (2,3,4,5,6,1)数据转成一个List集合
//2. 返回的 asList 编译类型 List(接口)
//3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的
// 静态内部类 private static class ArrayList extends AbstractList
// implements RandomAccess, java.io.Serializable
List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println("asList=" + asList);
System.out.println("asList的运行类型" + asList.getClass());
}
5.System类
-
exit退出当前程序
-
arraycopy:复制数组元素,比较适合底层调用,一般使用Arrays.copyOf完成复制数组
//arraycopy :复制数组元素,比较适合底层调用,
// 一般使用Arrays.copyOf完成复制数组
int[] src={1,2,3};
int[] dest = new int[3];// dest 当前是 {0,0,0}
//1. 主要是搞清楚这五个参数的含义
//2.
// 源数组
// * @param src the source array.
// srcPos: 从源数组的哪个索引位置开始拷贝
// * @param srcPos starting position in the source array.
// dest : 目标数组,即把源数组的数据拷贝到哪个数组
// * @param dest the destination array.
// destPos: 把源数组的数据拷贝到 目标数组的哪个索引
// * @param destPos starting position in the destination data.
// length: 从源数组拷贝多少个数据到目标数组
// * @param length the number of array elements to be copied.
System.arraycopy(src, 0, dest, 0, src.length);
// int[] src={1,2,3};
System.out.println("dest=" + Arrays.toString(dest));//[1, 2, 3] -
currentTimeMillens:返回当前时间距离 1970-1-1 的毫秒数
-
gc:运行垃圾回收机制
System.gc();
6.BigInteger 和 BigDecimal 类
-
exit退出当前程序
-
arraycopy:复制数组元素,比较适合底层调用,一般使用Arrays.copyOf完成复制数组
//arraycopy :复制数组元素,比较适合底层调用, // 一般使用Arrays.copyOf完成复制数组 int[] src={1,2,3}; int[] dest = new int[3];// dest 当前是 {0,0,0} //1. 主要是搞清楚这五个参数的含义 //2. // 源数组 // * @param src the source array. // srcPos: 从源数组的哪个索引位置开始拷贝 // * @param srcPos starting position in the source array. // dest : 目标数组,即把源数组的数据拷贝到哪个数组 // * @param dest the destination array. // destPos: 把源数组的数据拷贝到 目标数组的哪个索引 // * @param destPos starting position in the destination data. // length: 从源数组拷贝多少个数据到目标数组 // * @param length the number of array elements to be copied. System.arraycopy(src, 0, dest, 0, src.length); // int[] src={1,2,3}; System.out.println("dest=" + Arrays.toString(dest));//[1, 2, 3] -
currentTimeMillens:返回当前时间距离 1970-1-1 的毫秒数
-
gc:运行垃圾回收机制
System.gc();
6.BigInteger 和 BigDecimal 类
BigInteger适合保存比较大的整数
public static void main(String[] args) {
//当我们编程中,需要处理很大的整数,long 不够用
//可以使用BigInteger的类来搞定
// long l = 23788888899999999999999999999l;
// System.out.println("l=" + l);
BigInteger bigInteger = new BigInteger("23788888899999999999999999999");
BigInteger bigInteger2 = new BigInteger("10099999999999999999999999999999999999999999999999999999999999999999999999999999999");
System.out.println(bigInteger);
//1. 在对 BigInteger 进行加减乘除的时候,需要使用对应的方法,不能直接进行 + - * /
//2. 可以创建一个 要操作的 BigInteger 然后进行相应操作
BigInteger add = bigInteger.add(bigInteger2);
System.out.println(add);//
BigInteger subtract = bigInteger.subtract(bigInteger2);
System.out.println(subtract);//减
BigInteger multiply = bigInteger.multiply(bigInteger2);
System.out.println(multiply);//乘
BigInteger divide = bigInteger.divide(bigInteger2);
System.out.println(divide);//除
}
BigDecimal适合保存精度更高的浮点数(小数)
public static void main(String[] args) {
//当我们需要保存一个精度很高的数时,double 不够用
//可以是 BigDecimal
// double d = 1999.11111111111999999999999977788d;
// System.out.println(d);
BigDecimal bigDecimal = new BigDecimal("1999.11");
BigDecimal bigDecimal2 = new BigDecimal("3");
System.out.println(bigDecimal);
//1. 如果对 BigDecimal进行运算,比如加减乘除,需要使用对应的方法
//2. 创建一个需要操作的 BigDecimal 然后调用相应的方法即可
System.out.println(bigDecimal.add(bigDecimal2));
System.out.println(bigDecimal.subtract(bigDecimal2));
System.out.println(bigDecimal.multiply(bigDecimal2));
//System.out.println(bigDecimal.divide(bigDecimal2));//可能抛出异常ArithmeticException
//在调用divide 方法时,指定精度即可. BigDecimal.ROUND_CEILING
//如果有无限循环小数,就会保留 分子 的精度
System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
}
7.第三代日期类
public static void main(String[] args) {
//第三代日期
//1. 使用now() 返回表示当前日期时间的 对象
LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now();//LocalTime.now()
System.out.println(ldt);
//2. 使用DateTimeFormatter 对象来进行格式化
// 创建 DateTimeFormatter对象
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = dateTimeFormatter.format(ldt);
System.out.println("格式化的日期=" + format);
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());
LocalDate now = LocalDate.now(); //可以获取年月日
LocalTime now2 = LocalTime.now();//获取到时分秒
//提供 plus 和 minus方法可以对当前时间进行加或者减
//看看890天后,是什么时候 把 年月日-时分秒
LocalDateTime localDateTime = ldt.plusDays(890);
System.out.println("890天后=" + dateTimeFormatter.format(localDateTime));
//看看在 3456分钟前是什么时候,把 年月日-时分秒输出
LocalDateTime localDateTime2 = ldt.minusMinutes(3456);
System.out.println("3456分钟前 日期=" + dateTimeFormatter.format(localDateTime2));
}
7.1DateTimeFormatter 格式日期类
//使用 DateTimeFormatter 对象来进行格式化
// 创建 DateTimeFormatter 对象
DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = dateTimeFormatter.format(ldt);
System.out.println("格式化的日期=" + format)
7.2Instant 时间戳
//使用 DateTimeFormatter 对象来进行格式化
// 创建 DateTimeFormatter 对象
DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = dateTimeFormatter.format(ldt);
System.out.println("格式化的日期=" + format)
7.2Instant 时间戳
类似于Date
提供了一系列和D阿特类转换的方式
lic class Instant_ {
public static void main(String[] args) {
//1.通过 静态方法 now() 获取表示当前时间戳的对象
Instant now = Instant.now();
System.out.println(now);
//2. 通过 from 可以把 Instant转成 Date
Date date = Date.from(now);
//3. 通过 date的toInstant() 可以把 date 转成Instant对象
Instant instant = date.toInstant();
}



