常用类
包装类
- 包装类分类 WrapperType.java
- 针对八种基本数据类型定义相应的引用类型-包装类
- 有了类的特点，就可以调用类中的方法
- 除了Boolean和Character，其他六个的父类都是Number
| 基本数据类型 | 包装类 |
|---|---|
| boolean | Boolean |
| char | Character |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
- 包装类和基本数据的转换
- jdk5前的手动装箱和拆箱方式，装箱：基本类型->包装类型，反之，拆箱
- jdk5以后(含jdk5)的自动装箱和拆箱方式
- 自动装箱底层调用的是valueOf方法
public static void main(String[] args) {
//int<-->Integer的装箱和拆箱
//手动装箱int->Integer
int n1=100;
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);
//手动拆箱Integer->int
int i=integer.intValue();
//jdk5后，就可以自动装箱和拆箱
//自动装箱int->Integer
int n2=200;
Integer integer2=n2;//底层使用的是Integer.valuOf(n2)
//自动拆箱Integer->int
int i1=integer2;//底层仍然使用的是intValue()方法
}
- 包装类型和String类型的相互转换
public static void main(String[] args) {
//包装类(Integer)->String
Integer i=100;//自动装箱
//方式1
String str1=i+"";
//方式2
String str2 = i.toString();
//方式3
String str3 = String.valueOf(i);
//String->包装类(Integer)
String str="12345";
int i1 = Integer.parseInt(str);//使用到自动装箱
Integer i2 = new Integer(str);//构造器
}
- Integer创建机制：
- 如果i在(-128~127),就直接从数组返回
- 如果不在(-128~127),就直接new Integer(i)
String类
-
String类的理解和创建对象
- String对象用于保存字符串，也就是一组字符序列
- 字符串常量对象是用双引号括起的字符序列。例：“12”，“你好”，"boy"等
- 字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节
- String类较常用构造方法
- String类实现了接口Serializable[String可以串行化：可以在网络传输]
- String类实现了接口Comparable[String对象可以比较大小]
- String有属性private final char value[]; 用于存放字符串内容
- 一定要注意：value是一个final类型，不可以修改(不能指向新的地址，但是单个字符内容是可以变化)
-
两种创建String对象的区别
-
方式一：直接赋值String s=“aw”;
-
方式二：调用构造器String s2=new String(“aw”);
- 方式一：先从常量池查看是否有“aw”数据空间，如果有，直接指向；如果没有则呈现创建，然后指向。s最终指向的是常量池的空间地址
- 方式二：先在堆中创建空间，里面维护了value属性，指向常量池的aw空间。如果常量池没有“aw”，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址。
-
字符串的特性
- String是一个final类，代表不可变的字符序列
- 字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的。
public static void main(String[] args) {
String a="Hello";
String b="abc";
//1.先创建一个StringBuilder sb=new StringBuilder();
//2.执行 sb.append("Hello");
//3. sb.append("abc");
//4.String c=sb.toString
//最后其实是c指向堆中的对象(String)value[]->池中“helloabc”
String c=a+b;
}
底层是StringBuilder sb=new StringBuilder();sb.append(a); sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的。
重要规则：String c1=“ab”+“cd”;常量相加，看的是池。String c1=a+b;变量相加，是在堆中。
String类常见方法
- String类的常见方法一览
- equals//区分大小写，判断内容是否相等
- equalsIgnoreCase//忽略大小写的判断内容是否相等
- length//获取字符的个数，字符串份长度
- indexOf//获取字符串在字符串中第一次出现的索引，索引从0开始，如果找不到，返回-1
- lastIndexOf//获取字符串在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1
- substring//截取指定范围的字符串
- trim//去前后空格
- charAt：获取某索引处的字符，注意不能使用Str[index]这种方式
- toUpperCase：转换成大写
- toLowerCase：转换成小写
- concat//拼接字符串
- replace//替换字符串中份字符
- split//分割字符串，对于某些分割字符，我们需要转义 | \ \等
- compareTo//比较两个字符串的大小
- toCharArray//转换成字符数组
- format//格式字符串，%s字符串，%c字符，%d整型，%.2f浮点型
//- equals//区分大小写，判断内容是否相等
String a="java";
System.out.println("java".equals(a));
//- equalsIgnoreCase//忽略大小写的判断内容是否相等
String b="xml";
System.out.println("XML".equalsIgnoreCase(b));
//- length//获取字符的个数，字符串份长度
System.out.println("money".length());
//- indexOf//获取字符串在字符串中第一次出现的索引，索引从0开始，如果找不到，返回-1
String s1="wyw@terwe@g";
int index = s1.indexOf("@");
System.out.println(index);
//- lastIndexOf//获取字符串在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1
index = s1.lastIndexOf("@");
System.out.println(index);
//- substring//截取指定范围的字符串
String name="hello,张三";
System.out.println(name.substring(6));//截取后面的字符
System.out.println(name.substring(0,5));//截取0到5前一个的
//- toUpperCase：转换成大写
System.out.println(name.toUpperCase());
//- toLowerCase：转换成小写
System.out.println(name.toLowerCase());
//- concat//拼接字符串
a="浊心";
String c = a.concat("斯卡蒂");
System.out.println(c);
//- replace//替换字符串中份字符
String li = name.replace("张三", "李四");
System.out.println(li);
//- split//分割字符串，对于某些分割字符，我们需要转义 | \ \等
String poem="锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦";
String[] split = poem.split("，");
//1以，为标准对poem进行分割，返回一个数组
//2在对字符串进行分割时，如果有特殊字符，需要加入转义符\
poem="E：\\aaa\\bbb";
split=poem.split("\\\\");
for (String s : split) {
System.out.println(s);
}
//- compareTo//比较两个字符串的大小,如果前者大，
//则返回正数，后者大在，则返回负数，如果相等，返回0
//（1）如果长度相同，并且每个字符也相同，就返回0
//（2）如果长度相同或者不相同，但是在进行比较时，可以区分大小就返回
//if(c1!=c2){
// return c1-c2;
// }
//(3)如果前面的部分都相同，就返回str1.Len-str2.Len
a="jc";
b="jack";
System.out.println(a.compareTo(b));//返回值是c-a=2的值
//- toCharArray//转换成字符数组
a="happy";
char[] chars = a.toCharArray();
for (char aChar : chars) {
System.out.println(aChar);
}
//- format//格式字符串，%s字符串，%c字符，%d整型，%.2f浮点型
name="李四";
int age=10;
double score=98/3;
char gender='男';
String info="我们姓名是"+name+"年龄是"+age+"成绩是"+score+"性别是"+gender+"。希望大家喜欢我";
System.out.println(info);
//1%s,%d,%c,%.2f称为占位符
//2这些占位符由后面变量来替换
//3%s表示后面由字符串来替换
//4%d是整数来替换
//5%.2f表示使用小数来替换，替换后，只会保留小数点两位，并且进行四舍五入
//6%c使用字符char来替换
String formatStr="我的姓名是%s，年龄是%d,成绩是%.2f,性别是%c。希望大家喜欢我";
String info2=String.format(formatStr,name,age,score,gender);
System.out.println(info2);
StringBuffer类
- 说明
String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因此java设计者还提供了StringBuilder和StringBuffer来增强Sting的功能，并提高效率
- 基本介绍
- java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删
- 很多方法与String相同，但StringBuffer是可变长度的
- StringBuffer是一个容器
//1.StringBuffer的直接父类是 AbstractStringBuffer
//2.StringBuffer实现了Serializable，即StringBuffer的对象可以串行化
//3.在父类中，AbstractStringBuffer有属性 char[] value，不是final
//该 value 数组存放字符串内容，引出存放在堆中的
//4.StringBuffer是一个final类，不能被继承
//5.因为StringBuffer字符内容存放在char[] value，所有在变化(增加/删除)
//不用每次都更换地址(即不是每次创建新对象)，所以效率高于String
StringBuffer buffer = new StringBuffer();
-
String VS StringBuffer
- String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低//private final char value[];
- StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高//char[] value; //这个放在堆
-
StringBuffer构造器的使用
- 创建一个大小为16的char[]，用于存放字符内容
- 通过构造器指定char[] 大小
- 通过给一个String 创建StringBuffer
//构造器的使用
//1. 创建一个大小为16的char[]，用于存放字符内容
StringBuffer buffer = new StringBuffer();
//2. 通过构造器指定char[] 大小
StringBuffer buffer1 = new StringBuffer(100);
//3. 通过给一个String 创建StringBuffer
//这时候char[]的大小就是str.length()+16为21
StringBuffer hello = new StringBuffer("hello");
- String和StringBuffer相互转换
//String->StringBuffer
String str="hello zx";
//方式1 使用构造器
//注意：返回的才是StringBuffer对象，对str本身没有影响
StringBuffer buffer = new StringBuffer(str);
//方式2 使用的是append的方法
StringBuffer buffer1 = new StringBuffer();
buffer1.append(str);
//StringBuffer->String
StringBuffer buffer2 = new StringBuffer("歌蕾蒂娅");
//方式1 使用StringBuffer提供的toString方法
String string = buffer2.toString();
//方式2 使用构造器
String s = new String(buffer2);
StringBuffer类常见方法
- StringBuffer方法一览
- append:增
- delete:删
- replace(start,end,string)//将start—end间的内容替换掉，不含end
- index//查找字符在字符串第一次出现的索引，如果查不到返回-1
- insert:插
- length:长度
//1. append:增
StringBuffer s = new StringBuffer("hello");
s.append(",").append("凯尔希").append(100).append(true).append(10.5);
System.out.println(s);
//2. delete:删
s.delete(9,12);//删除11-14的字符[9,12)
System.out.println(s);
//3. replace(start,end,string)//将start---end间的内容替换掉，不含end
s.replace(6,9,"阿米娅");//替换6-9的字符[6,9)
System.out.println(s);
//4. indexOf//查找字符在字符串第一次出现的索引，如果查不到返回-1
int i = s.indexOf(String.valueOf(100));
System.out.println(i);
//5. insert:插
s.insert(9,"陈");//在索引为9的位置插入陈，true往后移
System.out.println(s);
//6. length:长度
System.out.println(s.length());
StringBuilder类
-
基本介绍
- StringBuilder是一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但不保证同步(不是线程安全)。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快。
- 在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。
-
StringBuilder常用方法
StringBuilder和StringBuffer均代表可变的字符序列，方法是一样的，所以使用和StringBuffer一样
//1.StringBuilder 继承 AbstractStringBuilder //2.实现了Serializable，即StringBuilder的对象可以串行化(该对象可以网络传输，可以保存到文件) //3.在父类中，AbstractStringBuilder有属性 char[] value，不是final //该 value 数组存放字符串内容，引出存放在堆中的 //4.StringBuilder是一个final类，不能被继承 //5.StringBuilder的方法，没有做互斥的处理，即没有synchronized关键字，因此在单线程的情况下使用 StringBuilder stringBuilder = new StringBuilder();
-
String、StringBuffer和StringBuilder的比较
- StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
- String:不可变字符序列，效率低，但是复用率高
- StringBuffer:可变字符序列，效率较高(增删)、线程安全
- StringBuilder:可变字符序列，效率最高、线程不安全
- String使用注意说明：
- string s=“a”;//创建了一个字符串
- s+=“b”;//实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+“b”(也就是"ab")。如果多次执行这些字符串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能=>结论:如果我们对字符串做大量修改，不要使用String
-
String、StringBuffer和StringBuilder的选择
- 如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder
- 如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder
- 如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer
- 如果我们字符串很少修改，被多个对象引用，使用String，比如配置信息等
Math类
- 基本介绍
Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
- Math常见方法
- abs:绝对值
- pow:求幂
- ceil:向上取整
- floor:向下取整
- round:四舍五入
- sqrt:求开方
- random:求随机数
- max:求两个数的最大值
- min:求两个数的最小值
//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);//6 //3. ceil:向上取整，返回>=该参数的最小整数(转成double) double ceil = Math.ceil(-3.0001); System.out.println(ceil);//-3.0 //4. floor:向下取整，返回<=该参数的最小整数(转成double) double floor = Math.floor(-4.999); System.out.println(floor);//-5.0 //5. round:四舍五入 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<=a<1之间的一个随机小数 //获取一个a-b之间的一个随机整数 //int num=(int)(a+Math.random()*(b-a+1)) //8. max:求两个数的最大值 int max = Math.max(1, 9); System.out.println(max);//9 //9. min:求两个数的最小值 int min = Math.min(1, 9); System.out.println(min);//1
Arrays类
- Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)
- toString:返回数组的字符串形式
- sort:排序(自然排序和定制排序)
- binarySearch:通过二分搜索法进行查找，要求必须排好序
- copyOf:数组元素的复制
- fill:数组元素的填充
- equals:比较两个数组元素的内容是否完全一致
- asList:将一组值，转换成list
Integer[] integers={1,20,90,7,60}; // toString:返回数组的字符串形式 System.out.println(Arrays.toString(integers)); // sort:排序(自然排序和定制排序) //1.可以直接使用冒泡排序，也可以直接使用Arrays提供的sort方法排序 //2.因为数组是引用类型，所以通过sort排序后，会直接影响到实参 //3.sort是重载的，也可以通过传入一个接口Comparator实现定制排序 //4.调用定制方法时，传入两个参数（1）排序的数组 // （2）实现了Comparator接口的匿名内部类，要求实现compare方法 //5.这里体现了接口编程的方式 Arrays.sort(integers);//默认排序方法 //定制排序 Arrays.sort(integers, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { Integer i1=(Integer) o1; Integer i2=(Integer) o2; return i2-i1; } }); System.out.println(Arrays.toString(integers)); // binarySearch:通过二分搜索法进行查找，要求必须排好序 //1.使用binarySearch二叉查找 //2.要求该数组是有序的，如果该数组是无序的，不能使用 //3.如果数组中不存在该元素，就返回-1 Integer[] arr={1,2,9,123,567}; int index = Arrays.binarySearch(arr, 9); System.out.println(index); // copyOf:数组元素的复制 //1.从arr数组中，拷贝arr.length个元素到newarr数组中 //2.如果拷贝的长度>arr.length就在新数组的后面增加null //3.如果拷贝长度<0就抛出异常 Integer[] newarr = Arrays.copyOf(arr, 6); System.out.println(Arrays.toString(newarr)); // fill:数组元素的填充 //使用99区填充newarr数组，可以理解成是替换原理的元素 Arrays.fill(newarr, 99); System.out.println(Arrays.toString(newarr)); // equals:比较两个数组元素的内容是否完全一致 //1.如果arr和newarr数组的元素一样，则返回true //2.如果不是完全一样就返回false boolean equals = Arrays.equals(arr, newarr); System.out.println(equals); // asList:将一组值，转换成list List<Integer> list = Arrays.asList(arr); System.out.println(list);
System类
- System类常见方法
- exit:退出当前程序
- arraycopy:复制数组元素，比较适合底层调用，一般使用
- currentTimeMillens:返回当前时间距离1970-1-1的毫秒数
- gc:运行垃圾回收机制
// exit:退出当前程序 System.out.println("ok1"); //1.exit(0)表示程序退出 //2.0表示一个状态，正常的状态 //3.0以外的整数表示非正常退出 //System.exit(0); System.out.println("ok2"); // arraycopy:复制数组元素，比较适合底层调用，一般使用 int[] src={1,2,3}; int[] dest=new int[3];//dest当前是{0,0,0} //第一个：源数组 //第二个：从原数组的哪个索引位置开始拷贝 //第三个：目标数组，即把源数组的数据拷贝到哪个数组 //第四个：把源数组的数据拷贝到目标数组的哪个索引 //第五个：从源数组拷贝多少个数据到目标数组 System.arraycopy(src,0,dest,0,3); System.out.println(Arrays.toString(dest)); // currentTimeMillens:返回当前时间距离1970-1-1的毫秒数 System.out.println(System.currentTimeMillis()); // gc:运行垃圾回收机制 System.gc();//主动调用垃圾回收器
BigInteger和BigDecimal类
-
BigInteger和BigDecimal介绍
- BigInteger适合保存比较大的整型
- BigDecimal适合保存精度更高的浮点型
-
BigInteger和BigDecimal常见方法
- add:加
- subtract:减
- multiply:乘
- divide:除
//当我们编程中，需要处理很大的整数，long不够用 //可以使用BigInteger的类来搞定 // long l=2378999999999999999l; //System.out.println(l); BigInteger bigInteger = new BigInteger("29999999999999999999999999999999999999999999999999"); System.out.println(bigInteger); //1.在堆BigInteger进行加减乘除的时候，需要使用对应的方法，不能+-*/ //2.可以创建一个要操作的BigInteger然后进行相应操作 //add:加 BigInteger bigInteger1 = new BigInteger("100"); BigInteger add = bigInteger.add(bigInteger1); System.out.println(add); // subtract:减 BigInteger subtract = bigInteger.subtract(BigInteger.valueOf(200)); System.out.println(subtract); // multiply:乘 BigInteger multiply = bigInteger.multiply(BigInteger.valueOf(30)); System.out.println(multiply); // divide:除 BigInteger divide = bigInteger.divide(BigInteger.valueOf(500)); System.out.println(divide);
//当我们编程中，需要保存一个精度很高的数时，double不够 //可以使用BigDecimal的类来搞定 // double d=199.13316186446156135131315311d; //System.out.println(d); BigDecimal bigDecimal = new BigDecimal("199.13316186446156135131315311"); System.out.println(bigDecimal); //1.如果对BigDecimal进行运算，比如加减乘除，需要使用对应的方法 //2.可以创建一个要操作的BigDecimal然后进行相应操作 //add:加 System.out.println(bigDecimal.add(BigDecimal.valueOf(100))); // subtract:减 System.out.println(bigDecimal.subtract(BigDecimal.valueOf(200))); // multiply:乘 System.out.println(bigDecimal.multiply(BigDecimal.valueOf(500))); // divide:除 //System.out.println(bigDecimal.divide(BigDecimal.valueOf(200)));//可能抛出异常AritimeticException //在调用divide方法时，指定精度即可。bigDecimal.ROUND_CEILING //如果有无限循环小数，就会保留分子的精度 System.out.println(bigDecimal.divide(BigDecimal.valueOf(200),bigDecimal.ROUND_CEILING));
日期类
- 第一代日期类
- Date:精确到毫秒，代表特定的瞬间
- SimpleDateFormat:格式和解析日期的类。它允许进行格式化(日期->文本->)、解析(文本->日期)和规范化
//1.获取当前系统时间 //2.这里的Date类是在java.util包 //3.默认输出的日期格式是国外的方式，因此通常需要对格式进行转换 Date date = new Date(); System.out.println(date); Date date1 = new Date(912345678);//通过指定毫秒数得到时间 System.out.println(date1);//获取某个时间对应的毫秒数 //1.创建SimpleDateFormat对象，可以指定相应的格式 //2.这里的格式使用的字母是规定好的，不能乱写 SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E"); String time = format.format(date);//format：将日期转换成指定格式的字符串 System.out.println(time); //可以把一个格式化的String转成对应的Date //2.得到Date仍然是按照国外的格式，如果希望zhid格式输出，需要转换 //3.在把String->Date，使用format格式需要和你给的String的格式一样，否则会抛出转换异常 String s="2021年01月01日 10:30:50 星期一"; Date parse = format.parse(s); System.out.println(format.format(parse));
- 第二代日期类
- 第二代日期类，主要就是Calendar类(日历)
- Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段(例如获取下星期的日期)提供了一些方法
//1.Calendar是一个抽象类，并且构造器是private //2.可以通过getInstance()来获取实例 //3.提供大量的方法和字段提供给程序员 //4.Calendar没有提供对应的格式化的类，因此需要程序员自己组合来输出 //5.如果我们需要按照24小时进制来获取时间，Calendar.HOUR=>Calendar.HOUR_OF_DAY Calendar c = Calendar.getInstance();//创建日历类对象 System.out.println(c); //获取日历对象的某个日历字段 System.out.println("年："+c.get(Calendar.YEAR)); System.out.println("月："+(c.get(Calendar.MONTH)+1));//因为Calendar返回月时候，是按照0开始编号 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)); System.out.println(c.get(Calendar.YEAR)+"/"+(c.get(Calendar.MONTH)+1)+"/"+c.get(Calendar.DAY_OF_MONTH) +" "+c.get(Calendar.HOUR_OF_DAY)+":"+c.get(Calendar.MINUTE)+":"+c.get(Calendar.SECOND));
- 第三代日期类
前面两代日期类的不足分析
JDK1.0只包含了一个java.util.Date类，但是它的大多数方法已经在JDK1.1引入Calendar类之后被弃用了。而Calendar也存在问题是：
- 可变性：像日期和时间这样的类应该是不可变的
- 偏移性：Date中的年份是从1900开始的，而月份都从0开始
- 格式化：格式化只对Date有用，Calendar则不行
- 此外，它们也不是线程安全的；不能处理闰秒等(每隔两天，多出1s)
-
第三代日期类常见方法
- LocalDate(日期/年月日)、LocalTime(时间/时分秒)、LocalDateTime(日期时间/年月日)JDK8加入
//使用now()返回表示当前日期时间的对象 LocalDateTime now = LocalDateTime.now(); System.out.println(now); System.out.println("年："+now.getYear()); System.out.println("月："+now.getMonth());//英文的分 System.out.println("月："+now.getMonthValue()); System.out.println("日："+now.getDayOfMonth()); System.out.println("时："+now.getHour()); System.out.println("分："+now.getMinute()); System.out.println("秒："+now.getSecond()); LocalDate now1 = LocalDate.now();//可以获取年月日 LocalTime now2 = LocalTime.now();//可以获取时分秒- DateTimeFormatter格式日期类
类似于SimpleDateFormat
//1.使用now()返回表示当前日期时间的对象 LocalDateTime now = LocalDateTime.now(); System.out.println(now); //2.使用DateTimeFormatter对象来格式化 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"); String format = dateTimeFormatter.format(now); System.out.println(format);- Instant时间戳
类似于Date，提供了一系列和Date类转换的方式
//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();- 第三代日期类更多方法
- LocalDateTime类
- MonthDay类：检查重复事件
- 是否为闰年
- 增加日期的某个部分
- 使用plus方法测试增加时间的某个部分
- 使用minus方法测试查看一年前和一年后的日期
LocalDateTime now = LocalDateTime.now(); DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"); //提供plus和minus方法可以把当前时间进行加或者减 //看看900天后，是什么时候把年月日-时分秒 LocalDateTime localDateTime = now.plusDays(900); System.out.println(dateTimeFormatter.format(localDateTime)); //看看3456分钟前是什么时候，把年月日-时分秒输出 LocalDateTime localDateTime1 = now.minusMinutes(3456); System.out.println(dateTimeFormatter.format(localDateTime1));
4448
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
