文章目录
Java基础
十二、常用类
包装类
包装类的分类
1)针对八种基本数据类型相应的引用类型–包装类
2)有了类的特点,就可以调用类中的方法
包装类和基本数据的转换
1)jdk5前的手动装箱和拆箱方式,装箱:基本类型–>包装类型,反之,拆箱
2)jdk5以后(含jdk5)的自动装箱和拆箱方式
3)自动装箱底层调用的是valueOf方法
package com.Chapter06.Wrapper_;
public class Integer01 {
public static void main(String[] args) {
//演示int <--> Integer的装箱和拆箱
//jdk5之前是手动装箱和拆箱
//手动装箱 int <-->Integer
int n1 = 100;
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);
//手动拆箱
//Integer -> int
int i = integer.intValue();
//jdk5以后就自动装箱和拆箱
int n2 = 200;
//自动装箱int -> Integer
Integer integer2 = n2; //底层使用的是Integer.valueOf(n2)
//自动拆箱Integer->int
int n3 = integer2; //底层仍然使用的是intValue()方法
}
}
包装类型和String类型的相互转换
package com.hspedu.wrapper;
public class WrapperVSString {
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 str4 = "12345";
Integer i2 = Integer.parseInt(str4);//使用到自动装箱
Integer i3 = new Integer(str4);//构造器
System.out.println("ok~~");
}
}
Integer面试题
package com.hspedu.wrapper;
public class WrapperExercise02 {
public static void main(String[] args) {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j); //False
//所以,这里主要是看范围-128 ~ 127 就是直接返回
/*
//1. 如果i 在IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回
//2. 如果不在-128~127,就直接new Integer(i)
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
*/
Integer m = 1; //底层Integer.valueOf(1); -> 阅读源码
Integer n = 1;//底层Integer.valueOf(1);
System.out.println(m == n); //T
//所以,这里主要是看范围-128 ~ 127 就是直接返回
//,否则,就new Integer(xx);
Integer x = 128;//底层Integer.valueOf(1);
Integer y = 128;//底层Integer.valueOf(1);
System.out.println(x == y);//False
Integer i11=127;
int i12=127;
//只要有基本数据类型,判断的是值是否相同
System.out.println(i11==i12); //T
}
}
String类
String类的理解和创建对象
1)String对象用于保存字符串,也就是一组字符序列
2)字符串常量对象是用双引号括起的字符序列
3)字符串的字符使用Unicode字符编码,一个字符(不区分字母还是汉字)占两个字节
4)String类较常用构造方法
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count);
package com.hspedu.string_;
public class String01 {
public static void main(String[] args) {
//1.String 对象用于保存字符串,也就是一组字符序列
//2. "jack" 字符串常量, 双引号括起的字符序列
//3. 字符串的字符使用Unicode 字符编码,一个字符(不区分字母还是汉字)占两个字节
//4. String 类有很多构造器,构造器的重载
// 常用的有String s1 = new String(); //
//String s2 = new String(String original);
//String s3 = new String(char[] a);
//String s4 = new String(char[] a,int startIndex,int count)
//String s5 = new String(byte[] b)
//5. String 类实现了接口Serializable【String 可以串行化:可以在网络传输】
// 接口Comparable [String 对象可以比较大小]
//6. String 是final 类,不能被其他的类继承
//7. String 有属性private final char value[]; 用于存放字符串内容
//8. 一定要注意:value 是一个final 类型, 不可以修改(value地址不能修改):即value 不能指向
// 新的地址,但是单个字符内容是可以变化
String name = "jack";
name = "tom";
final char[] value = {'a','b','c'};
char[] v2 = {'t','o','m'};
value[0] = 'H';
//value = v2; 不可以修改value 地址
}
}
创建String对象的两种方式
1)方式一:直接赋值String s = "java";
2)方式二:调用构造器String s = new String("java");
两种创建String对象的区别:
1)方式一:先从常量池查看是否有"java"数据空间,如果有,直接指向;如果没有则重新创建,然后指向,s最终指向的是常量池的空间地址
2)方式二:先在堆中创建空间,里面维护了value属性,指向常量池的java空间,如果常量池没有"java",重新创建,如果有,直接通过value指向,最终指向的是堆中的空间地址
String对象特性
1)String是一个final类,代表不可变的字符序列
2)字符串是不可变的,一个字符串对象一旦被分配,其内容是不可变的
测试题:
String类的常用方法
String类是保存字符串常量的,每次更新都需要重新开辟空间,效率较低,因此,java设计者还提供了StringBuilder和StringBuffer来增强String的功能,并提高效率
常见方法:
- equals:区分大小写,判断内容是否相等
- equalslgnoreCase:忽略大小写的判断内容是否相等
- length:获取字符的个数,字符串的长度
- indexOf:获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1
- lastIndexOf:获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1
- substring:截取指定范围的子串
- trim:去前后空格
- charAt:获取某索引处的字符,注意不能使用Str[index]这种方式
- toUpperCase:转换为大写字母
- toLowerCase:转换为小写字母
- concat:拼接字符串
- replace:替换字符串中的字符
- split:分割字符串,对于某些分割字符,我们需要转义比如| \ \等
- compareTo:比较两个字符串的大小
- 如果长度相同,并且每个字符也相同,就返回0
- 如果长度相同或不相同,但是在进行比较时,可以区分大小
- 如果前面的部分都相同,就返回str1.len - str2.len
- toCharArray:转换成字符串
- format:格式化字符串
- %c:字符 %d:整型 %s:字符串 %.2f:浮点型
StringBuffer类
1)java.lang.StringBuffer代表可变的字符序列,可以对字符串内容进行增删
2)很多方法与String相同,但StringBuffer是可变长度的
3)StringBuffer是一个容器
package com.hspedu.stringbuffer_;
public class StringBuffer01 {
public static void main(String[] args) {
//1. StringBuffer 的直接父类是AbstractStringBuilder
//2. StringBuffer 实现了Serializable, 即StringBuffer 的对象可以串行化
//3. 在父类中AbstractStringBuilder 有属性char[] value,不是final
// 该value 数组存放字符串内容,引出存放在堆中的
//4. StringBuffer 是一个final 类,不能被继承
//5. 因为StringBuffer 字符内容是存在char[] value, 所有在变化(增加/删除)
// 不用每次都更换地址(即不是每次创建新对象), 所以效率高于String
StringBuffer stringBuffer = new StringBuffer("hello");
}
}
String和StringBuffer比较:
1)String保存的是字符串常量,里面的值不能更改,每次String类的更新实际上就是更改地址,效率较低 private final char value[];
2)StringBuffer保存的是字符串变量,里面的值可以 更改,每次StringBuffer的更新实际上可以更新内容,不用更新地址,效率较高 char[] value;
这个放在堆中
StringBuffer的构造器
package com.Chapter06.String_;
public class StringBuffer01 {
public static void main(String[] args) {
//构造器使用
//1.创建一个大小为16的char[],用于存放字符内容
StringBuffer stringBuffer = new StringBuffer();
//2.通过构造器指定char[]大小
StringBuffer stringBuffer1 = new StringBuffer(100);
//3.通过给一个String创建StringBuffer,char[]大小就是str.length + 16
StringBuffer hello = new StringBuffer("hello");
}
}
String和StringBuffer之间相互转换
package com.Chapter06.String_;
public class StringBuffer02 {
public static void main(String[] args) {
//String --> StringBuffer
String str = "hello";
//方式一:使用构造器
//注意:返回的才是StringBuffer对象,对str本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式二:使用的是append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);
//StringBuffer --> String
StringBuffer java = new StringBuffer("java");
//方式一:使用StringBuffer提供的toString方法
String s = java.toString();
//方式二:使用构造器
String s1 = new String(java);
}
}
StringBuffer类常见方法
- append:增
- delete(start,end):删
- replace(start,end,string):改(将start-end之间的内容替换掉,不含end)
- indexOf:查(查找子串在字符串第1次出现的索引,如果找不到返回-1)
- insert:插
- length:获取长度
测试题:
StringBuilder类
1)一个可变的字符序列,此类提供一个与StringBuffer兼容的API,但不保证同步(StringBuilder不是线程安全)。该类被设计用作StringBuffer的一个简易替换,用在字符串缓冲区被单个线程使用的时候,如果可能,建议优先采用该类,因为在大多数实现中,它比StringBuffer要快
2)在StringBuilder上的主要操作是append和insert方法,可重载这些方法,以接受任意类型的数据
3)StringBuffer和StringBuilder均代表可变的字符序列,方法是一样的,所以使用和StringBuffer一样
package com.hspedu.stringbuilder_;
public class StringBuilder01 {
public static void main(String[] args) {
//1. StringBuilder 继承AbstractStringBuilder 类
//2. 实现了Serializable ,说明StringBuilder 对象是可以串行化(对象可以网络传输,可以保存到文件)
//3. StringBuilder 是final 类, 不能被继承
//4. StringBuilder 对象字符序列仍然是存放在其父类AbstractStringBuilder 的char[] value;
// 因此,字符序列是堆中
//5. StringBuilder 的方法,没有做互斥的处理,即没有synchronized 关键字,因此在单线程的情况下使用
// StringBuilder
StringBuilder stringBuilder = new StringBuilder();
}
}
String、StringBuffer和StringBuilder对比
三者效率:StringBuilder > StringBuffer > String
使用原则:
1)如果字符串存在大量的修改操作,一般使用StringBuffer和StringBuilder
2)如果字符串存在大量的修改操作,并在单线程的情况,使用StringBuilder
3)如果字符串存在大量的修改操作,并在多线程的情况,使用StringBuffer
4)如果字符串很少修改,被多个对象引用,使用String
Math类
基本介绍
Math类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数
常见方法:
- abs:绝对值
- pow:求幂
- ceil:向上取整
- floor:向下取整
- round:四舍五入
- sqrt:求开方
- random:求随机数
- random返回的是0<=x<1之间的一个随机小数
- max:求两个数的最大值
- min:求两个数的最小值
Arrays类
Arrays里面包含一系列静态方法,用于管理或操作数组(比如排序和搜索)
常见方法:
1)toString:返回数组的字符串形式
Arrays.toString(arr);
2)sort排序(自然排序和定制排序)
3)binarySearch:通过二分搜索法进行查找,要求必须排好序
4)copyOf:数组元素的复制
5)fill:数组元素的填充
6)equals:比较两个数组元素内容是否完全一致
7)asList:将一组值转换成list
package com.hspedu.arrays_;
import java.util.Arrays;
public class ArraysMethod01 {
public static void main(String[] args) {
Integer[] integers = {1, 20, 90};
//遍历数组
// for(int i = 0; i < integers.length; i++) {
// System.out.println(integers[i]);
// }
//直接使用Arrays.toString 方法,显示数组
// System.out.println(Arrays.toString(integers));//
//演示sort 方法的使用
Integer arr[] = {1, -1, 7, 0, 89};
//进行排序
//老韩解读
//1. 可以直接使用冒泡排序, 也可以直接使用Arrays 提供的sort 方法排序
//2. 因为数组是引用类型,所以通过sort 排序后,会直接影响到实参arr
//3. sort 重载的,也可以通过传入一个接口Comparator 实现定制排序
//4. 调用定制排序时,传入两个参数(1) 排序的数组arr
// (2) 实现了Comparator 接口的匿名内部类, 要求实现compare 方法
//5. 先演示效果,再解释
//6. 这里体现了接口编程的方式, 看看源码,就明白
// 源码分析
//(1) Arrays.sort(arr, new Comparator()
//(2) 最终到TimSort 类的private static <T> void binarySort(T[] a, int lo, int hi, int start,
// Comparator<? super T> c)()
//(3) 执行到binarySort 方法的代码, 会根据动态绑定机制c.compare()执行我们传入的
// 匿名内部类的compare ()
// while (left < right) {
// int mid = (left + right) >>> 1;
// if (c.compare(pivot, a[mid]) < 0)
// right = mid;
// else
// left = mid + 1;
// }
//(4) new Comparator() {
// @Override
// public int compare(Object o1, Object o2) {
// Integer i1 = (Integer) o1;
// Integer i2 = (Integer) o2;
// return i2 - i1;
// }
// }
//(5) public int compare(Object o1, Object o2) 返回的值>0 还是<0
// 会影响整个排序结果, 这就充分体现了接口编程+动态绑定+匿名内部类的综合使用
// 将来的底层框架和源码的使用方式,会非常常见
//Arrays.sort(arr); // 默认排序方法
//定制排序
Arrays.sort(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer) o1;
Integer i2 = (Integer) o2;
return i2 - i1;
}
});
System.out.println("===排序后===");
System.out.println(Arrays.toString(arr));//
}
}
package com.Chapter06.Arrays_;
import java.util.Arrays;
import java.util.Comparator;
public class ArraySort {
public static void main(String[] args) {
int[] arr = {1,-1,3,20};
Bubble02(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
int i1 = (Integer)o1;
int i2 = (Integer)o2;
return i1 - i2;
}
});
System.out.println(Arrays.toString(arr));
}
//使用冒泡排血完成排序
public static void Bubble(int[] arr){
int tmp = 0;
for(int i = 0;i < arr.length-1 ; i++){
for(int j = 0; j < arr.length-1-i;j++){
if(arr[j] > arr[j+1]){
tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
}
//结合冒泡+定制
public static void Bubble02(int[] arr, Comparator c){
int tmp = 0;
for(int i = 0;i < arr.length-1 ; i++){
for(int j = 0; j < arr.length-1-i;j++){
if(c.compare(arr[j],arr[j+1])>0){
tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
}
}
package com.hspedu.arrays_;
import java.util.Arrays;
import java.util.List;
public class ArraysMethod02 {
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<E> extends AbstractList<E>
// 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());
}
}
System类
常见方法:
1)exit:退出当前程序
2)arraycopy:复制数组元素,比较适合底层调用,一般使用Arrays.copyOf完成复制数组
3)currentTimeMillens:返回当前时间距离1970年1月1日的毫秒数
4)gc:运行垃圾回收机制:System.gc();
package com.hspedu.system_;
import java.util.Arrays;
public class System_ {
public static void main(String[] args) {
//exit 退出当前程序
// System.out.println("ok1");
// //1. exit(0) 表示程序退出
// //2. 0 表示一个状态, 正常的状态
// System.exit(0);//
// System.out.println("ok2");
//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 的毫秒数
System.out.println(System.currentTimeMillis());
}
}
BigInteger 和BigDecimal 类
应用场景:
1)BigInteger:适合保存比较大的整型
2)BigDecimal:适合保存精度更高的浮点型(小数)
常见方法:
- add:加
- subtract:减
- multiply:乘
- divide:除
package com.hspedu.bignum;
import java.math.BigInteger;
public class BigInteger_ {
public static void main(String[] args) {
//当我们编程中,需要处理很大的整数,long 不够用
//可以使用BigInteger 的类来搞定
// long l = 23788888899999999999999999999l;
// System.out.println("l=" + l);
BigInteger bigInteger = new BigInteger("23788888899999999999999999999");
BigInteger bigInteger2 = newBigInteger("100999999999999999999999999999999999999999999999999999999999999999999999999999999999");
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);//除
}
}
package com.hspedu.bignum;
import java.math.BigDecimal;
public class 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));
}
}
日期类
第一代日期类
1)Data:精确到毫秒,代表特定的瞬间
2)SimpleDateFormat:格式和解析日期的类SimpleDateFormat格式化和解析日期的具体类,它允许进行格式化(日期->文本)、解析(文本->日期)和规范化
package com.hspedu.date_;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Date01 {
public static void main(String[] args) throws ParseException {
//1. 获取当前系统时间
//2. 这里的Date 类是在java.util 包
//3. 默认输出的日期格式是国外的方式, 因此通常需要对格式进行转换
Date d1 = new Date(); //获取当前系统时间
System.out.println("当前日期=" + d1);
Date d2 = new Date(9234567); //通过指定毫秒数得到时间
System.out.println("d2=" + d2); //获取某个时间对应的毫秒数
//
//1. 创建SimpleDateFormat 对象,可以指定相应的格式
//2. 这里的格式使用的字母是规定好,不能乱写
SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年MM 月dd 日hh:mm:ss E");
String format = sdf.format(d1); // format:将日期转换成指定格式的字符串
System.out.println("当前日期=" + format);
//1. 可以把一个格式化的String 转成对应的Date
//2. 得到Date 仍然在输出时,还是按照国外的形式,如果希望指定格式输出,需要转换
//3. 在把String -> Date , 使用的sdf 格式需要和你给的String 的格式一样,否则会抛出转换异常
String s = "1996 年01 月01 日10:20:30 星期一";
Date parse = sdf.parse(s);
System.out.println("parse=" + sdf.format(parse));
}
}
第二代日期类
1)第二代日期类,主要就是Calendar类(日历)
public abstract class Calendar extends Object implements,Serializable,Cloneable, Comparable < Calenda >
2)Calendar类是一个抽象类,它为特定瞬间与一组诸如year、month、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法,并为操作日历字段(例如获取下星期的日期)提供了一些方法
package com.hspedu.date_;
import java.util.Calendar;
public class Calendar_ {
public static void main(String[] args) {
//老韩解读
//1. Calendar 是一个抽象类, 并且构造器是private
//2. 可以通过getInstance() 来获取实例
//3. 提供大量的方法和字段提供给程序员
//4. Calendar 没有提供对应的格式化的类,因此需要程序员自己组合来输出(灵活)
//5. 如果我们需要按照24 小时进制来获取时间, Calendar.HOUR ==改成=> Calendar.HOUR_OF_DAY
Calendar c = Calendar.getInstance(); //创建日历类对象//比较简单,自由
System.out.println("c=" + c);
//2.获取日历对象的某个日历字段
System.out.println("年:" + c.get(Calendar.YEAR));
// 这里为什么要+ 1, 因为Calendar 返回月时候,是按照0 开始编号
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));
//Calender 没有专门的格式化方法,所以需要程序员自己来组合显示
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中也存在问题是:
1)可变性:像日期和时间这样的类应该是不可变的
2)偏移性:Date中的年份是从1900开始的,而月份是从0开始的
3)格式化:格式化只对Date有用,Calendar则不行
4)此外,它们也不是线程安全的;不能处理闰秒等(每隔2天,多出1s)
DateTimeFormatter 格式日期类
类似于SimpleDateFormat
DateTimeFormat dtf = DateTimeFormatter.ofPattern(格式);
String str = dtf.format(日期对象);
在JDK8加入:LocalDate(日期/年月日)、LocalTime(时间/时分秒)、LocalDateTime(日期时间/年月日时分秒)
LocalDate只包含日期,可以获取日期字段
LocalTime只包含时间,可以获取时间字段LocalDateTime包含日期+时间,可以获取日期和时间字段
package com.hspedu.date_;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collection;
public class LocalDate_ {
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));
}
}
Instant时间戳
类似于Date,提供了一系列和Date类转换的方式
Instant --> Date;
Date date = Date.from(instant);
Date --> Instant
Instant instant = date.tolnstant();