當前位置: 首頁>>代碼示例 >>用法及示例精選 >>正文


Java java.time.Year用法及代碼示例


Year of()類代表一年ISO-8601日曆係統,例如 2021。年份是不可變的代表年份的日期時間對象。該類不存儲或代表月、日、時間,或時區。此類代表的年份遵循如下的推算編號係統:

The year 0 is preceded by year -1 and succeeded by the year 1.

用法:類別聲明

public final class Year extends Object implements Temporal, TemporalAdjuster, Comparable<Year>, Serializable

現在讓我們討論 Year 類的所有方法,如下以表格格式顯示。稍後,我們將單獨討論它們。

方法 說明
adjustsIntro() 將指定的時間對象調整為今年。
atDay() 創建一個本地日期,其天數等於 Year 類對象中的數字
atMonth() 將今年與一個月結合起來創建一個 YearMonth
atMonthDay() 將今年與月份日期結合起來創建 LocalDate
compareTo() 比較 two-year 對象。
equals() 檢查two-year對象是否相等。
format() 使用指定的日期時間格式化程序格式化年份。
get() 獲取今年以來指定字段的值。
getLong() 獲取今年指定字段的長整型值
getValue() 返回年份的整數值。
hashCode() 返回年份對象的哈希碼。
isAfter() 檢查年份是否在year1 之後。
isBefore() 檢查年份是否早於year1。
isLeap() 檢查年份是否為閏年。
isSupported() 檢查是否支持指定的時間字段。
isValidMonthDay() 檢查 month-day 今年是否有效
length() 返回一年中的天數。
minus() 返回減去指定數量的今年的副本
minusYears() 從年份中減去年份數並返回新的 Year 對象。
now() 獲取當前年份並創建一個 Year 對象。
of()

“創建年份對象,年份等於數字。

0 用於 0 AD,而 -1 用於 1 BC。”

parse() 從文本字符串(例如 2021)獲取 Year 的實例。
plus() 返回添加了指定年數的今年的副本。
plusYears() 將 num 年添加到年份並返回一個新的 Year 對象。
query() 今年的查詢使用指定的查詢。
range() 獲取指定字段的有效值範圍。
toString() 以字符串形式返回當前年份。
until() 以指定單位計算距另一年的時間量。
with() 返回年份的調整副本。

讓我們詳細討論該類的一些常用方法,以便更好地理解,以便也實現其餘的方法。在這裏我們將討論 our主要方法如下ws:

  1. Year atDay()
  2. hashCode()
  3. Year isAfter()
  4. Year isBefore()
  5. Year isLeap()
  6. Year now()
  7. Year minus(long,unit)

方法一:Year atDay()Java 中的 Year 類的方法將當前年份與作為參數傳遞給它的 day-of-year 相結合,以創建 LocalDate。

用法:

public LocalDate atDay(int dayOfYear)

參數:此方法接受一年中的單個參數。使用的是day-of-year。它可以取 1 到 365-366 之間的值。

返回值:它返回由當前年份和作為參數傳遞給函數的年份日期形成的本地日期。

異常: 這個方法會拋出一個ZoneOffset of(String),如果參數中傳遞的年份日期無效,即為零或小於、366 或大於或等於 366 並且當前年份不是閏年。

方法二:hashCode()

它以整數形式返回哈希碼值。 hashcode值主要用於散列-基於集合,如 HashMap、HashSet、HashTable 等。必須在每個覆蓋該方法的類中覆蓋此方法equals()方法.
用法:

public int hashCode()

// This method returns the hash code value 
// for the object on which this method is invoked.

方法三:

Java 中 Year 類的 isAfter() 方法用於檢查當前的 Year 對象是否在指定為該方法的參數的 Year 之後。

用法

public boolean isAfter(Year otherYear)

參數:它接受要與當前 Year 對象進行比較的另一年的單個參數。

返回值:如果此 Year 對象的值在指定為方法參數的 Year 對象的值之後,則返回布爾 True 值,否則返回 False。

方法四:

Java 中 Year 類的 isBefore() 方法用於檢查當前 Year 對象是否在指定為該方法參數的 Year 之前。

用法

public boolean isBefore(Year otherYear)

參數:它接受單個參數 otherYear,當前 Year 對象將與該參數進行比較。

返回值:如果此 Year 對象的值在指定為方法參數的 Year 對象的值之前,則返回布爾 True 值,否則返回 False。

方法五:

Year isLeap()Java中Year類的方法用於根據預知日曆係統規則檢查該Year對象是否為閏年。

A year is a leap year if it has 366 days in it. According to the proleptic calendar system rules, a year is a Leap year if:

  • If it is divisible by 4.
  • It is not divisible by 100, but it can be divisible by 400.

用法

public boolean isLeap()

參數:該方法不接受任何參數。

返回值:如果根據預算日曆係統規則,此 Year 對象的值為閏年,則返回布爾 True 值,否則返回 False。

方法六:

Year now()Java中Year類的方法用於從默認時區的係統時鍾返回當前年份。

用法

public static Year now()

or,
public static Year now(Clock clock)

or,
public static Year now(ZoneId zone)

參數:此方法的參數是可選的,如上麵的語法所示。

返回值:如果不指定參數,則從默認時區的係統時鍾返回當前年份,否則使用指定的時鍾和時區返回當前年份。它永遠不能返回 NULL 值

方法七:

Year 類的 minus() method 用於在從此 Year 對象中減去指定數量的單位後返回今年的副本。如果無法從 Year 中減去指定的單位,則會引發異常。該實例是不可變的並且不受該方法調用的影響。

用法:

public Year minus(long amountToSubtract, TemporalUnit unit)

參數:該方法接受兩個參數,如下所示:

  • 減去的數量
    • 該參數表示要從結果中減去的單位量。
  • 單元
    • 該參數表示要減去的數量的單位。

返回值:此方法返回基於今年減去指定數量的年份。

異常:該方法拋出以下異常:

  • DateTimeException
    • 如果無法進行減法,則會拋出此異常。
  • UnsupportedTemporalTypeException
    • 如果不支持該單位,則會引發此異常。
  • ArithmeticException
    • 如果發生數字溢出,則會拋出此異常。

您可以對 plus() 方法進行 co-relate 相同的操作。至此我們就結束了方法的討論。現在是時候實現同樣的方法來演示 Year 類了。

執行:

示例

Java


// Java Program to illustrate java.time.Year class
import java.time.*;
// Importing all classes from
// time package to get other functionalities
import java.time.Year;
//  Class
public class GFG {
    // Main driver method
    public static void main(String[] args)
    {
        // Object 1
        // Creating an Year class object
        // getting the current year each
        // using the now() method
        Year y = Year.now();
        // Print and display the current year
        System.out.println("Current year: " + y);
        // Object 2
        // Creating another Year class object Object
        // Here year 2020 as passed as an argument
        Year y1 = Year.of(2020);
        // Object 3
        // Creating another object of year class
        // again passing year 2022 as an argument
        Year y2 = Year.of(2022);
        // Now, creating a LocalDate object and
        // getting the local date at the day
        // passed as an argument
        // Custom input argument = 350
        LocalDate l = y.atDay(350);
        // Print the local date
        System.out.println("Local date: " + l);
        // Now, creating a YearMonth
        // and retrieving month using atMonth() method
        // by passing argument to the method
        // Custom input argument- 6
        YearMonth ym = y.atMonth(6);
        // Print the year and the month
        System.out.println("Year and month: " + ym);
        // Printing number of days of current Year
        System.out.println("Number of days: " + y.length());
        // Checking if Year y
        // is before Year y2
        System.out.println("2021 is before 2022: "
                           + y.isBefore(y2));
        // check if Year y
        // is after Year y1
        System.out.println("2021 is after 2020: "
                           + y.isAfter(y1));
        // Now, printing hashcode of the year
        // using the hashcode() method
        System.out.println("Hashcode of the year: "
                           + y.hashCode());
        // Checking whether the year is leap year or not
        System.out.println("2020 is leap year: "
                           + y1.isLeap());
        // Adding 150 years to the current year
        System.out.println("2021 - 155 years: "
                           + y.minusYears(155));
        // Subtracting 150 years from the current year
        System.out.println("2021 + 145 years: "
                           + y.plusYears(145));
    }
}
輸出
Current year: 2021
Local date: 2021-12-16
Year and month: 2021-06
Number of days: 365
2021 is before 2022: true
2021 is after 2020: true
Hashcode of the year: 2021
2020 is leap year: true
2021 - 155 years: 1866
2021 + 145 years: 2166


相關用法


注:本文由純淨天空篩選整理自mehulp1612大神的英文原創作品 java.time.Year Class in Java。非經特殊聲明,原始代碼版權歸原作者所有,本譯文未經允許或授權,請勿轉載或複製。