詳解Java的日期時間新特性

更新時間：2023年06月02日 09:39:09 作者：一一哥Sun

隨著時間的不斷推移，現(xiàn)實的需求也在不斷更新，原先的一些API已經(jīng)難以滿足開發(fā)需求了，從JDK?8之后，為了滿足更多的開發(fā)需求，Java給我們增加了不少關于日期時間的新特性，接下來就帶各位來看看這些新特性有哪些,需要的朋友可以參考下

一. 新特性概述

在JDK 8之前，其實有不少的API都存在著一些問題，日期時間等相關類同樣如此。所以從JDK 8開始，Java做了較大的改動，出現(xiàn)了很多新特性。其中，java.time包中了就提供了不少新的日期和時間API，主要如下：

本地日期和時間類：LocalDateTime，LocalDate，LocalTime；
帶時區(qū)的日期和時間類：ZonedDateTime；
時刻類：Instant；
時區(qū)：ZoneId，ZoneOffset；
時間間隔：Duration。

在格式化操作方面，也推出了一個新的格式化類DateTimeFormatter。

和之前那些舊的API相比，新的時間API嚴格區(qū)分了時刻、本地日期、本地時間和帶時區(qū)的日期時間，日期和時間的運算更加方便。這些新的API類型幾乎全都是final不變類型，我們不必擔心其會被修改。并且新的API還修正了舊API中一些不合理的常量設計：

Month的范圍采用1~12，分別表示1月到12月；
Week的范圍采用1~7，分別表示周一到周日。

二. LocalDateTime

1. 簡介

LocalDateTime是JDK 8之后出現(xiàn)的，用來表示本地日期和時間的類。我們可以通過now()方法，默認獲取到本地時區(qū)的日期和時間。與之前的舊API不同，LocalDateTime、LocalDate和LocalTime默認會嚴格按照ISO 8601規(guī)定的日期和時間格式進行打印。

2. 獲取當前日期和時間

我們可以通過now()方法來獲取到當前的日期和時間。我們在執(zhí)行一行代碼時，多少也會消耗一點時間，日期和時間的值可能會對不上，尤其是時間的毫秒數(shù)可能會有差異。所以為了保證獲取到的日期和時間值差異減少，我們的代碼盡量要編寫如下：

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
/**
 * @author
 */
public class Demo10 {
    public static void main(String[] args) {
	//獲取當前日期和時間
	LocalDateTime dt = LocalDateTime.now();
	System.out.println("dt="+dt);
	// 轉(zhuǎn)換到當前日期
	LocalDate d = dt.toLocalDate(); 
	System.out.println("date="+d);
	// 轉(zhuǎn)換到當前時間
	LocalTime t = dt.toLocalTime(); 
	System.out.println("time="+t);
    }
}

3. of()方法的作用

我們可以通過of()方法，根據(jù)指定的日期和時間來創(chuàng)建一個LocalDateTime對象，用法如下：

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
/**
 * @author
 */
public class Demo11 {
    public static void main(String[] args) {
	// 根據(jù)指定的日期和時間創(chuàng)建LocalDateTime對象
	// 2023-01-25, 月份與之前不同：1-12分別表示1-12個月
	LocalDate date = LocalDate.of(2023, 1, 25);
	// 20:35:48
	LocalTime time = LocalTime.of(20, 35, 48);
	LocalDateTime dt1 = LocalDateTime.of(date, time);
	System.out.println("dt1=" + dt1);
	LocalDateTime dt2 = LocalDateTime.of(2023, 1, 23, 20, 35, 48);
	System.out.println("dt2=" + dt2);
    }
}

4. parse()方法的作用

我們可以使用parse()方法，將一個時間格式的字符串解析為LocalDateTime，用法如下：

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
/**
 * @author
 */
public class Demo11 {
    public static void main(String[] args) {
	// 解析時間字符串。T是日期和時間的分隔符
	LocalDateTime dt = LocalDateTime.parse("2023-02-22T20:18:15");
	System.out.println("dt="+dt);
	LocalDate date = LocalDate.parse("2012-10-15");
	System.out.println("date="+date);
	LocalTime time = LocalTime.parse("16:15:20");
	System.out.println("time="+time);
    }
}

我們要注意，根據(jù)ISO 8601規(guī)定，日期和時間的分隔符是T，標準格式如下：

日期：yyyy-MM-dd
時間：HH:mm:ss
帶毫秒的時間：HH:mm:ss.SSS
日期和時間：yyyy-MM-dd'T'HH:mm:ss
帶毫秒的日期和時間：yyyy-MM-dd'T'HH:mm:ss.SSS

5. 時間加減方法

在LocalDateTime中，給我們提供了一系列的加減操作方法，使得我們可以很輕易的實現(xiàn)時間的加減操作，比如給某個日期或時間進行加或減的操作。plusXxx()增加方法如下圖所示：

minusXxx()減少方法如下圖所示：

import java.time.LocalDateTime;
/**
 * @author
 */
public class Demo13 {
    public static void main(String[] args) {
	// 對日期進行加減操作
	LocalDateTime dt1 = LocalDateTime.now();
	System.out.println("dt1=" + dt1);
        // 加3天減6小時:
        LocalDateTime dt2 = dt1.plusDays(3).minusHours(6);
        // 2019-10-31T17:30:59
        System.out.println("dt2=" +dt2); 
        // 減1月:
        LocalDateTime dt3 = dt2.minusMonths(1);
        // 2019-09-30T17:30:59
        System.out.println("dt3=" +dt3); 
        //加兩周
        LocalDateTime dt4 = dt3.plusWeeks(2);
        System.out.println("dt4=" +dt4); 
    }
}

6. 時間調(diào)整方法

我們除了可以進行日期和時間的增加、減少操作之外，還可以利用withXxx()方法對日期和時間進行調(diào)整，這些方法如下圖所示：

從上圖可以看出，我們可以對年、月、日、時、分、秒等進行調(diào)整，具體含義如下：

調(diào)整年：withYear()
調(diào)整月：withMonth()
調(diào)整日：withDayOfMonth()
調(diào)整時：withHour()
調(diào)整分：withMinute()
調(diào)整秒：withSecond()

import java.time.LocalDateTime;
/**
 * @author
 */
public class Demo14 {
    public static void main(String[] args) {
	// 對日期進行加減操作
	LocalDateTime dt1 = LocalDateTime.now();
	System.out.println("dt1=" + dt1);
	// 注意：如果某個月中沒有29、30、31等日期,會出現(xiàn)java.time.DateTimeException: Invalid date 'FEBRUARY 31'類似的異常。
        //LocalDateTime dt2 = dt1.withDayOfMonth(31);
	//日期變?yōu)?5日
        LocalDateTime dt2 = dt1.withDayOfMonth(25);
        System.out.println("dt2="+dt2); // 2019-10-31T20:30:59
        //月份變成5月
        LocalDateTime dt3 = dt2.withMonth(5);
        //2023-05-25T20:06:06.768
        System.out.println("dt3="+dt3); 
        //年份變成2024年
        LocalDateTime dt4 = dt3.withYear(2024);
        //2024-05-25T20:06:06.768
        System.out.println("dt4=" +dt4); 
    }
}

我們在利用withXxx()方法調(diào)整月份時，會相應地調(diào)整日期。并且要注意，如果某個月中沒有29、30、31等日期，則會出現(xiàn)java.time.DateTimeException: Invalid date 'FEBRUARY 31'類似的異常，如下圖所示：

7. with()方法

LocalDateTime中有一個通用的with()方法，允許我們進行更復雜的運算，比如獲取當月或下個月的第一天、最后一天、第一個周一等操作。

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.TemporalAdjusters;
public class Demo14 {
    public static void main(String[] args) {
        //獲取本月的第一天0:00時刻:
        LocalDateTime firstDay = LocalDate.now().withDayOfMonth(1).atStartOfDay();
        System.out.println("firstDay="+firstDay);
        //獲取本月的最后1天:
        LocalDate lastDay = LocalDate.now().with(TemporalAdjusters.lastDayOfMonth());
        System.out.println("lastDay="+lastDay);
        //獲取下個月的第1天:
        LocalDate nextMonthFirstDay = LocalDate.now().with(TemporalAdjusters.firstDayOfNextMonth());
        System.out.println("nextMonthFirstDay="+nextMonthFirstDay);
        //獲取本月的第1個周一
        LocalDate firstWeekday = LocalDate.now().with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY));
        System.out.println("firstWeekday="+firstWeekday);
    }
}

8. isBefore()與isAfter()方法

如果我們判斷兩個LocalDateTime的先后順序，可以使用isBefore()、isAfter()方法。

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
/**
 * @author
 */
public class Demo16 {
    public static void main(String[] args) {
	LocalDateTime now = LocalDateTime.now();
        LocalDateTime target = LocalDateTime.of(2022, 12, 25, 10, 15, 10);
        //判斷A日期在B日期之前
        System.out.println("before?="+now.isBefore(target));
        //判斷A日期在B日期之前
        System.out.println(LocalDate.now().isBefore(LocalDate.of(2023, 12, 19)));
        //判斷A時間在B時間之后
        System.out.println(LocalTime.now().isAfter(LocalTime.parse("10:15:20")));
    }
}

9. Duration時間間隔和Period間隔天數(shù)

我們可以使用Duration來 表示兩個時刻之間的持續(xù)時間， 計算兩個時間之間的間隔 ；用 Period來 表示兩個日期之間的間隔天數(shù)， 以年、月、日的形式表示，用于計算兩個日期之間的間隔。

Duration和Period的表示方法也符合ISO-8601的格式，它以 P...T... 的形式表示。P...T之間表示日期間隔，T后面表示時間間隔，如果是PT...的格式，則只表示時間間隔。

所以如果是兩個LocalDateTime之間的差值，使用Duration表示的形式就是PT12H10M30S，意思是間隔12小時10分鐘30秒。而兩個LocalDate之間的差值，用Period表示的形式則是P1M21D，表示間隔1個月21天。

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;
/**
 * @author 
 */
public class Demo17 {
    public static void main(String[] args) {
	LocalDateTime start = LocalDateTime.of(2023, 05, 24, 13, 15, 20);
        LocalDateTime end = LocalDateTime.of(2025, 11, 8, 19, 25, 30);
        //計算兩個時間的間隔
        Duration d = Duration.between(start, end);
        //PT21582H10M10S,間隔21582小時10分10秒
        System.out.println("duration="+d); 
        //計算兩個日期的間隔
        Period p = LocalDate.of(2022, 12, 11).until(LocalDate.of(2025, 2, 22));
        //P2Y2M11D,間隔2個月11天
        System.out.println("period="+p); 
        //我們也可以使用ofXxx()或parse()方法直接創(chuàng)建Duration
        //10hours
        Duration d1 = Duration.ofHours(10);
        //2day,4hours,5minutes
        Duration d2 = Duration.parse("P2DT4H5M"); 
        System.out.println("d1="+d1); 
        System.out.println("d2="+d2); 
    }
}

三. ZonedDateTime

1. 簡介

我們知道，LocalDateTime表示本地日期和時間，如果我們要表示一個帶時區(qū)的日期和時間，就需要使用ZonedDateTime了。ZonedDateTime相當于是LocalDateTime + ZoneId，其中ZoneId是java.time引入的新的時區(qū)類，它與舊的java.util.TimeZone是有區(qū)別的。在ZonedDateTime中也提供了plusDays()等加減操作，使用起來也非常地方便。

2. 創(chuàng)建方式

如果我們想要創(chuàng)建一個ZonedDateTime對象，可以有以下幾種方法：

通過now()方法返回ZonedDateTime對象；
通過給LocalDateTime附加ZoneId獲取。

接下來就通過一些具體的案例來給大家展示一下ZonedDateTime到底是怎么創(chuàng)建的。

2.1 now()方法

我們先來看看通過now()方法如何創(chuàng)建一個ZonedDateTime對象。

import java.time.ZoneId;
import java.time.ZonedDateTime;
/**
 * @author
 */
public class Demo18 {
    public static void main(String[] args) {
	//獲取默認時區(qū)的時間對象
	ZonedDateTime zdt1 = ZonedDateTime.now(); 
	System.out.println("zdt1="+zdt1); 
	//獲取指定時區(qū)的時間對象
        ZonedDateTime zdt2 = ZonedDateTime.now(ZoneId.of("America/New_York"));
        System.out.println("zdt2="+zdt2); 
    }
}

在這個案例中，我們獲得的兩個ZonedDateTime對象，它們的時區(qū)雖然不同，但時間都是同一時刻的，如果毫秒數(shù)不同是在執(zhí)行語句時有一點時間差。

2.2 附加ZoneId

我們再來通過給LocalDateTime附加ZoneId的方式來獲取一個ZonedDateTime對象。

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
/**
 * @author
 */
public class Demo19 {
    public static void main(String[] args) {
	LocalDateTime ldt = LocalDateTime.of(2023, 1, 25, 10, 15, 11);
	//獲取默認時區(qū)的時間對象
	ZonedDateTime zdt1 = ldt.atZone(ZoneId.systemDefault());
	System.out.println("zdt1=" + zdt1);
	//獲取指定時區(qū)的時間對象
	ZonedDateTime zdt2 = ldt.atZone(ZoneId.of("America/New_York"));
	System.out.println("zdt2=" + zdt2);
    }
}

這種方式創(chuàng)建的ZonedDateTime對象，其日期和時間與LocalDateTime相同，但附加的時區(qū)不同，因此是兩個不同的時刻。

3. 時區(qū)轉(zhuǎn)換

有時我們在項目中需要將A時區(qū)的時間轉(zhuǎn)換成B時區(qū)的時間，這就需要在兩個時區(qū)之間進行切換。以前如果我們想實現(xiàn)這種功能，就需要我們自己計算，而且非常的麻煩且復雜，現(xiàn)在新的Java API中直接給我們帶來了負責時區(qū)轉(zhuǎn)換的方法，這就非常方便了。利用withZoneSameInstant()方法，我們就可以將一個關聯(lián)的時區(qū)轉(zhuǎn)換到另一個時區(qū)，轉(zhuǎn)換后的日期和時間也會相應調(diào)整。

import java.time.ZoneId;
import java.time.ZonedDateTime;
/**
 * @author 
 */
public class Demo20 {
    public static void main(String[] args) {
	//將北京時間轉(zhuǎn)為紐約時間
	//獲取北京時區(qū)的當前時間
	//注意：這里的時區(qū)名字不能隨便瞎寫，否則會產(chǎn)生java.time.zone.ZoneRulesException: Unknown time-zone ID: Asia/Beijing
        ZonedDateTime zdt1 = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
        System.out.println("zdt1=" + zdt1);
        //將當前時區(qū)的時間，轉(zhuǎn)換為紐約時間
        ZonedDateTime zdt2 = zdt1.withZoneSameInstant(ZoneId.of("America/New_York"));
	System.out.println("zdt2=" + zdt2);
        //轉(zhuǎn)換為本地時間
	LocalDateTime ldt = zdt2.toLocalDateTime();
	System.out.println("ldt=" + ldt);
    }
}

注意：

時區(qū)的名字不能隨便瞎寫，否則會產(chǎn)生java.time.zone.ZoneRulesException: Unknown time-zone ID: Asia/Beijing，如下圖所示：

另外在時區(qū)轉(zhuǎn)換時，由于夏令時的存在，不同的日期轉(zhuǎn)換結(jié)果有可能是不同的，有可能會出現(xiàn)兩次轉(zhuǎn)換后有1小時的夏令時時差。所以如果我們以后涉及到時區(qū)轉(zhuǎn)換時，盡量不要自己計算時差，否則難以正確地處理夏令時。

四. DateTimeFormatter

1. 簡介

我們在前面學習Date日期時間對象時，知道該對象默認輸出的時間格式其實是不符合大多數(shù)的使用場景的，所以一般都需要我們對其進行格式化設置，比如通過printf()方法或SimpleDateFormat類來實現(xiàn)。但是當我們使用新的LocalDateTime或ZonedDateTime進行格式化顯示時，就需要使用新的DateTimeFormatter類了。

和SimpleDateFormat不同的是，DateTimeFormatter不但是不可變的對象，且還是線程安全的。編程時我們可以先創(chuàng)建出一個DateTimeFormatter實例對象，然后根據(jù)需要引用即可。而之前的SimpleDateFormat則是線程不安全的，使用時只能在方法內(nèi)部創(chuàng)建出一個新的局部變量。

2. 創(chuàng)建方式

我們要想使用DateTimeFormatter，首先得創(chuàng)建出一個DateTimeFormatter對象，一般有如下兩種方式：

DateTimeFormatter.ofPattern(String pattern)：pattern是待傳入的格式化字符串；
DateTimeFormatter.ofPattern(String pattern,Locale locale)：locale是所采用的本地化設置。

3. 基本使用

了解了創(chuàng)建方式之后，我們就可以來看看該如何進行時間格式化了。

import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
/**
 * @author 
 */
public class Demo21 {
    public static void main(String[] args) {
	//獲取默認的本地時間
	ZonedDateTime zdt = ZonedDateTime.now();
	//獲取一個DateTimeFormatter對象,如果需要輸出固定字符，可以用'xxx'表示，如'中國時間'
        var formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss ZZZZ '中國時間'");
        System.out.println(formatter.format(zdt));
        //獲取一個DateTimeFormatter對象,中國時區(qū)
        var zhFormatter = DateTimeFormatter.ofPattern("yyyy MMM dd EE HH:mm:ss", Locale.CHINA);
        System.out.println(zhFormatter.format(zdt));
        //改變默認的顯示格式,用指定的格式顯示
        //System.out.println(DateTimeFormatter.ISO_DATE.format(zdt));
        //獲取一個DateTimeFormatter對象,美國時區(qū)
        var usFormatter = DateTimeFormatter.ofPattern("E, MMMM/dd/yyyy HH:mm:ss", Locale.US);
        //System.out.println(usFormatter.format(zdt));
        //改變默認的顯示格式
        System.out.println(DateTimeFormatter.ISO_DATE_TIME.format(zdt));
    }
}

當我們在格式化字符串時，如果需要輸出一些固定的字符，可以用'xxx'的形式來表示。另外我們在調(diào)用System.out.println()方法對一個ZonedDateTime，或者LocalDateTime實例進行打印時，實際上調(diào)用的是它們的toString()方法。默認的toString()方法顯示的字符串是按照ISO 8601格式顯示的，我們可以通過DateTimeFormatter預定義的幾個靜態(tài)變量來引用。

五. Instant

1. 簡介

在之前給大家講過，計算機中存儲的當前時間，其實就是一個不斷遞增的整數(shù)值，即從1970年1月1日0分0秒開始以來不斷遞增的一個整數(shù)值。如果我們想要獲取這個整數(shù)值，可以使用System.currentTimeMillis()方法，該方法會返回一個long型的毫秒值，這就是當前時間的時間戳！

而現(xiàn)在我們其實還可以使用Instant.now()來 獲取當前的時間戳，效果和 System.currentTimeMillis() 類似。但Instant獲取的時間戳更為精確，其內(nèi)部采用了兩種時間精度，分別是秒和納秒。

另外Instant還提供了plusXxx和minusXxx增減方法，方便我們進行時間的操作。且Instant作為時間戳對象，我們還可以給它附加上一個時區(qū)，創(chuàng)建出對應的ZonedDateTime對象。我們也可以給它關聯(lián)上指定的ZoneId，得到對應的ZonedDateTime，進而獲得對應時區(qū)的LocalDateTime，所以我們可以在LocalDateTime、ZoneId、Instant、ZonedDateTime之間互相轉(zhuǎn)換。

2. 使用方法

接下來我們看看Instant的用法。

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
/**
 * @author
 */
public class Demo22 {
    public static void main(String[] args) {
	//獲取當前時間的時間戳
	long currentTimeMillis = System.currentTimeMillis();
	System.out.println("currentTimeMillis毫秒級時間戳="+currentTimeMillis);
	//獲取當前時間的時間戳
	Instant now = Instant.now();
	System.out.println("now時刻="+now);
	// 秒
        System.out.println("秒級時間戳="+now.getEpochSecond()); 
        // 毫秒
        System.out.println("毫秒級時間戳="+now.toEpochMilli());
	//用指定的時間戳創(chuàng)建Instant對象
	Instant ins = Instant.ofEpochSecond(1676262418);
	//獲取所在時區(qū)的ZonedDateTime對象
	ZonedDateTime zdt = ins.atZone(ZoneId.systemDefault());
	System.out.println("zdt="+zdt); 
    }
}

六. 新舊時間API的轉(zhuǎn)換

1. 簡介

現(xiàn)在我們知道，在Java中，關于日期和時間的API其實有兩套，一套舊的，一套新的。這兩套API以JDK 8為分割線，此前的屬于舊版API，此后的屬于新版API。

舊版API：定義在java.util包中，主要包括Date、Calendar和TimeZone幾個類；
新版API：JDK 8之后引入，定義在java.time包中，主要包括LocalDateTime、ZonedDateTime、ZoneId、DateTimeFormatter、Instant等。

這時有些小白就會好奇，這兩套時間API我們在開發(fā)時該怎么選擇？其實，如果大家的項目屬于是一個新開發(fā)的項目，且你們的Java版本在JDK 8以上，那就采用新版的API吧。但是如果你們的項目涉及到遺留代碼，是對舊的項目進行維護或改造，很多遺留代碼仍然在使用舊的API，建議大家還是不要改變原有的選擇，請繼續(xù)使用舊版API。

但是如果你們的項目環(huán)境已經(jīng)從低版本的JDK切換到了高本版的JDK，且你們公司要求對項目進行升級改造，我們能不能在新舊兩種API之間進行轉(zhuǎn)換呢？其實這也是可以的，今天就給大家講一下如何在新舊兩套API之間互相轉(zhuǎn)換。

2. 舊轉(zhuǎn)新

首先我們來看看舊的API是如何轉(zhuǎn)成新的API的。比如我們想把舊式的 Date 或 Calendar 轉(zhuǎn)換為新的API對象，可以通過 toInstant() 方法轉(zhuǎn)換為 Instant 對象，然后再繼續(xù)轉(zhuǎn)換為 ZonedDateTime，實現(xiàn)代碼如下：

import java.time.Instant;
import java.time.ZonedDateTime;
import java.util.Calendar;
import java.util.Date;
/**
 * @author 
 */
public class Demo24 {
    public static void main(String[] args) {
	//將舊版API中的Date，轉(zhuǎn)為新版API中的Instant對象
	Instant instant = new Date().toInstant();
	System.out.println("instant="+instant);
	//將舊版API中的Calendar，轉(zhuǎn)為新版API中的Instant，然后再進一步轉(zhuǎn)為新版的ZonedDateTime:
	Calendar calendar = Calendar.getInstance();
	Instant instant2 = calendar.toInstant();
	ZonedDateTime zdt = instant2.atZone(calendar.getTimeZone().toZoneId());
	System.out.println("zdt="+zdt); 
    }
}

3. 新轉(zhuǎn)舊

舊版API可以轉(zhuǎn)換成新版API，同時我們也可以將新班API轉(zhuǎn)成舊版的API，已實現(xiàn)與原有系統(tǒng)的兼容。如果要實現(xiàn)這一目標，我們需要借助 long 型的時間戳做一個“中轉(zhuǎn)” ，具體實現(xiàn)如下：

import java.time.ZonedDateTime;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
public class Demo25 {
    public static void main(String[] args) {
	//新版API中的ZonedDateTime，先轉(zhuǎn)為long類型
	ZonedDateTime zdt = ZonedDateTime.now();
	//獲取秒級時間戳，轉(zhuǎn)為long類型
	long ts = zdt.toEpochSecond() * 1000;
	System.out.println("ts=" + ts);
	//然后將long類型,轉(zhuǎn)為舊版API中的Date
	Date date = new Date(ts);
	System.out.println("date=" + date);
	//將long類型轉(zhuǎn)為舊版API中的Calendar對象
	Calendar calendar = Calendar.getInstance();
	calendar.clear();
	calendar.setTimeZone(TimeZone.getTimeZone(zdt.getZone().getId()));
	calendar.setTimeInMillis(zdt.toEpochSecond() * 1000);
	System.out.println("calendar=" + calendar);
    }
}

七. 結(jié)語

至此，就把日期的格式化操作給大家講解完畢了，今天的內(nèi)容比較多且很實用。接下來就把今日重點給大家總結(jié)一下：

JDK 8中引入了新的日期和時間API，它們是不變類，默認按ISO 8601標準格式化和解析；
使用LocalDateTime可以非常方便地對日期和時間進行加減、調(diào)整日期和時間，且總是返回新對象；
使用isBefore()和isAfter()可以判斷日期和時間的先后；
使用Duration和Period可以表示兩個日期和時間的“區(qū)間間隔”；
ZonedDateTime是帶時區(qū)的日期和時間，可用于時區(qū)轉(zhuǎn)換；
ZonedDateTime和LocalDateTime可以相互轉(zhuǎn)換；
對ZonedDateTime或LocalDateTime進行格式化，需要使用DateTimeFormatter類；
DateTimeFormatter可以通過格式化字符串和Locale對日期和時間進行定制輸出；
Instant表示高精度時間戳，它可以和ZonedDateTime以及l(fā)ong互相轉(zhuǎn)換；
處理日期和時間時，盡量使用新的java.time包；
新舊兩種API之間可以進行轉(zhuǎn)換，舊版轉(zhuǎn)新版可以通過toInstant()方法轉(zhuǎn)換為Instant對象，然后再繼續(xù)轉(zhuǎn)換為ZonedDateTime；新版轉(zhuǎn)舊版需要借助long型的時間戳做一個“中轉(zhuǎn)”。

以上就是詳解Java的日期時間新特性的詳細內(nèi)容，更多關于Java 日期時間新特性的資料請關注腳本之家其它相關文章！

您可能感興趣的文章:

Maven實現(xiàn)自己的starter依賴
本文主要介紹了Maven實現(xiàn)自己的starter依賴，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2023-04-04
一文帶你搞懂什么是BIO
BIO英文全名是 blocking IO,也叫做阻塞IO,是最容易理解、最容易實現(xiàn)的IO工作方式，本文就來通過一些簡單的示例為大家講講什么是BIO吧
2023-06-06
java多線程讀取多個文件的方法
這篇文章主要為大家詳細介紹了java多線程讀取多個文件的方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2019-08-08
深入了解Java語言中的并發(fā)性選項有何不同
這篇文章主要介紹了深入了解Java語言中的并發(fā)性選項有何不同,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，,需要的朋友可以參考下
2019-06-06
基于Java網(wǎng)絡編程和多線程的多對多聊天系統(tǒng)
這篇文章主要介紹了基于Java網(wǎng)絡編程和多線程的多對多聊天系統(tǒng),文中有非常詳細的代碼示例,對正在學習java網(wǎng)絡編程的小伙伴們有非常好的幫助,需要的朋友可以參考下
2021-04-04
Java判斷兩個集合是否具有交集及如何獲得交集詳解
這篇文章主要給大家介紹了關于Java判斷兩個集合是否具有交集及如何獲得交集的相關資料,文中通過圖文以及實例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考借鑒價值,需要的朋友可以參考下
2023-07-07
如何將char類型的數(shù)字字符轉(zhuǎn)換成int類型問題
這篇文章主要介紹了如何將char類型的數(shù)字字符轉(zhuǎn)換成int類型問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2022-12-12
java實現(xiàn)簡單圖書管理系統(tǒng)
這篇文章主要為大家詳細介紹了java實現(xiàn)簡單圖書管理系統(tǒng)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2022-03-03
spring?jpa集成依賴的環(huán)境準備及實體類倉庫編寫教程
這篇文章主要為大家介紹了spring?jpa集成依賴的環(huán)境準備及實體類倉庫編寫教程，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
2022-03-03
ssm實現(xiàn)視頻的上傳與播放的示例代碼
這篇文章主要介紹了ssm實現(xiàn)視頻的上傳與播放的示例代碼，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2021-04-04