Java 8 – Year

Un año en el sistema de calendario ISO-8601, como 2014.Esta clase no almacena ni representa un mes, día, hora o zona horaria. Como todas las clases de java.time, esta clase es inmutable y thread-safe.

now(), of(), parse(), from()

static Year	now()
static Year	now(Clock clock)
static Year	now(ZoneId zone)
static Year	of(int isoYear)
static Year	parse(CharSequence text)
static Year	parse(CharSequence text, DateTimeFormatter formatter)
static Year	from(TemporalAccessor temporal)

Crea un objeto Year desde diversos orígenes

• Desde el reloj del sistema
• Desde un reloj definido
• Desde el reloj del sistema en la zona indicada
• Pasándole un entero correspondiente a año
• Indicando el texto en una string, añadiéndole patrón de formato si no es el estandar
• Desde otro campo temporal que contenga la información necesaria (año)

En el ejemplo, mostramos todas las posibilidades indicadas

public static void main(String[] args) {
	
	
	Clock clock = Clock.systemDefaultZone();
	
	Year an1 = Year.now();		
	Year an1Def = Year.now(clock);		
	Year an1MX = Year.now(ZoneId.of("America/Mexico_City"));
	
	System.out.println("Hoy        :" + an1);
	System.out.println("Hoy Def    :" + an1Def);
	System.out.println("Hoy MX     :" + an1MX);
	
	Year an2 = Year.of(2021);
	System.out.println("of  2021   :" + an2);
	
	Year an3 = Year.parse("2020");
	System.out.println("parse 2020 :" + an3);

	DateTimeFormatter formato = DateTimeFormatter.ofPattern("dd MMMM yyyy");
    Year an4 = Year.parse("12 febrero 2020", formato);
    System.out.println("parse 12 febrero 2020 :" + an3);
    
    
    Year an5 = Year.from(LocalDate.of(2018, 10,12));
    System.out.println("from Localdate        :" + an5);
}

Y, según lo previsto, nos presentará

with()

Year	with(TemporalAdjuster adjuster)
Year	with(TemporalField field, long newValue)

Devuelve el campo que se le pasa, modificando el valor indicado; en un caso como este, que el objeto solo soporta el año, la operación no es demasiado útil, ya que el valor que contiene es el único a modificar, y se comporta como los métodos de creación

De cualquier forma, aquí esta algunos ejemplos

public static void main(String[] args) {
	
	Year an1 = Year.of(1999);
	System.out.println("an1   : " + an1);
	
	Year an2 = an1.with(Year.of(2010));
	System.out.println("an2   : " + an2);
	
	Year an3 = an1.with(ChronoField.YEAR, 2015);
	System.out.println("an3   : " + an3);
}

Y los valores que obtiene

plus(), plusYears(), minus(), minusYears()

Year	plus(long amountToAdd, TemporalUnit unit)
Year	plus(TemporalAmount amountToAdd)
Year	plusYears(long yearsToAdd)

Devuelve una copia, con los años incrementados según las unidades pasadas

Year	minus(long amountToSubtract, TemporalUnit unit)

Year	minus(TemporalAmount amountToSubtract)
Year	minusYears(long yearsToSubtract)

Devuelve una copia, con los años decrementados según las unidades pasadas

Podemos ver como se comportan los métodos en el siguiente ejemplo

public static void main(String[] args) {
	
	Year base = Year.of(2020);
	
	Year mas1 = base.plusYears(1);
	Year mas2 = base.plus(2, ChronoUnit.YEARS);
	Year mas3 = base.plus(Period.of(3, 0, 0));
	
	System.out.println("base           : " + base);
	System.out.println("base  mas1     : " + mas1);
	System.out.println("base  mas2     : " + mas2);
	System.out.println("base  mas3     : " + mas3);

        Year menos1 = base.minusYears(1);
	Year menos2 = base.minus(2, ChronoUnit.YEARS);
	Year menos3 = base.minus(Period.of(3, 0, 0));
	
	System.out.println("base  menos1   : " + menos1);
	System.out.println("base  menos2   : " + menos2);
	System.out.println("base  menos3   : " + menos3);
}

y sus resultados

isAfter(), isBefore(), isLeap(), isSupported(), isValidMonthDay(), equals(), compateTo()

boolean	isAfter(Year other)
boolean	isBefore(Year other)
boolean	equals(Object obj)
int	compareTo(Year other)

Compara este objeto Year con otro objeto Year para determinar si son iguales, o cual es anterior

boolean	isLeap()
static boolean	isLeap(long year)

Comprueba si el año indicado es bisiesto

boolean	isSupported(TemporalField field)
boolean	isSupported(TemporalUnit unit)

Comprueba si el campo, o la unidad indicada es valida para este objeto. En este caso, solo se acepta YEAR

boolean	isValidMonthDay(MonthDay monthDay)

Comprueba si el objeto MonthDay es valido para el año indicado

Veamos algunos ejemplos

public static void main(String[] args) {

	Year d1 = Year.of(2022);
	System.out.println("d1               :" + d1);

	Year d2 = Year.of(2020);

	System.out.println("d1               :" + d1);
	System.out.println("d2               :" + d2);
	System.out.println("d1.isAfter(d2 )  :" + d1.isAfter(d2));
	System.out.println("d1.equals(d2)    :" + d1.equals(d2));
	System.out.println("d1.compareTo(d2) :" + d1.compareTo(d2));
	System.out.println("d1 es bisiesto?  :" + d1.isLeap());

	System.out.println("2024 es bisiesto?:" + Year.isLeap(2024));

	boolean ms = d1.isSupported(ChronoField.MILLI_OF_SECOND);
	boolean dw = d1.isSupported(ChronoField.YEAR);
	boolean mo = d1.isSupported(ChronoUnit.MONTHS);

	System.out.println("Soporta ChronoField.MILLI_OF_SECOND:" + ms);
	System.out.println("Soporta ChronoField.YEAR           :" + dw);
	System.out.println("Soporta ChronoUnit.MONTHS          :" + mo);

	MonthDay mesdia = MonthDay.of(7, 20);
	System.out.println("es mes/dia valido?                 :" + d1.isValidMonthDay(mesdia));

}

Y los resultados que obtendríamos

get(), getLong(), getValue()

int	get(TemporalField field)

long	getLong(TemporalField field)

int	getValue()

Obtiene el valor del campo. En este caso, el campo solo puede contener el año, por lo que el unico TemporalField que podemos utilizar será YEAR, y los tres métodos son iguales

Viéndolo en un ejemplo

public static void main(String[] args) {
	Year d1 = Year.of(2022);
	System.out.println("d1               :" + d1);
	
	System.out.println("ChronoField.YEAR   : " + d1.get(ChronoField.YEAR));
	System.out.println("ChronoField.YEAR   : " + d1.getLong(ChronoField.YEAR));
	System.out.println("getValue           : " + d1.getValue());
}

Y los resultados

length()

int	length()

Obtiene la duración de este año en días.

Veámoslo en un ejemplo

public static void main(String[] args) {
	Year d1 = Year.of(2022);
	System.out.println("d1       :" + d1);
	
	System.out.println("dias     : " + d1.length());
	
}

Recibiremos los siguientes resultados

range()

ValueRange	range(TemporalField field)

Facilita el rango con que podemos filtrar un valor que deseemos guardar

Solo se puede pedir para Year, ya que es el unico dato que guarda, pero …

public static void main(String[] args) {
	Year d1 = Year.of(2022);
	System.out.println("d1        :" + d1);
	
	System.out.println("ValueRange: " + d1.range(ChronoField.YEAR));
	
}

Y obtendremos

until()

long	until(Temporal endExclusive, TemporalUnit unit)

Obtiene la distancia que hay entre dos fechas, en las unidades indicadas, que en este caso, solo acepta YEARS

En el ejemplo, obtenemos la distancia en años entre un LocalDate y un Year

public static void main(String[] args) {
	Year d1 = Year.of(2022);
	System.out.println("d1        :" + d1);
	
	LocalDate f1 = LocalDate.of(2021, 5,20);
	
	System.out.println("until     : " + d1.until(f1,ChronoUnit.YEARS));
	
}

La distancia en años, será

format()

String	format(DateTimeFormatter formatter)

Formatea el año según la forma deseada

En el ejemplo, se muestran algunos formatos. Es conveniente revisar DateTimeFormatter

public static void main(String[] args) {
	Year d1 = Year.of(2022);
	System.out.println("d1             : " + d1);
	String formateado = d1.format(DateTimeFormatter.ofPattern("yy"));
	
	
	System.out.println("con formato yy : " + formateado);
	
}

Nos presenta

adjustInto()

Temporal	adjustInto(Temporal temporal)

Obtiene un objeto temporal tras aplicarle al Year el ajuste indicado. El objeto obtenido esta limitado por el tipo de ajuste

En el ejemplo, vemos como podemos cambiar el año.

public static void main(String[] args) {
	Year d1 = Year.of(2022);
	System.out.println("d1             : " + d1);
	
	LocalDate f1 = (LocalDate) d1.adjustInto(LocalDate.of(1950, 10, 1));
	System.out.println("Queda como     : " + f1);

}

Nos permite cambiar el año al LocalDate entregado, y dejarle con el que contiene Year

atDay(), atMonth(), atMonthDay()

LocalDate	atDay(int dayOfYear)

Combina el Year con el dia del año para obtener un LocalDate

YearMonth	atMonth(int month)
YearMonth	atMonth(Month month)

Combina el Year con un Month, para obtener un YearMonth

LocalDate	atMonthDay(MonthDay monthDay)

Combina el Year con un MonthDay para obtener un LocalDate

Vemos algunos ejemplos

public static void main(String[] args) {
	Year d1 = Year.of(2022);
	System.out.println("d1             : " + d1);
	
	LocalDate f1 = d1.atDay(244);
	System.out.println("con dia año    : " + f1);
	
	YearMonth ym1 = d1.atMonth(9);
	YearMonth ym2 = d1.atMonth(Month.OCTOBER);
	System.out.println("con mes 9      : " + ym1);
	System.out.println("con mes OCTOBER: " + ym2);
	
	MonthDay md = MonthDay.of(12,25);
	LocalDate f2 = d1.atMonthDay(md);
	System.out.println("con MonthDay   : " + f2);
}

Y dará los siguientes resultados

Conclusión

La clase Year, mantiene únicamente el año y puede ser reutilizados en el resto de clases de la api java.time, asi como utilizarlo para crear un montón de objetos mas completos de esta misma api

Este articulo detalle una de las clases de la api java.time descritas anteriormente en el indice que se facilito sobre este tema