Java8新增加的时间日期API

介绍：https://blog.csdn.net/qq_40794973/article/details/86882454#t67

Java8以前的实际日期API: http://www.runoob.com/java/java-date-time.html

---

 

常用类

 LocalDateTime

创建对象： 

@Test
public void test() {
    //now() / now(ZoneId zone) 静态方法，根据当前时间创建对象/指定时区的对象
    //获取当前时间
    LocalDateTime ld = LocalDateTime.now();
    System.out.println(ld);//2019-02-19T11:16:34.350568200
}

@Test
public void test() {
     //of() 静态方法，根据指定日期/时间创建对象
    //指定时间
    LocalDateTime ld2 = LocalDateTime.of(2019, 2, 19, 11, 19, 59);
    System.out.println(ld2);//2019-02-19T11:19:59
}

查询 

获取年月日： 

@Test
public void test() {
    //getMonthValue() / getYear()  获得月份(1-12) /获得年份
    LocalDateTime localdate = LocalDateTime.now();
    int ld1 = localdate.getYear();//年                  获得年份
    int ld2 = localdate.getMonthValue();//月            获得月份(1-12)
    int ld3 = localdate.getDayOfMonth();//这一个月的多少天   日
    System.out.println(ld1 + ":" + ld2 + ":" + ld3);//2019:2:19
}

天数为单位： 

@Test
public void test() {
    LocalDateTime localdate = LocalDateTime.now();
    //getDayOfMonth()/getDayOfYear() 获得月份天数(1-31) /获得年份天数(1-366)
    int ld3 = localdate.getDayOfYear();// 这一年的多少天
    int ld4 = localdate.getDayOfMonth();//这一个月的多少天   日
    System.out.println(ld3 + ":" + ld4);//50:19
}

 返回枚举对象：

@Test
public void test() {
    //getMonth()  获得月份, 返回一个 Month 枚举值
    //getDayOfWeek() 获得星期几(返回一个 DayOfWeek 枚举值)
    LocalDateTime localdate = LocalDateTime.now();
    Month ld1 = localdate.getMonth();// 获得月份, 返回一个 Month 枚举值
    DayOfWeek ld2 = localdate.getDayOfWeek();//获得星期几(返回一个 DayOfWeek 枚举值)
    System.out.println(ld1 + ":" + ld2);//FEBRUARY:TUESDAY
}

获取时分秒： 

@Test
public void test() {
    //getHour()/getMinute()/getSecond()  获得当前对象对应的小时、分钟、秒
    LocalDateTime localdate = LocalDateTime.now();
    int ld1 = localdate.getHour();//小时
    int ld2 = localdate.getMinute();//分钟
    int ld3 = localdate.getSecond();//秒
    System.out.println(ld1 + ":" + ld2  + ":" + ld3);//11:38:8
}

修改

修改年月日：

@Test
public void test() {
    //withDayOfMonth()/withDayOfYear()/ withMonth()/withYear()  将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象
    LocalDateTime ld2 = LocalDateTime.of(2019, 2, 19, 11, 19, 59);
    System.out.println(ld2);//2019-02-19T11:19:59


    LocalDateTime ld3 = ld2.withDayOfYear(365);  //一年的多少天
    System.out.println(ld3);//2019-12-31T11:19:59

    LocalDateTime ld4 = ld2.withDayOfMonth(15);  //一个月的多少天
    System.out.println(ld4);//2019-02-15T11:19:59

    LocalDateTime ld5 = ld2.withYear(2018);  //改成第几年
    System.out.println(ld5);//2018-02-19T11:19:59

    LocalDateTime ld6 = ld2.withMonth(3);  //改成第几个月
    System.out.println(ld6);//2019-03-19T11:19:59
}

在当期日期上增加减少年月日、时分秒

1、增加

@Test
public void test() {
    //plusDays(), plusWeeks(), plusMonths(), plusYears(),plusHours()  向当前对象添加几天、几周、几个月、几年、几小时
    LocalDateTime ld2 = LocalDateTime.of(2019, 2, 19, 11, 19, 59);
    System.out.println(ld2);//2019-02-19T11:19:59

    LocalDateTime ld3 = ld2.plusYears(2);//在当前的日期上在加两年
    System.out.println(ld3);//2021-02-19T11:19:59

    LocalDateTime ld4 = ld2.plusMonths(2);//在当前的日期上在加个月
    System.out.println(ld4);//2019-04-19T11:19:59

    LocalDateTime ld5 = ld2.plusWeeks(2);//在当前的日期上在加周  （2月28天 在加2周14天）
    //ld2.plusDays(14);  //相当于
    System.out.println(ld5);//2019-03-05T11:19:59

    LocalDateTime ld6 = ld2.plusDays(2);//在当前的日期上在加两天
    System.out.println(ld6);//2019-02-21T11:19:59

    LocalDateTime ld7 = ld2.plusHours(2);//在当前的日期上在加个小时
    System.out.println(ld7);//2019-02-19T13:19:59
}

2019-02-19T11:19:59
2021-02-19T11:19:59
2019-04-19T11:19:59
2019-03-05T11:19:59
2019-02-21T11:19:59
2019-02-19T13:19:59

2、减少 

@Test
public void test() {
    //minusMonths() / minusWeeks()/ minusDays()/minusYears()/minusHours() 从当前对象减去几月、几周、几天、几年、几小时
    LocalDateTime ld2 = LocalDateTime.of(2019, 2, 19, 11, 19, 59);
    System.out.println(ld2);//2019-02-19T11:19:59
    
    LocalDateTime ld3 = ld2.minusYears(2);//在当前的日期上在减两年
    System.out.println(ld3);//2017-02-19T11:19:59

    LocalDateTime ld4 = ld2.minusMonths(2);//在当前的日期上在减两个月
    System.out.println(ld4);//2018-12-19T11:19:59

    LocalDateTime ld5 = ld2.minusWeeks(2);//在当前的日期上在减两周
    System.out.println(ld5);//2019-02-05T11:19:59

    LocalDateTime ld6 = ld2.minusDays(2);//在当前的日期上在减两天
    System.out.println(ld6);//2019-02-17T11:19:59

    LocalDateTime ld7 = ld2.minusHours(2);//在当前的日期上在减两个小时
    System.out.println(ld7);//2019-02-19T09:19:59

    LocalDateTime ld8 = ld2.minusMinutes(2);//在当前的日期上在减两分钟
    System.out.println(ld8);//2019-02-19T11:17:59

    LocalDateTime ld9 = ld2.minusSeconds(2);//在当前的日期上在减两秒
    System.out.println(ld9);//2019-02-19T11:19:57

    LocalDateTime ld10 = ld2.minusNanos(2);//在当前的日期上在减两纳秒
    System.out.println(ld10);//2019-02-19T11:19:58.999999998
}

2019-02-19T11:19:59
2017-02-19T11:19:59
2018-12-19T11:19:59
2019-02-05T11:19:59
2019-02-17T11:19:59
2019-02-19T09:19:59

 其他：

int compareTo(ChronoLocalDateTime other)  //将此日期时间与其他日期时间进行比较。  

@Test
public void test() {
    LocalDateTime ld = LocalDateTime.now();
    LocalDateTime ld2 = LocalDateTime.of(2018, 2, 19, 11, 19, 59);
    System.out.println(ld+" : "+ld2);//2019-02-19T14:37:33.043493 : 2019-02-19T11:19:59

    System.out.println(ld.compareTo(ld2));//调用的时间对象大，返回 1
    System.out.println(ld2.compareTo(ld));//调用的时间对象小，返回 -1
    System.out.println(ld2.compareTo(ld2));//一样大返回 0
}

boolean equals(Object obj) 
检查这个日期时间是否等于另一个日期时间。 

@Test
public void test() {
    LocalDateTime ld = LocalDateTime.now();
    LocalDateTime ld2 = LocalDateTime.of(2018, 2, 19, 11, 19, 59);
    System.out.println(ld+" : "+ld2);//2019-02-19T14:37:33.043493 : 2019-02-19T11:19:59

    System.out.println(ld.equals(ld2));//false
    System.out.println(ld.equals(ld));//true
}

boolean isAfter(ChronoLocalDateTime other) 
检查这个日期时间是否在指定的日期之后。  
boolean isBefore(ChronoLocalDateTime other) 
检查此日期时间是否在指定的日期时间之前。  
boolean isEqual(ChronoLocalDateTime other) 
检查此日期时间是否等于指定的日期时间。  

@Test
public void test() {
    LocalDateTime ld = LocalDateTime.now();
    LocalDateTime ld2 = LocalDateTime.of(2018, 2, 19, 11, 19, 59);
    System.out.println(ld+" : "+ld2);//2019-02-19T14:37:33.043493 : 2019-02-19T11:19:59

    System.out.println(ld.isAfter(ld2));//true           ld 在 ld2后  ld是ld2发生过后才发生的
    System.out.println(ld2.isBefore(ld));//true         ld2 在 ld钱  ld2是在ld发生之前发生的
    System.out.println(ld.isEqual(ld));//true
}

 

---

格式化与解析日期或时间

java.time.format.DateTimeFormatter 类：该类提供了三种格式化方法：

1. 预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE
2. 本地化相关的格式。如：ofLocalizedDate(FormatStyle.FULL)
3. 自定义的格式，根据模式字符串来创建 DateTimeFormatter 格式器。如：ofPattern(“yyyy-MM-dd hh:mm:ss E”)

方法	描述
ofPattern(String pattern)	静态方法，返回一个指定字符串格式的DateTimeFormatter
format(TemporalAccessor t)	格式化一个日期、时间，返回字符串
parse(CharSequence text)	将指定格式的字符序列解析为一个日期、时间

模式字符串： 

字母	日期或时间元素	表示	示例
y	年	Year	1996; 96
M	年中的月份	Month	July; Jul; 07
d	月份中的天数	Number	10
h	am/pm 中的小时数（1-12）	Number	12
H	一天中的小时数（0-23）	Number	0
k	一天中的小时数（1-24）	Number	24
K	am/pm 中的小时数（0-11）	Number	0
m	小时中的分钟数	Number	30
s	分钟中的秒数	Number	55
E	星期中的天数	Text	Tuesday; Tue
G	Era 标志符	Text	AD
w	年中的周数	Number	27
W	月份中的周数	Number	2
D	年中的天数	Number	189
F	月份中的星期	Number	2
a	Am/pm 标记	Text	PM
S	毫秒数	Number	978

使用 DateTimeFormatter完成格式化 

使用 DateTimeFormatter将日期、时间（LocalDate、LocalDateTime、LocalTime等实例）格式化为字符串，可通过如下两种方式。

1. 调用 DateTimeFormatter的 format (TemporalAccessor temporal) 方法执行格式化，其中 LocalDate、 LocalDateTime、LocalTime等类都是 TemporalAccessor 接口的实现类。

2. 调用 LocalDate、LocalDateTime、LocalTime等日期、时间对象的 format (DateTimeFormatter formatter)方法执行格式化。

上面两种方式的功能相同，用法也基本相似，如下程序示范了使用 DateTimeFormatter来格式化日期、时间。 

import java.time.*;
import java.time.format.*;
public class NewFormatterTest {
	public static void main(String[] args) {
		DateTimeFormatter[] formatters = new DateTimeFormatter[]{
				// 直接使用常量创建DateTimeFormatter格式器
				DateTimeFormatter.ISO_LOCAL_DATE,
				DateTimeFormatter.ISO_LOCAL_TIME,
				DateTimeFormatter.ISO_LOCAL_DATE_TIME,
				// 使用本地化的不同风格来创建DateTimeFormatter格式器
				DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL, FormatStyle.MEDIUM),
				//DateTimeFormatter.ofLocalizedTime(FormatStyle.LONG),
				// 根据模式字符串来创建DateTimeFormatter格式器
				DateTimeFormatter.ofPattern("Gyyyy%%MMM%%dd HH:mm:ss")
		};
		LocalDateTime date = LocalDateTime.now();
		// 依次使用不同的格式器对LocalDateTime进行格式化
		for(int i = 0 ; i < formatters.length ; i++) {
			// 下面两行代码的作用相同
			System.out.println(date.format(formatters[i]));
			System.out.println(formatters[i].format(date));
		}
	}
}

 2019-03-03
2019-03-03
10:18:44.502281
10:18:44.502281
2019-03-03T10:18:44.502281
2019-03-03T10:18:44.502281
2019年3月3日星期日 上午10:18:44
2019年3月3日星期日 上午10:18:44
公元2019%%3月%%03 10:18:44
公元2019%%3月%%03 10:18:44

@Test
public void test() {
    //DateTimeFormatter.ISO_LOCAL_DATE_TIME   ISO日期格式化程序格式化或解析没有偏移量的日期时间，例如“2011-12-03T10：15：30”。
    //DateTimeFormatter.ISO_LOCAL_DATE          ISO日期格式化程序格式化或解析没有偏移量的日期，如“2011-12-03”。
    //DateTimeFormatter.ISO_LOCAL_TIME          ISO时间格式化程序格式化或解析一个没有偏移量的时间，例如“10：15”或“10：15：30”。
    LocalDateTime ldt = LocalDateTime.now();
    DateTimeFormatter dtf2 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
    String str = ldt.format(dtf2);
    System.out.println(str);

    String str2 = ldt.format(DateTimeFormatter.ISO_LOCAL_DATE);
    System.out.println(str2);

    String str3 = ldt.format(DateTimeFormatter.ISO_LOCAL_TIME);
    System.out.println(str3);

    System.out.println("-----------------------------------------");
    //DateTimeFormatter.ISO_DATE_TIME   类似ISO的日期格式化程序，用于格式化或解析具有偏移量和区域（如果有的话）的日期时间，如“2011-12-03T10：15：30”，“2011-12-03T10：15：30 + 01” ：00'或'2011-12-03T10：15：30 + 01：00 [欧洲/巴黎]'。
    //DateTimeFormatter.ISO_DATE        ISO日期格式化程序格式化或解析具有偏移量的日期（如可用），如“2011-12-03”或“2011-12-03 + 01：00”。 
    //DateTimeFormatter.ISO_TIME        格式化或解析时间的ISO时间格式化程序，如果可用的偏移量，如“10：15”，“10：15：30”或“10：15：30 + 01：00”。 
    String str4 = ldt.format(DateTimeFormatter.ISO_DATE_TIME);
    System.out.println(str4);

    String str5 = ldt.format(DateTimeFormatter.ISO_DATE);
    System.out.println(str5);

    String str6 = ldt.format(DateTimeFormatter.ISO_TIME);
    System.out.println(str6);
}

 2019-02-19T15:32:24.27152
2019-02-19
15:32:24.27152
-----------------------------------------
2019-02-19T15:32:24.27152
2019-02-19
15:32:24.27152

从图7.12可以看出，使用 DateTimeFormatter 进行格式化时不仅可按系统预置的格式对日期、时间进行格式化，也可使用模式字符串对日期、时间进行自定义格式化，由此可见，DateTimeFormatter的功能完全覆盖了传统的 DateFormat、SimpleFormate的功能。

提示：有些时候，读者可能还需要使用传统的 DateFormat 来执行格式化，DateTimeFormatter则提供了一个 toFormat() 方法，该方法可以获取 DateTimeFormatter对应的 Format 对象。

 使用 DateTimeFormatter 解析字符串

为了使用 DateTimeFormatter 将指定格式的字符串解析成日期、时间对象（LocalDate、LocalDateTime、LocalTime等实例），可通过日期、时间对象提供的 parse(CharSequence text, DateTimeFormatter formatter) 方法进行解析。

如下程序示范了使用 Date Time Formatter解析日期、时间字符串 。

@Test
public void test() {
    // 定义一个任意格式的日期时间字符串
    String str1 = "2014==04==12 01时06分09秒";
    // 根据需要解析的日期、时间字符串定义解析所用的格式器
    DateTimeFormatter fomatter1 = DateTimeFormatter.ofPattern("yyyy==MM==dd HH时mm分ss秒");
    // 执行解析
    LocalDateTime dt1 = LocalDateTime.parse(str1, fomatter1);
    System.out.println(dt1); // 输出 2014-04-12T01:06:09
}

@Test
public void test() {
    // ---下面代码再次解析另一个字符串---
    String str2 = "2014$$$四月$$$13 20小时";//2014$$$4月$$$13 20小时
    DateTimeFormatter fomatter2 = DateTimeFormatter.ofPattern("yyy$$$MMM$$$dd HH小时");
    LocalDateTime dt2 = LocalDateTime.parse(str2, fomatter2);
    System.out.println(dt2); // 输出 2014-04-13T20:00
}

 

上面程序中定义了两个不同格式的日期、时间字符串，为了解析它们，程序分别使用对应的格式字符串创建了 DateTime formatter对象，这样 DateTimeFormatter 即可按该格式字符串将日期、时间字符串解析成 LocalDateTime对象。编译、运行该程序，即可看到两个日期、时间字符串都被成功地解析成LocalDateTime。

 

//5. DateTimeFormatter : 解析和格式化日期或时间
@Test
public void test5(){
    System.out.println("-------------自定义格式-----------------------");
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");
    LocalDateTime ldt = LocalDateTime.now();
    System.out.println(ldt);
    String strDate = ldt.format(dtf);
    //String strDate = dtf.format(ldt); //两种都可以
    System.out.println(strDate);
    //解析回去
    LocalDateTime newLdt = ldt.parse(strDate, dtf);
    System.out.println(newLdt);
}

-------------自定义格式-----------------------
2019-02-19T15:50:11.059749300
2019年02月19日 15:50:11 周二
2019-02-19T15:50:11

https://blog.csdn.net/u011726984/article/details/79345847