1?? 概念

Java的時間處理相關(guān)類主要是為了提供靈活、可靠地處理日期和時間的能力，以滿足各種應(yīng)用程序中對時間的需求。這些類旨在簡化日期和時間的操作，并提供一致的方法和功能來處理時間上的計算、格式化和解析。

?? 時間日期及處理類匯總

將Java中所有用于表示日期時間的類匯總，羅列如下表：

以上這些類都是Java標(biāo)準(zhǔn)庫中常用的時間處理類，根據(jù)具體的需求和場景選擇合適的類進(jìn)行使用。Java 8引入的java.time包更加推薦，提供了更多功能強(qiáng)大且易于使用的日期和時間處理功能。

將日期時間相關(guān)處理操作的類匯總，羅列如下表：

以上這些類都提供了豐富的日期時間格式處理功能，可以根據(jù)需求選擇適合的類來處理日期和時間的格式化和解析操作。其中，Java 8引入的 DateTimeFormatter 是推薦使用的方法，因為它提供了更多的選項和靈活性。

在本文中，主要介紹最常用的Date 、Calendar、SimpleDateFormat 、LocalDateTime、DateTimeFormatter等類的使用及操作方式等相關(guān)知識。而其他類的詳細(xì)操作方法API等信息，由于篇幅原因本文不再做更多介紹，感興趣的朋友可私信我一起交流。

• Date 類：Java 中最基本的日期和時間處理類。它表示一個特定的時間點，以毫秒為單位存儲。Date 類有一些基本的方法用于獲取、設(shè)置日期和時間，但它在處理日期和時間方面存在一些缺陷和限制；

• Calendar 類：用于表示日歷系統(tǒng)。它提供了一些方法來操作日期和時間，如獲取年、月、日、時、分、秒等。Calendar 可以將日期和時間字段進(jìn)行修改，并支持國際化和本地化的日期和時間顯示；

• SimpleDateFormat 類：用于格式化和解析日期和時間的類?？梢酝ㄟ^指定模式將 Date 對象格式化為字符串，也可以將字符串解析為 Date 對象；

• LocalDateTime類：Java 8 中的一個類，表示了一個不受時區(qū)影響的日期時間對象。它將日期和時間組合在一起，可以精確表示到納秒級別。相比于傳統(tǒng)的Date類，LocalDateTime提供了更多的操作方法和功能。
  使用LocalDateTime類可以進(jìn)行各種日期和時間相關(guān)的操作，例如計算、比較、格式化等。它提供了更直觀、簡潔和安全的方式來處理日期和時間，避免了以前的一些問題和陷阱，并使開發(fā)者能夠更輕松地編寫健壯和可維護(hù)的代碼。

• DateTimeFormatter類：Java 8 中的一個類，它提供了日期和時間對象的格式化和解析功能，用于將日期和時間對象轉(zhuǎn)換為字符串或從字符串解析成日期和時間對象。
  它的設(shè)計目的是為了彌補(bǔ)舊的日期和時間相關(guān)類（如SimpleDateFormat）在線程安全性、易用性和靈活性方面的不足。同時，它引入了新的日期和時間類（例如LocalDate、LocalTime、ZonedDateTime等），結(jié)合了DateTimeFormatter的強(qiáng)大功能，使得處理日期和時間的代碼更加簡潔和可讀，并且適合在多線程環(huán)境下使用。
  
  

2?? 優(yōu)勢和缺點

1. Date 類

• 優(yōu)點：簡單易懂，可以直接進(jìn)行日期和時間操作；
• 缺點：不夠靈活，實現(xiàn)上存在線程安全問題；

2. SimpleDateFormat 類

• 優(yōu)點：可以根據(jù)指定模式對日期和時間進(jìn)行格式化和解析；
• 缺點：在多線程環(huán)境下不安全；

3. Calendar 類

• 優(yōu)點：可以處理更復(fù)雜的日期和時間操作，提供了豐富的方法和功能；
• 缺點：使用起來較為繁瑣，并且性能較差；

4. DateTimeFormatter類

• 優(yōu)點：
  • 可擴(kuò)展性：支持自定義的模式符號，使開發(fā)人員能夠創(chuàng)建特定于項目或領(lǐng)域的日期時間格式；
  • 線程安全：線程安全的，可以在多個線程之間共享和重復(fù)使用；
  • 預(yù)定義模式：包含許多預(yù)定義的日期時間格式模式，例如ISO_LOCAL_DATE、ISO_OFFSET_DATE_TIME等，這些模式可直接使用；
  • 方法豐富：提供了各種方法來處理日期時間對象的格式化、解析、校驗和轉(zhuǎn)換。
• 缺點：
  • 學(xué)習(xí)曲線：提供了廣泛而靈活的選項，這使得學(xué)習(xí)和理解如何使用它可能需要一些時間和努力。

5. LocalDateTime類

• 優(yōu)點：
  • 不受時區(qū)限制：表示本地日期和時間，不受特定時區(qū)的影響。這使得它更適合處理與時區(qū)無關(guān)的日期和時間操作；
  • 不可變性和線程安全性：LocalDateTime是不可變的，任何操作都會返回一個新的實例。這保證了多線程環(huán)境下的安全性，并減少了由于修改實例而引起的潛在問題；
  • 解析和格式化：可以使用DateTimeFormatter類將其轉(zhuǎn)換為字符串形式，并從字符串解析為LocalDateTime。這使得數(shù)據(jù)的輸入和輸出變得非常方便；
  • 操作豐富：提供了一系列的方法來進(jìn)行日期和時間的增減、比較、格式化、計算等操作。這使得在處理日期和時間上的常見需求時變得更加便捷。
• 缺點:
  • 缺乏時區(qū)信息：由于LocalDateTime類不包含時區(qū)信息，因此在處理需要考慮時區(qū)的應(yīng)用程序中可能不夠適用。如果需要處理跨時區(qū)的日期和時間，建議使用ZonedDateTime或其他相關(guān)類。
    
    

3?? 使用

3.1 各時間日期類使用案例

下面是一個Java案例程序，演示如何使用上文各個日期和時間相關(guān)類以及對它們的一些簡單解釋說明：

import java.util.Date;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.ZonedDateTime;
import java.time.Duration;
import java.time.Period;

public class DateTimeExample {
    public static void main(String[] args) {
        // 使用java.util.Date獲取當(dāng)前日期和時間
        Date currentDate = new Date();
        System.out.println("當(dāng)前日期和時間： " + currentDate);

        // 使用java.util.Calendar獲取當(dāng)前日期
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;  // 注意：Calendar中月份是從0開始計數(shù)的，所以需要加1
        int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println("當(dāng)前日期： " + year + "-" + month + "-" + dayOfMonth);

        // 使用java.util.GregorianCalendar創(chuàng)建指定日期和時間的對象
        GregorianCalendar gregorianCalendar = new GregorianCalendar(2022, 0, 1, 12, 30, 0);  // 2022年1月1日 12:30:00
        Date specificDate = gregorianCalendar.getTime();
        System.out.println("指定日期和時間： " + specificDate);

        // 使用java.time.LocalDate獲取當(dāng)前日期
        LocalDate localDate = LocalDate.now();
        System.out.println("當(dāng)前日期： " + localDate);

        // 使用java.time.LocalTime獲取當(dāng)前時間
        LocalTime localTime = LocalTime.now();
        System.out.println("當(dāng)前時間： " + localTime);

        // 使用java.time.LocalDateTime獲取當(dāng)前日期和時間
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println("當(dāng)前日期和時間： " + localDateTime);

        // 使用java.time.ZonedDateTime獲取帶時區(qū)的日期和時間
        ZonedDateTime zonedDateTime = ZonedDateTime.now();
        System.out.println("當(dāng)前帶時區(qū)的日期和時間： " + zonedDateTime);

        // 使用java.time.Duration計算時間間隔
        Duration duration = Duration.between(localTime, LocalTime.of(14, 30));
        long hours = duration.toHours();
        long minutes = duration.toMinutes() % 60;
        System.out.println("當(dāng)前時間與今天14:30之間的時間間隔： " + hours + "小時" + minutes + "分鐘");

        // 使用java.time.Period計算日期間隔
        Period period = Period.between(localDate, LocalDate.of(2023, 12, 31));
        int years = period.getYears();
        int months = period.getMonths();
        int days = period.getDays();
        System.out.println("當(dāng)前日期與2023年12月31日之間的日期間隔： " + years + "年" + months + "月" + days + "日");
    }
}

以上的案例程序演示了如何使用這些類來獲取當(dāng)前日期和時間、創(chuàng)建特定的日期和時間對象，以及計算日期和時間之間的間隔。

運(yùn)行結(jié)果如下：

當(dāng)前日期和時間： Mon Jun 26 17:26:27 CST 2023
當(dāng)前日期： 2023-6-26
指定日期和時間： Sat Jan 01 12:30:00 CST 2022
當(dāng)前日期： 2023-06-26
當(dāng)前時間： 17:26:28.114
當(dāng)前日期和時間： 2023-06-26T17:26:28.114
當(dāng)前帶時區(qū)的日期和時間： 2023-06-26T17:26:28.122+08:00[Asia/Shanghai]
當(dāng)前時間與今天14:30之間的時間間隔： -2小時-56分鐘
當(dāng)前日期與2023年12月31日之間的日期間隔： 0年6月5日

3.2 各時間日期處理類使用案例

下面是一個Java案例程序，演示如何使用上文各個日期和時間相關(guān)處理操作類以及對它們的一些簡單解釋說明：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Date;
import java.util.Formatter;
import java.util.Locale;

public class FormattingExample {
    public static void main(String[] args) {
        Date date = new Date();
        // 使用 java.text.DateFormat 格式化日期和時間
        DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.LONG, Locale.US);
        String formattedDate = dateFormat.format(date);
        System.out.println("格式化的日期：" + formattedDate);

        // 使用 java.text.SimpleDateFormat 自定義日期和時間格式化
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = simpleDateFormat.format(date);
        System.out.println("自定義格式化的日期和時間：" + formattedDateTime);

        // 使用 java.time.format.DateTimeFormatter 格式化日期和時間
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedLocalDateTime = LocalDateTime.now().format(dateTimeFormatter);
        System.out.println("使用 DateTimeFormatter 格式化的當(dāng)前日期和時間：" + formattedLocalDateTime);

        // 使用 java.util.Formatter 進(jìn)行格式化
        Formatter formatter = new Formatter();
        String formattedString = formatter.format("Hello, %s! Today is %tF.", "John", date).toString();
        System.out.println("使用 Formatter 進(jìn)行格式化：" + formattedString);
        formatter.close();

        // 使用 java.time.format.FormatStyle 定義預(yù)定義的格式風(fēng)格
        String formattedStyleDateTime = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM).format(LocalDateTime.now());
        System.out.println("使用 FormatStyle 定義的格式風(fēng)格：" + formattedStyleDateTime);
    }
}

上述案例程序演示了如何使用這些類和方法來格式化日期和時間，包括使用預(yù)定義風(fēng)格、自定義格式化模式等。運(yùn)行結(jié)果如下：

格式化的日期：June 26, 2023
自定義格式化的日期和時間：2023-06-26 17:40:52
使用 DateTimeFormatter 格式化的當(dāng)前日期和時間：2023-06-26 17:40:53
使用 Formatter 進(jìn)行格式化：Hello, John! Today is 2023-06-26.
使用 FormatStyle 定義的格式風(fēng)格：2023-6-26 17:40:53

3.3 Date 類

Java的Date類是一個用于處理日期和時間的基本類，它提供了一系列方法來操縱和顯示日期、時間和相關(guān)信息。下面是Java Date類的全部操作方法API：

下面是一個演示如何使用Date類的Java案例程序，包含了代碼注釋說明：

import java.util.Date;

public class DateExample {
    public static void main(String[] args) {
        // 使用無參構(gòu)造函數(shù)創(chuàng)建一個Date對象，表示當(dāng)前系統(tǒng)日期和時間
        Date currentDate = new Date();
        System.out.println("Current Date: " + currentDate);

        // 使用指定的毫秒數(shù)創(chuàng)建一個Date對象，表示從1970年1月1日開始的特定時間點
        long milliseconds = 1636382593000L;
        Date specificDate = new Date(milliseconds);
        System.out.println("Specific Date: " + specificDate);

        // 獲取日期和時間信息

        // 返回自 1970 年 1 月 1 日至當(dāng)前時間的毫秒數(shù)差值
        long timeDifference = currentDate.getTime();
        System.out.println("Time difference (milliseconds): " + timeDifference);

        // 獲取表示年份的值（從1900開始）
        int year = currentDate.getYear();
        System.out.println("Year: " + (year + 1900));

        // 獲取表示月份的值（范圍為0-11）
        int month = currentDate.getMonth() + 1;
        System.out.println("Month: " + month);

        // 獲取表示日期的值
        int date = currentDate.getDate();
        System.out.println("Date: " + date);

        // 獲取表示星期幾的值（范圍為0-6，其中0代表星期日）
        int dayOfWeek = currentDate.getDay();
        System.out.println("Day of week: " + dayOfWeek);

        // 獲取小時數(shù)（24小時制）
        int hours = currentDate.getHours();
        System.out.println("Hours: " + hours);

        // 獲取分鐘數(shù)
        int minutes = currentDate.getMinutes();
        System.out.println("Minutes: " + minutes);

        // 獲取秒數(shù)
        int seconds = currentDate.getSeconds();
        System.out.println("Seconds: " + seconds);

        // 設(shè)置日期和時間信息

        // 設(shè)置日期對象的毫秒數(shù)
        specificDate.setTime(System.currentTimeMillis());
        System.out.println("Updated Specific Date: " + specificDate);

        // 設(shè)置年份（從1900開始）
        specificDate.setYear(122);
        System.out.println("Updated Specific Date (Year): " + specificDate);

        // 設(shè)置月份（范圍為0-11）
        specificDate.setMonth(10);
        System.out.println("Updated Specific Date (Month): " + specificDate);

        // 設(shè)置日期
        specificDate.setDate(8);
        System.out.println("Updated Specific Date (Date): " + specificDate);

        // 設(shè)置小時數(shù)（24小時制）
        specificDate.setHours(15);
        System.out.println("Updated Specific Date (Hours): " + specificDate);

        // 設(shè)置分鐘數(shù)
        specificDate.setMinutes(30);
        System.out.println("Updated Specific Date (Minutes): " + specificDate);

        // 設(shè)置秒數(shù)
        specificDate.setSeconds(45);
        System.out.println("Updated Specific Date (Seconds): " + specificDate);

        // 其他操作方法

        // 檢查日期對象是否在給定日期之前
        boolean before = currentDate.before(specificDate);
        System.out.println("Is current date before specific date? " + before);

        // 檢查日期對象是否在給定日期之后
        boolean after = specificDate.after(currentDate);
        System.out.println("Is specific date after current date? " + after);

        // 比較兩個日期對象是否相等
        boolean equals = currentDate.equals(specificDate);
        System.out.println("Are the two dates equal? " + equals);

        // 創(chuàng)建并返回日期對象的拷貝
        Date copy = (Date) specificDate.clone();
        System.out.println("Copy of specific date: " + copy);

        // 將日期對象轉(zhuǎn)換為字符串表示形式
        String dateString = specificDate.toString();
        System.out.println("Specific date as string: " + dateString);
    }
}

運(yùn)行結(jié)果如下：

Current Date: Mon Jun 26 19:51:15 CST 2023
Specific Date: Mon Nov 08 22:43:13 CST 2021
Time difference (milliseconds): 1687780275710
Year: 2023
Month: 6
Date: 26
Day of week: 1
Hours: 19
Minutes: 51
Seconds: 15
Updated Specific Date: Mon Jun 26 19:51:15 CST 2023
Updated Specific Date (Year): Sun Jun 26 19:51:15 CST 2022
Updated Specific Date (Month): Sat Nov 26 19:51:15 CST 2022
Updated Specific Date (Date): Tue Nov 08 19:51:15 CST 2022
Updated Specific Date (Hours): Tue Nov 08 15:51:15 CST 2022
Updated Specific Date (Minutes): Tue Nov 08 15:30:15 CST 2022
Updated Specific Date (Seconds): Tue Nov 08 15:30:45 CST 2022
Is current date before specific date? false
Is specific date after current date? false
Are the two dates equal? false
Copy of specific date: Tue Nov 08 15:30:45 CST 2022
Specific date as string: Tue Nov 08 15:30:45 CST 2022

3.4 Calendar 類

Java的Calendar類是用于日期和時間處理的重要類之一，它提供了豐富的操作方法來對日期進(jìn)行增減、比較以及格式化等操作。下面是Java Calendar類的全部操作方法API的介紹：

以下是一個使用Java Calendar 類全部操作方法API的案例程序，代碼都有解釋說明：

import java.util.Calendar;
import java.util.Date;

public class CalendarExample {
    public static void main(String[] args) {
        // 創(chuàng)建一個Calendar實例
        Calendar calendar = Calendar.getInstance();

        // get(int field): 返回給定字段的值
        int year = calendar.get(Calendar.YEAR);
        System.out.println("當(dāng)前年份: " + year);

        int month = calendar.get(Calendar.MONTH);
        System.out.println("當(dāng)前月份: " + (month + 1)); // 月份從0開始，所以要加1

        int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println("今天是本月的第幾天: " + dayOfMonth);

        // set(int field, int value): 設(shè)置給定字段的值
        calendar.set(Calendar.YEAR, 2022);
        System.out.println("修改后的年份: " + calendar.get(Calendar.YEAR));

        // add(int field, int amount): 將指定字段的值增加指定的數(shù)量
        calendar.add(Calendar.MONTH, 2);
        System.out.println("兩個月后的月份: " + (calendar.get(Calendar.MONTH) + 1));

        // getTime(): 返回表示當(dāng)前Calendar對象的時間戳，即Date對象
        Date date = calendar.getTime();
        System.out.println("當(dāng)前日期時間: " + date);

        // getTimeInMillis(): 返回表示當(dāng)前Calendar對象的時間戳，以毫秒為單位
        long timestamp = calendar.getTimeInMillis();
        System.out.println("當(dāng)前時間戳: " + timestamp);

        // setTime(Date date): 將Calendar對象的值設(shè)置為給定日期所代表的時間
        Date newDate = new Date();
        calendar.setTime(newDate);
        System.out.println("修改后的日期時間: " + calendar.getTime());

        // getActualMaximum(int field): 返回指定字段的最大允許值
        int maxMonth = calendar.getActualMaximum(Calendar.MONTH);
        System.out.println("當(dāng)前年份最大的月份是: " + (maxMonth + 1));

        // getActualMinimum(int field): 返回指定字段的最小允許值
        int minMonth = calendar.getActualMinimum(Calendar.MONTH);
        System.out.println("當(dāng)前年份最小的月份是: " + (minMonth + 1));

        // before(Object when): 檢查當(dāng)前Calendar對象表示的時間是否在給定時間之前
        Calendar comparisonCalendar = Calendar.getInstance();
        comparisonCalendar.set(Calendar.YEAR, 2022);
        boolean isBefore = calendar.before(comparisonCalendar);
        System.out.println("當(dāng)前日期時間是否在2022年之前: " + isBefore);

        // after(Object when): 檢查當(dāng)前Calendar對象表示的時間是否在給定時間之后
        boolean isAfter = calendar.after(comparisonCalendar);
        System.out.println("當(dāng)前日期時間是否在2022年之后: " + isAfter);

        // compareTo(Calendar anotherCalendar): 比較兩個Calendar對象的時間順序
        int comparisonResult = calendar.compareTo(comparisonCalendar);
        System.out.println("當(dāng)前日期時間與指定日期時間的比較結(jié)果: " + comparisonResult);

        // clear(): 清除所有字段的值，將Calendar對象重置為初始狀態(tài)
        calendar.clear();
        System.out.println("清除后的年份: " + calendar.get(Calendar.YEAR));

        // getDisplayName(int field, int style, Locale locale): 返回指定字段的本地化名稱
        String monthName = calendar.getDisplayName(Calendar.MONTH, Calendar.LONG, java.util.Locale.getDefault());
        System.out.println("當(dāng)前月份的本地化名稱: " + monthName);

        // isSet(int field): 檢查指定字段是否已設(shè)置為具體值
        boolean isYearSet = calendar.isSet(Calendar.YEAR);
        System.out.println("年份字段是否已設(shè)置: " + isYearSet);

        // roll(int field, boolean up): 將指定字段的值“滾動”，即在不改變更大字段的情況下增減指定字段的值
        calendar.set(Calendar.DAY_OF_MONTH, 31); // 設(shè)置為一個月的最后一天
        calendar.roll(Calendar.DAY_OF_MONTH, false); // 減少一個月的天數(shù)，而不影響月份
        System.out.println("一個月前的日期: " + calendar.getTime());
    }
}

運(yùn)行結(jié)果如下：

當(dāng)前年份: 2023
當(dāng)前月份: 6
今天是本月的第幾天: 26
修改后的年份: 2022
兩個月后的月份: 8
當(dāng)前日期時間: Fri Aug 26 20:47:49 CST 2022
當(dāng)前時間戳: 1661518069288
修改后的日期時間: Mon Jun 26 20:47:49 CST 2023
當(dāng)前年份最大的月份是: 12
當(dāng)前年份最小的月份是: 1
當(dāng)前日期時間是否在2022年之前: false
當(dāng)前日期時間是否在2022年之后: true
當(dāng)前日期時間與指定日期時間的比較結(jié)果: 1
清除后的年份: 1970
當(dāng)前月份的本地化名稱: 一月
年份字段是否已設(shè)置: true
一個月前的日期: Fri Jan 30 00:00:00 CST 1970

3.5 SimpleDateFormat 類

SimpleDateFormat類用于將日期對象轉(zhuǎn)換為字符串（格式化），或?qū)⒆址馕鰹槿掌趯ο螅⒏鶕?jù)指定的模式進(jìn)行日期和時間的格式化與解析。它提供了一系列方法來設(shè)置、獲取和操作日期格式、時區(qū)以及相關(guān)符號信息等。通過使用這些方法，我們可以靈活地處理不同格式的日期和時間數(shù)據(jù)。

注意：在使用SimpleDateFormat類進(jìn)行日期和時間的格式化和解析時，請確保模式字符串（pattern）的正確性，否則可能會導(dǎo)致意外的結(jié)果或錯誤的解析。模式字符串中的特殊字符必須按照規(guī)定的方式使用，例如yyyy表示四位年份，MM表示兩位月份等。詳細(xì)的模式字符含義可以參考Java官方文檔中的具體說明。

同時，請注意SimpleDateFormat類不是線程安全的，如果在多線程環(huán)境中使用，請采取適當(dāng)?shù)耐酱胧?/p>

下面是Java SimpleDateFormat類的全部操作方法API的介紹：

以下是一個使用SimpleDateFormat類的全部操作方法的Java案例程序，代碼都有解釋說明：

import java.text.DateFormatSymbols;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;

public class SimpleDateFormatExample {
    public static void main(String[] args) {
        Date now = new Date();

        // 創(chuàng)建一個新的SimpleDateFormat對象，使用指定的模式
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 根據(jù)此日期格式將給定的日期對象格式化為字符串，并返回結(jié)果
        String format = dateFormat.format(now);
        System.out.println("格式化的當(dāng)前日期時間: " + format);

        // 將給定的本地化模式應(yīng)用于此日期格式
        dateFormat.applyLocalizedPattern("HH時mm分ss秒");
        format = dateFormat.format(now);
        System.out.println("本地化模式格式化的當(dāng)前日期時間: " + format);

        // 將給定的模式應(yīng)用于此日期格式
        dateFormat.applyPattern("yyyyMMddHHmmss");
        format = dateFormat.format(now);
        System.out.println("給定的模式格式化的當(dāng)前日期時間: " +format);

        // 將給定的字符串解析為日期對象，根據(jù)此日期格式的規(guī)則
        String dateString = "20220103120000";
        try {
            Date parsedDate = dateFormat.parse(dateString);
            System.out.println("解析得到的日期對象: " + parsedDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        // 指定解析過程是否寬松
        dateFormat.setLenient(false);

        // 返回解析過程是否寬松的設(shè)置
        boolean isLenient = dateFormat.isLenient();
        System.out.println("解析過程是否寬松: " + isLenient);

        // 設(shè)置此日期格式的時區(qū)
        dateFormat.setTimeZone(TimeZone.getTimeZone("GMT+2"));
        System.out.println("時區(qū): " + dateFormat.getTimeZone().getID());

        // 設(shè)置與此日期格式關(guān)聯(lián)的日歷
        Calendar calendar = Calendar.getInstance();
        dateFormat.setCalendar(calendar);
        System.out.println("關(guān)聯(lián)的日歷: " + dateFormat.getCalendar().getTime());

        // 返回此日期格式的字符串表示形式
        String pattern = dateFormat.toPattern();
        System.out.println("日期格式的字符串表示形式: " + pattern);

        // 返回此日期格式的本地化字符串表示形式
        String localizedPattern = dateFormat.toLocalizedPattern();
        System.out.println("日期格式的本地化字符串表示形式: " + localizedPattern);

        // 返回日期格式的符號信息，例如星期幾名稱、月份名稱等
        DateFormatSymbols symbols = dateFormat.getDateFormatSymbols();
        String[] months = symbols.getMonths();
        System.out.println("月份名稱: " + months[calendar.get(Calendar.MONTH)]);

        // 設(shè)置日期格式的符號信息
        DateFormatSymbols newSymbols = new DateFormatSymbols();
        newSymbols.setMonths(new String[]{"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"});
        dateFormat.setDateFormatSymbols(newSymbols);

        months = dateFormat.getDateFormatSymbols().getMonths();
        System.out.println("新月份名稱: " + months[calendar.get(Calendar.MONTH)]);
    }
}

這個例子演示了如何使用SimpleDateFormat類的全部操作方法。通過實例化SimpleDateFormat對象并調(diào)用相應(yīng)的方法，我們可以根據(jù)指定的模式將日期對象格式化為字符串，或者解析給定的字符串為日期對象。

程序中還演示了如何設(shè)置和獲取時區(qū)、日歷、模式字符串以及日期格式的符號信息等。
運(yùn)行結(jié)果如下：

格式化的當(dāng)前日期時間: 2023-06-26 21:36:41
本地化模式格式化的當(dāng)前日期時間: 21時36分41秒
給定的模式格式化的當(dāng)前日期時間: 20230626213641
解析得到的日期對象: Mon Jan 03 12:00:00 CST 2022
解析過程是否寬松: false
時區(qū): GMT+02:00
關(guān)聯(lián)的日歷: Mon Jun 26 21:36:41 CST 2023
日期格式的字符串表示形式: yyyyMMddHHmmss
日期格式的本地化字符串表示形式: aaaannjjHHmmss
月份名稱: 六月
新月份名稱: June

3.6 LocalDateTime 類

下面是LocalDateTime 類的全部操作方法API及其說明：

這個表格列出了LocalDateTime類的全部操作方法，包括創(chuàng)建對象、獲取日期時間部分、比較、加減日期時間值、格式化輸出以及時間間隔計算等。你可以根據(jù)具體需求選擇適合的方法來操作LocalDateTime對象。

下面是一個使用LocalDateTime類的操作方法的示例程序，演示了如何使用其中的一些常用方法：

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;

public class LocalDateTimeExample {
    public static void main(String[] args) {
        // 返回當(dāng)前日期時間
        LocalDateTime currentDateTime = LocalDateTime.now();
        System.out.println("當(dāng)前日期時間: " + currentDateTime);

        // 返回指定時區(qū)的當(dāng)前日期時間
        LocalDateTime dateTimeInZone = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
        System.out.println("指定時區(qū)的當(dāng)前日期時間: " + dateTimeInZone);

        // 使用指定時鐘對象返回當(dāng)前日期時間
        Clock clock = Clock.systemDefaultZone();
        LocalDateTime dateTimeWithClock = LocalDateTime.now(clock);
        System.out.println("使用指定時鐘對象返回當(dāng)前日期時間: " + dateTimeWithClock);

        // 創(chuàng)建指定日期時間的對象
        LocalDateTime customDateTime = LocalDateTime.of(2022, Month.JUNE, 15, 10, 30);
        System.out.println("創(chuàng)建指定日期時間的對象: " + customDateTime);

        // 根據(jù)指定的日期和時間創(chuàng)建對象
        LocalDate date = LocalDate.of(2022, Month.JUNE, 15);
        LocalTime time = LocalTime.of(10, 30);
        LocalDateTime dateTimeFromParts = LocalDateTime.of(date, time);
        System.out.println("根據(jù)指定的日期和時間創(chuàng)建對象: " + dateTimeFromParts);

        // 將指定字符串解析為對象
        String dateString = "2022-06-15 10:30:00";
        LocalDateTime parsedDateTime = LocalDateTime.parse(dateString, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("解析后的日期時間: " + parsedDateTime);

        // 獲取信息
        LocalDate localDate = dateTimeFromParts.toLocalDate();
        System.out.println("日期部分: " + localDate);

        LocalTime localTime = dateTimeFromParts.toLocalTime();
        System.out.println("時間部分: " + localTime);

        int year = dateTimeFromParts.getYear();
        System.out.println("年份: " + year);

        Month month = dateTimeFromParts.getMonth();
        System.out.println("月份: " + month);

        int monthValue = dateTimeFromParts.getMonthValue();
        System.out.println("月份值: " + monthValue);

        int dayOfMonth = dateTimeFromParts.getDayOfMonth();
        System.out.println("月份中的天數(shù): " + dayOfMonth);

        int hour = dateTimeFromParts.getHour();
        System.out.println("小時數(shù): " + hour);

        int minute = dateTimeFromParts.getMinute();
        System.out.println("分鐘數(shù): " + minute);

        int second = dateTimeFromParts.getSecond();
        System.out.println("秒數(shù): " + second);

        int nano = dateTimeFromParts.getNano();
        System.out.println("納秒數(shù): " + nano);


        // 創(chuàng)建一個指定的日期時間
        LocalDateTime comparisonDateTime = LocalDateTime.of(2022, 6, 15, 12, 0, 0);
        // 檢查當(dāng)前日期時間是否在指定日期時間之后
        boolean isAfter = currentDateTime.isAfter(comparisonDateTime);
        if (isAfter) {
            System.out.println("當(dāng)前日期時間在指定日期時間之后");
        } else {
            System.out.println("當(dāng)前日期時間在指定日期時間之前或相同");
        }

        // 加減操作
        LocalDateTime plusYears = dateTimeFromParts.plusYears(1);
        System.out.println("加1年后的日期時間: " + plusYears);

        LocalDateTime minusMonths = dateTimeFromParts.minusMonths(2);
        System.out.println("減去2個月后的日期時間: " + minusMonths);

        // 其他操作
        boolean isSupported = dateTimeFromParts.isSupported(ChronoField.DAY_OF_WEEK);
        System.out.println("是否支持星期字段: " + isSupported);

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = dateTimeFromParts.format(formatter);
        System.out.println("格式化后的日期時間: " + formattedDateTime);

        boolean isSupportedUnit = dateTimeFromParts.isSupported(ChronoUnit.HOURS);
        System.out.println("是否支持小時單位計算: " + isSupportedUnit);

        LocalDateTime futureDateTime = LocalDateTime.of(2023, Month.DECEMBER, 31, 23, 59);
        long daysUntilFutureDate = currentDateTime.until(futureDateTime, ChronoUnit.DAYS);
        System.out.println(currentDateTime + "與 "+ futureDateTime +" 之間的天數(shù)間隔: " + daysUntilFutureDate);
    }
}

該示例程序演示了如何使用LocalDateTime類的各種操作方法。運(yùn)行程序結(jié)果如下：

當(dāng)前日期時間: 2023-06-26T22:12:10.751
指定時區(qū)的當(dāng)前日期時間: 2023-06-26T22:12:10.751
使用指定時鐘對象返回當(dāng)前日期時間: 2023-06-26T22:12:10.751
創(chuàng)建指定日期時間的對象: 2022-06-15T10:30
根據(jù)指定的日期和時間創(chuàng)建對象: 2022-06-15T10:30
解析后的日期時間: 2022-06-15T10:30
日期部分: 2022-06-15
時間部分: 10:30
年份: 2022
月份: JUNE
月份值: 6
月份中的天數(shù): 15
小時數(shù): 10
分鐘數(shù): 30
秒數(shù): 0
納秒數(shù): 0
當(dāng)前日期時間在指定日期時間之后
加1年后的日期時間: 2023-06-15T10:30
減去2個月后的日期時間: 2022-04-15T10:30
是否支持星期字段: true
格式化后的日期時間: 2022-06-15 10:30:00
是否支持小時單位計算: true
2023-06-26T22:12:10.751與 2023-12-31T23:59 之間的天數(shù)間隔: 188

3.7 DateTimeFormatter 類

下面是DateTimeFormatter類的全部操作方法API及其說明：

下面是一個使用DateTimeFormatter類的操作方法的示例程序，演示了如何使用其中的一些方法：

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DecimalStyle;
import java.time.format.FormatStyle;
import java.time.format.ResolverStyle;
import java.util.Locale;

public class DateTimeFormatterExample {
    public static void main(String[] args) {
        // 使用指定的模式字符串創(chuàng)建對象
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
        LocalDateTime dateTime = LocalDateTime.now();
        String formattedDateTime = dateTime.format(formatter);
        System.out.println("格式化后的日期時間: " + formattedDateTime);


        // 創(chuàng)建一個本地化日期時間格式的對象
        DateTimeFormatter localizedFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        String localizedFormattedDateTime = dateTime.format(localizedFormatter);
        System.out.println("本地化格式化后的日期時間: " + localizedFormattedDateTime);


        // 創(chuàng)建一個本地化日期時間格式的對象，并指定日期部分和時間部分的顯示樣式
        localizedFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM, FormatStyle.SHORT);
        String localizedCustomFormattedDateTime = dateTime.format(localizedFormatter);
        System.out.println("指定日期時間樣式的本地化格式化后的日期時間: " + localizedCustomFormattedDateTime);


        // 預(yù)定義的日期、時間和日期時間格式
        DateTimeFormatter dateFormatter = DateTimeFormatter.ISO_LOCAL_DATE;
        DateTimeFormatter timeFormatter = DateTimeFormatter.ISO_LOCAL_TIME;
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        String formattedDate = dateTime.format(dateFormatter);
        String formattedTime = dateTime.format(timeFormatter);
        String formattedDateTime2 = dateTime.format(dateTimeFormatter);
        System.out.println("預(yù)定義的日期格式化結(jié)果: " + formattedDate);
        System.out.println("預(yù)定義的時間格式化結(jié)果: " + formattedTime);
        System.out.println("預(yù)定義的日期時間格式化結(jié)果: " + formattedDateTime2);


        // 返回一個新的對象，其中的地區(qū)設(shè)置為指定的地區(qū)
        DateTimeFormatter withLocaleFormatter = dateTimeFormatter.withLocale(Locale.CHINA);
        String formattedWithLocaleDateTime = dateTime.format(withLocaleFormatter);
        System.out.println("指定地區(qū)的格式化后的日期時間: " + formattedWithLocaleDateTime);


        // 返回一個新的對象，其中的格式設(shè)置為指定的十進(jìn)制樣式
        DateTimeFormatter withDecimalStyleFormatter = withLocaleFormatter.withDecimalStyle(DateTimeFormatter.ISO_TIME.getDecimalStyle());
        String formattedWithDecimalStyleDateTime = dateTime.format(withDecimalStyleFormatter);
        System.out.println("指定十進(jìn)制樣式的格式化后的日期時間: " + formattedWithDecimalStyleDateTime);


        // 返回一個新的對象，其中的解析方式設(shè)置為指定的解析方式
        DateTimeFormatter withResolverStyleFormatter = withDecimalStyleFormatter.withResolverStyle(DateTimeFormatter.ISO_DATE.getResolverStyle());
        String date = "2022-06-15T10:30:00.484";
        LocalDateTime parsedDateTime = LocalDateTime.parse(date, withResolverStyleFormatter);
        System.out.println("嚴(yán)格解析后的日期時間: " + parsedDateTime);


        // 將字符串解析為TemporalAccessor對象（例如LocalDate、LocalTime或LocalDateTime等）
        String dateString = "2022-06-15";
        LocalDate parsedDate = LocalDate.parse(dateString, dateFormatter);
        System.out.println("解析后的日期: " + parsedDate);


        // 將指定的TemporalAccessor對象格式化為字符串
        LocalDateTime localDateTime = LocalDateTime.of(2022, 6, 15, 10, 30);
        String formattedCustomDateTime = localDateTime.format(formatter);
        System.out.println("自定義日期時間格式化結(jié)果: " + formattedCustomDateTime);


        // 返回該DateTimeFormatter對象使用的十進(jìn)制樣式
        DecimalStyle decimalStyle = withResolverStyleFormatter.getDecimalStyle();
        System.out.println("該DateTimeFormatter對象使用的十進(jìn)制樣式: " + decimalStyle);


        // 返回該DateTimeFormatter對象的解析方式
        ResolverStyle resolverStyle = withResolverStyleFormatter.getResolverStyle();
        System.out.println("該DateTimeFormatter對象的解析方式: " + resolverStyle);
    }
}

程序運(yùn)行結(jié)果如下：

格式化后的日期時間: 2023/06/26 22:38:28
本地化格式化后的日期時間: 2023年6月26日 下午10時38分28秒
指定日期時間樣式的本地化格式化后的日期時間: 2023-6-26 下午10:38
預(yù)定義的日期格式化結(jié)果: 2023-06-26
預(yù)定義的時間格式化結(jié)果: 22:38:28.126
預(yù)定義的日期時間格式化結(jié)果: 2023-06-26T22:38:28.126
指定地區(qū)的格式化后的日期時間: 2023-06-26T22:38:28.126
指定十進(jìn)制樣式的格式化后的日期時間: 2023-06-26T22:38:28.126
嚴(yán)格解析后的日期時間: 2022-06-15T10:30:00.484
解析后的日期: 2022-06-15
自定義日期時間格式化結(jié)果: 2022/06/15 10:30:00
該DateTimeFormatter對象使用的十進(jìn)制樣式: DecimalStyle[0+-.]
該DateTimeFormatter對象的解析方式: STRICT

3.8 使用技巧

為了更好地使用Java的時間處理相關(guān)類，以下是一些使用技巧：

• 盡量使用java.time包代替舊的日期類：Java 8引入了新的日期和時間API，位于java.time包中，它們提供了更好的設(shè)計和功能；
• 使用線程安全的類：如果需要在多線程環(huán)境中使用日期和時間類，建議使用線程安全的類，如Instant、LocalDateTime等；
• 謹(jǐn)慎使用舊的Date和Calendar類：由于它們的局限性和不足，使用上需謹(jǐn)慎并注意線程安全問題。
  
  

4?? 應(yīng)用場景

Java的時間處理相關(guān)類適用于各種應(yīng)用場景，包括但不限于以下幾個常見場景：

1. 日期和時間計算：Java的時間處理類可以用于執(zhí)行各種日期和時間的計算操作。例如，你可以使用LocalDate和LocalDateTime類來增加或減少天數(shù)、月份、年份以及其他日期部分。

2. 日期和時間格式化和解析：Java的時間處理類提供了強(qiáng)大的日期和時間格式化和解析功能。你可以使用DateTimeFormatter類來將日期對象轉(zhuǎn)換為指定格式的字符串，并可以將字符串解析為日期對象。

3. 日期和時間比較和排序：通過使用Java的時間處理類，可以方便地比較和排序日期和時間。你可以使用compareTo方法進(jìn)行比較，以確定一個日期是在另一個日期之前、之后還是相等。

4. 跨時區(qū)操作：Java的時間處理類支持跨時區(qū)的操作。你可以使用ZoneId類和ZonedDateTime類來管理和轉(zhuǎn)換不同時區(qū)的日期和時間。

5. 定時任務(wù)調(diào)度：Java的時間處理類可以與定時任務(wù)調(diào)度器結(jié)合使用，例如Spring框架中的Cron表達(dá)式觸發(fā)器或JavaSE中的Timer類，以實現(xiàn)定時任務(wù)的調(diào)度和觸發(fā)。

總而言之，Java的時間處理相關(guān)類適用于廣泛的應(yīng)用場景，包括日期和時間的計算、格式化和解析、比較和排序、跨時區(qū)操作、定時任務(wù)調(diào)度、數(shù)據(jù)庫持久化以及業(yè)務(wù)邏輯中的日期計算等。無論你是開發(fā)桌面應(yīng)用、Web應(yīng)用還是后端系統(tǒng)，Java的時間處理類都提供了豐富的功能和方法，方便處理各種日期和時間操作需求。

5??擴(kuò)展：第三方框架中對日期時間處理的支持

Spring框架提供了多種對Java日期時間處理的工具類支持。下面列出了Spring中一些常用的日期時間處理相關(guān)的類和模塊：

1. org.springframework.format.datetime.DateFormatter：日期格式化器，用于將日期對象轉(zhuǎn)換為字符串、字符串轉(zhuǎn)換為日期對象。

2. org.springframework.format.annotation.DateTimeFormat：日期時間格式注解，用于指定特定字段或方法參數(shù)的日期時間格式。

3. org.springframework.util.DateUtils：日期時間工具類，提供了各種日期操作的靜態(tài)輔助方法，例如日期比較、格式化、解析等。

4. org.springframework.scheduling.support.CronTrigger：基于Cron表達(dá)式的觸發(fā)器，可以使用Cron表達(dá)式定義定時任務(wù)的執(zhí)行規(guī)則，靈活控制任務(wù)的調(diào)度時間。

除了這些類和模塊，Spring還通過整合其他第三方日期時間處理庫，如Joda-Time和java.time（JSR-310），為應(yīng)用程序提供更強(qiáng)大的日期時間處理功能。Spring在不同的模塊中提供了對這些庫的集成和支持，例如在Spring Boot中，可以輕松配置和使用Java 8日期時間API或Joda-Time。

除了Spring框架，還有一些其他流行的Java框架提供對日期時間處理的工具類支持。以下是其中幾個常用的框架：

1. Apache Commons Lang：Apache Commons Lang是一個通用的Java工具庫，提供了許多實用的工具類和方法。它包含DateUtils、FastDateFormat等類，用于日期時間的解析、格式化和操作。

2. Joda-Time：Joda-Time是一個非常流行的日期時間處理庫，在Java 8之前被廣泛使用。它提供了豐富的日期時間類和方法，如DateTime、LocalDate、Period等，以及靈活的日期時間操作和計算功能。

3. ThreeTen-Extra：ThreeTen-Extra是在Java 8日期時間API基礎(chǔ)上構(gòu)建的擴(kuò)展庫。它提供了額外的日期時間類和工具，如季度、年賬、時間間隔計算等功能。

這些框架提供了不同程度和不同特點的日期時間處理工具類支持，可以根據(jù)具體需求選擇適合的框架。無論是處理基本的日期比較和格式化，還是執(zhí)行復(fù)雜的日期計算和跨時區(qū)操作，這些框架都能滿足各種應(yīng)用場景的需求。

?? 總結(jié)

本文介紹了Java日期時間處理類的概念，以及它們在日期和時間操作中的優(yōu)勢和缺點。我們討論了Java提供的一些主要日期時間處理類，包括Date、Calendar、SimpleDateFormat、LocalDateTime和DateTimeFormatter等。我們分析了它們的使用方法，并提供了一些使用案例和技巧。

這些Java日期時間處理類提供了豐富的功能和靈活性，使得我們可以方便地執(zhí)行日期和時間的計算、格式化、解析和比較。然而，每個類都有自己的特點和適用范圍。例如，Date類在早期被廣泛使用，但它的缺點也逐漸顯現(xiàn)出來，不推薦作為首選。LocalDateTime和DateTimeFormatter則是Java 8引入的新API，提供了更方便和優(yōu)雅的方式來處理日期和時間。

在應(yīng)用場景方面，Java的日期時間處理類適用于各種應(yīng)用需求。我們可以將其用于日期和時間計算、格式化和解析、跨時區(qū)操作、定時任務(wù)調(diào)度、數(shù)據(jù)庫持久化以及業(yè)務(wù)邏輯中的日期計算等。這些類提供了強(qiáng)大的功能和方法，能夠滿足不同項目的日期時間處理需求。

最后，我們提到了一些第三方框架，如Spring和Apache Commons Lang，它們也提供了對Java日期時間處理的支持。這些框架通過整合其他庫或提供自己實現(xiàn)的工具類，進(jìn)一步增強(qiáng)了日期時間處理的功能和靈活性。

綜上所述，Java日期時間處理類提供了豐富的工具和方法來處理各種日期時間操作。無論是開發(fā)桌面應(yīng)用、Web應(yīng)用還是后端系統(tǒng)，Java的日期時間處理類都能滿足不同場景和需求，讓開發(fā)人員更輕松地處理日期時間相關(guān)任務(wù)。

? 溫習(xí)回顧上一篇（點擊跳轉(zhuǎn)）：
《【Java基礎(chǔ)教程】（三十六）常用類庫篇 · 第六講：數(shù)學(xué)運(yùn)算類——全面講解Java數(shù)學(xué)計算支持類庫，BigDecimal、Math、Random、DecimalFormat…~》

? 繼續(xù)閱讀下一篇（點擊跳轉(zhuǎn)）：
《【Java基礎(chǔ)教程】（三十八）常用類庫篇 · 第八講：數(shù)組操作類——解析Arrays類中的全部操作方法，解鎖Java數(shù)組操作技巧~》
文章來源地址http://www.zghlxwxcb.cn/news/detail-595347.html

到了這里，關(guān)于【Java基礎(chǔ)教程】（三十七）常用類庫篇 · 第七講：日期時間處理類——三萬字全面講解 LocalDateTime和 DateTimeFormatter，Date、Calendar ~的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！