Clase java.time.Year en Java

La clase java.time.Year representa un año en el sistema de calendario ISO-8601 , como 2021. Year es un objeto de fecha y hora inmutable que representa un año. Esta clase no almacena ni representa un mes, día, hora o zona horaria. Los años representados por esta clase siguen el sistema de numeración proléptico que es el siguiente: 

El año 0 está precedido por el año -1 y seguido por el año 1.

Sintaxis: declaración de clase

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

Ahora analicemos todos los métodos de esta clase de año que se muestra a continuación en un formato tabular. Más adelante, los discutiremos individualmente.

Discutamos en detalle algunos de los métodos de esta clase que se usan con frecuencia para obtener una mejor comprensión e implementar el resto de ellos también. Aquí discutiremos nuestros principales métodos, a saber, los siguientes :

1. en el día()
2. código hash()
3.  es despues()
4. esAntes()
5. esSalto()
6. ahora()
7. menos()

Método 1: el método atDay() de la clase Year en Java combina el año actual con un día del año pasado como parámetro para crear una LocalDate.

Sintaxis : 

public LocalDate atDay(int dayOfYear)

Parámetro : Este método acepta un solo parámetro día del año. Es el día del año a utilizar. Puede tomar valores de 1 a 365-366.

Valor de Retorno : Devuelve una Fecha Local formada por el año actual y la fecha del año pasado como parámetro a la función.

Excepción : este método arroja una DateTimeException si el día del año pasado en el parámetro no es válido, es decir, cero o menos, 366 o más o igual a 366 y el año actual no es un año bisiesto.

Método 2: hashCode() 

Devuelve el valor del código hash como un entero. El valor de Hashcode se usa principalmente en colecciones basadas en hashing como HashMap , HashSet, HashTable, etc. Este método debe anularse en cada clase que anula el método equals() .
Sintaxis:

public int hashCode()

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

Método 3: 

El método isAfter() de la clase Year en Java se usa para verificar si este objeto Year actual es posterior al Year especificado como parámetro para este método.

Sintaxis :

public boolean isAfter(Year otherYear)

Parámetro : Acepta un solo parámetro otro año con el que se va a comparar el objeto Año actual.

Valor devuelto : Devuelve un valor booleano True si el valor de este objeto Year es posterior al valor del objeto Year especificado como parámetro del método; de lo contrario, devuelve False.

Método 4: 

El método isBefore() de la clase Year en Java se usa para verificar si este objeto Year actual es anterior al Year especificado como parámetro para este método.

Sintaxis :

public boolean isBefore(Year otherYear)

Parámetro : Acepta un único parámetro otro año con el que se va a comparar el objeto Año actual.

Valor devuelto : Devuelve un valor booleano True si el valor de este objeto Year es anterior al valor del objeto Year especificado como parámetro para el método; de lo contrario, devuelve False.

Método 5:

El método isLeap() de la clase Year en Java se usa para verificar si este objeto Year es un año bisiesto o no de acuerdo con las reglas del sistema de calendario proléptico.

Un año es bisiesto si tiene 366 días. De acuerdo con las reglas del sistema de calendario proléptico, un año es un año bisiesto si:

• Si es divisible por 4.
• No es divisible por 100, pero puede ser divisible por 400.

Sintaxis :

public boolean isLeap()

Parámetro : Este método no acepta ningún parámetro.

Valor de retorno : Devuelve un valor booleano True si el valor de este objeto Year es un año bisiesto de acuerdo con las reglas del sistema de calendario proléptico; de lo contrario, devuelve False.

Método 6:

El método now() de la clase Year en Java se usa para devolver el año actual desde el reloj del sistema en la zona horaria predeterminada.

Sintaxis :

public static Year now()

or,
public static Year now(Clock clock)

or,
public static Year now(ZoneId zone)

Parámetro : el parámetro es opcional para este método, como se muestra en la sintaxis anterior.

Valor devuelto : Devuelve el año actual del reloj del sistema en la zona horaria predeterminada si no se especifica ningún parámetro; de lo contrario, utiliza el reloj y la zona horaria especificados para devolver el año actual. Nunca puede devolver un valor NULL

Método 7: 

El método minus() de la clase Year se usa para devolver una copia de este año después de restar la cantidad especificada de unidades de este objeto Year. Se genera una excepción si la unidad especificada no se puede restar de Year. Esta instancia es inmutable y no se ve afectada por esta llamada de método.

Sintaxis:

public Year minus(long amountToSubtract, TemporalUnit unit)

Parámetros: este método acepta dos parámetros que son los siguientes:

• cantidad a restar
  • Este parámetro representa la cantidad de la unidad a restar del resultado.
• unidad
  • Este parámetro representa la unidad de la cantidad a restar.

Valor devuelto: este método devuelve un año basado en este año con la cantidad especificada restada.

Excepción: este método arroja las siguientes excepciones:

• Excepción de fecha y hora
  • Esta excepción se lanza si no se puede realizar la resta.
• Excepción de tipo temporal no admitida
  • Esta excepción se lanza si la unidad no es compatible.
• excepción aritmética
  • Esta excepción se produce si se produce un desbordamiento numérico.

Puede correlacionar lo mismo para el método plus(). Por ahora hemos terminado con la discusión de los métodos. Ahora es el momento de implementar lo mismo para demostrar la clase Year.

Implementación:

Ejemplo

// 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