当前位置: 首页>>代码示例 >>用法及示例精选 >>正文


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。非经特殊声明,原始代码版权归原作者所有,本译文未经允许或授权,请勿转载或复制。