Java 8 – YearMonth

YearMonth es un objeto de fecha y hora inmutable que representa la combinación de un año y un mes. Se puede obtener cualquier campo que pueda derivarse de un año y un mes, como un trimestre de año.

now(), of(), parse()

static YearMonth	now()
static YearMonth	now(Clock clock)
static YearMonth	now(ZoneId zone)
static YearMonth	of(int year, int month)
static YearMonth	of(int year, Month month)
static YearMonth	parse(CharSequence text)
static YearMonth	from(TemporalAccessor temporal)

Crea un objeto YearMonth desde diversos orígenes

• Desde el reloj del sistema
• Desde un reloj definido
• Desde el reloj del sistema en la zona indicada
• Pasándole dos enteros correspondientes a año y mes
• Pasándole año como entero y mes como literal
• 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 (día, mes, año)

En el ejemplo, mostramos todas las posibilidades indicadas

public static void main(String[] args) {
	
	YearMonth ames = YearMonth.now();
	
	Clock clock = Clock.systemDefaultZone();		
	YearMonth amesDef = YearMonth.now(clock);		
	YearMonth amesMX = YearMonth.now(ZoneId.of("America/Mexico_City"));
	
	System.out.println("Hoy        :" + ames);
	System.out.println("Hoy Def    :" + amesDef);
	System.out.println("Hoy MX     :" + amesMX);
//---of		
	YearMonth unDia = YearMonth.of(2021, 10);
	YearMonth otroDia = YearMonth.of(2022, Month.FEBRUARY );
	
	System.out.println("unDia      :" + unDia);
	System.out.println("otroDia    :" + otroDia);
// parse		
	YearMonth dParse = YearMonth.parse("2020-08");
	
	DateTimeFormatter formato = DateTimeFormatter.ofPattern("MMMM yyyy");
    YearMonth dParseF = YearMonth.parse("febrero 2020", formato);
    
    System.out.println("dParse     :" + dParse);
	System.out.println("dParseF    :" + dParseF);		
// from		
	YearMonth ahora = YearMonth.now();
	YearMonth pFrom = YearMonth.from(ahora);
	System.out.println("dFrom      :" + pFrom);	
}

Nos dará como resultado

with(), withMonth(), withYear()

YearMonth	with(TemporalAdjuster adjuster)
YearMonth	with(TemporalField field, long newValue)
YearMonth	withMonth(int month)
YearMonth	withYear(int year)

Nos devuelve una copia del objeto YearMonth en donde se ha modificado el valor pasado.

Vemos un ejemplo

public static void main(String[] args) {
	
	YearMonth ames = YearMonth.now();		
	System.out.println("Año-Mes    :" + ames);
		
	YearMonth d10 = ames.with(ChronoField.MONTH_OF_YEAR,10);
	System.out.println("d10        :" + d10);
	
	YearMonth cambioMes = ames.withMonth(8);
	System.out.println("cambioMes  :" + cambioMes);
  
	YearMonth cambioAny = ames.withYear(2034);
	System.out.println("cambioAny  :" + cambioAny);
}

Veremos como se cambia el mes o el año, dejando el resto sin modificaciones

plus(), plusMonths(), plusYears()

YearMonth	plus(long amountToAdd, TemporalUnit unit)
YearMonth	plus(TemporalAmount amountToAdd)
YearMonth	plusMonths(long monthsToAdd)
YearMonth	plusYears(long yearsToAdd)

Crea un objeto YearMonth a partir de otro objeto YearMonth y sumándole el dato según el método asociado

En el ejemplo vemos como podemos sumar meses o años a un YearMonth de forma simple

public static void main(String[] args) {
	
	YearMonth ames = YearMonth.of(2018, Month.DECEMBER);

	ames = ames.plusMonths(1);
	System.out.println(ames); // presenta 2019-01

	ames = ames.plusYears(1); // duma un año
	System.out.println(ames); // 2020-01

}

Nos calculará

minus(), minusMonths(), minusYears()

YearMonth	minus(long amountToAdd, TemporalUnit unit)
YearMonth	minus(TemporalAmount amountToAdd)
YearMonth	minusMonths(long monthsToAdd)
YearMonth	minusYears(long yearsToAdd)

Crea un objeto YearMonth a partir de otro objeto YearMonth y restándole el dato según el método asociado

En el ejemplo vemos como podemos restar meses o años a un YearMonth de forma simple

public static void main(String[] args) {
	
	YearMonth ames = YearMonth.of(2018, Month.DECEMBER);

	ames = ames.minusMonths(1);
	System.out.println(ames); // presenta 2018-11

	ames = ames.minusYears(1); // duma un año
	System.out.println(ames); // 2017-11

}

y obtendremos

isAfter(), isBefore(), isLeapYear(), isSupported(), isValidDay(), equals(), compareTo()

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

Podemos comparar el YearMonth con otros, para determinar si es el mismo Mes-año si es anterior o si es posterior

Por ejemplo, comprobamos si una fecha es posterior a otra

public static void main(String[] args) {
	
	YearMonth d1 = YearMonth.of(2020, Month.AUGUST);
	System.out.println("d1               :" + d1);
	
	YearMonth d2 = YearMonth.of(2020,Month.APRIL);
	System.out.println("d2               :" + d2);
	
	System.out.println("d1 es after?  :" + d1.isAfter(d2));
	System.out.println("d1 es before? :" + d1.isBefore(d2));
	System.out.println("d1 es =?      :" + d1.equals(d2));
	System.out.println("d1 compareTo  :" + d1.compareTo(d2));


}

Nos responderá con

boolean isLeapYear()

Nos indica si la fecha esta dentro de un año bisiesto, por ejemplo:

public static void main(String[] args) {
	
	YearMonth d1 = YearMonth.of(2022, Month.AUGUST);
	System.out.println("d1               :" + d1);
	System.out.println("d1 es bisiesto?  :" + d1.isLeapYear());
	
	YearMonth d2 = YearMonth.of(2024, Month.APRIL);
	System.out.println("d2               :" + d2);
	System.out.println("d2 es bisiesto?  :" + d2.isLeapYear());


}

Presenta

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

Nos indica si la unidad o el tipo de campo esta soportado en el YearMonth

En el ejemplo, vemos algunos casos

public static void main(String[] args) {
	
	YearMonth d1 = YearMonth.of(2022, Month.AUGUST);
	boolean ms = d1.isSupported(ChronoField.MILLI_OF_SECOND);
	boolean dw = d1.isSupported(ChronoField.DAY_OF_WEEK);
	boolean mo = d1.isSupported(ChronoUnit.MONTHS);
	
	System.out.println("Soporta ChronoField.MILLI_OF_SECOND:"+ms);
	System.out.println("Soporta ChronoField.DAY_OF_WEEK:"+dw);
	System.out.println("Soporta ChronoUnit.MONTHS:"+mo);


}

Solo nos dará valido MONTHS, ya que esta clase solo acepta YEAR y MONTHS

boolean	isValidDay(int dayOfMonth)

Dado un mes y año, comprueba que el valor del día es correcto para ese mes y año. Los errores se producirán habitualmente en Febrero , para años bisiestos o en errores de asignación de 28,30 o 31dia

Vemos un ejemplo, en donde utilizamos un año bisiesto y otro que no lo es, y probamos el día 29

public static void main(String[] args) {
	
	YearMonth d1 = YearMonth.of(2022, Month.FEBRUARY);
	System.out.println("d1               :" + d1);
	
	YearMonth d2 = YearMonth.of(2020,Month.FEBRUARY);
	System.out.println("d2               :" + d2);
	
	System.out.println("d1 es after?  :" + d1.isValidDay(29));
	System.out.println("d1 es before? :" + d2.isValidDay(29));
	
}

Aparece como resultado

get(), getLong(), getMonth(), getMonthValue(), getYear()

int	get(TemporalField field)
long	getLong(TemporalField field)
Month	getMonth()
int	getMonthValue()
int	getYear()

Facilita cada una de las partes del campo YearMonth (mes y año) en distintos formatos

En el ejemplo, podéis ver como los obtenemos

public static void main(String[] args) {
	YearMonth aMes = YearMonth.now();
	
	System.out.println("Fecha           :" + 
			aMes.toString());
	System.out.println("Numero mes      :" + 
			aMes.getMonthValue());	
	System.out.println("Año             :" + 
			aMes.getYear());
	System.out.println("Mes        Obj  :" + 
			aMes.getMonth());
	
	System.out.println("----------------------------------------");
	
	System.out.println("El año          :" + 
			aMes.getLong(ChronoField.YEAR));
	
	System.out.println("----------------------------------------");
	
}

Y la información que conseguimos

lengthOfMonth(), lengthOfYear()

int	lengthOfMonth()
int	lengthOfYear()

Nos facilita el numero de días que tiene el mes o el año de la fecha

En el ejemplo, vemos lo sencillo que es obtenerlos

public static void main(String[] args) {
	YearMonth hoy = YearMonth.now();
	
	System.out.println("Año/mes               :" + 
			hoy.toString());
	
	System.out.println("Longitud mes          :" + 
			hoy.lengthOfMonth());
	System.out.println("Longitud año          :" + 
			hoy.lengthOfYear());	
}

y sus resultados

range()

ValueRange	range(TemporalField field)

Facilita el rango con que podemos filtrar cualquiera de los valores soportados

En el ejemplo, vemos como obtener el rango para filtrar

public static void main(String[] args) {
	YearMonth hoy = YearMonth.now();
	
	System.out.println("Fecha           :" + 
			hoy.toString());
	
	System.out.println("Rango  meses año:" + 
			hoy.range(ChronoField.MONTH_OF_YEAR));	
	System.out.println("Rango  años     :" + 
			hoy.range(ChronoField.YEAR));	
	

}

Los valores que nos facilita para filtrar la entrada de mes y de año es

until()

long	until(Temporal endExclusive, TemporalUnit unit)

Obtiene la distancia que hay entre dos YearMonth, en las unidades indicadas

En el ejemplo, obtenemos la distancia en años y en numero de meses

public static void main(String[] args) {
	
	YearMonth d1 = YearMonth.of(2022, Month.AUGUST);
	System.out.println("d1               :" + d1);
	
	YearMonth d2 = YearMonth.of(2024, Month.APRIL);
	System.out.println("d2               :" + d2);
	
	long p = d1.until(d2,ChronoUnit.YEARS);
	System.out.println("en años          :" + p);
	
	long meses = d1.until(d2,ChronoUnit.MONTHS);
	System.out.println("en meses         :" + meses);

}

Consigue los siguientes resultados

format()

String	format(DateTimeFormatter formatter)

Formatea la fecha según la forma deseada

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

public static void main(String[] args) {
	
	YearMonth ames = YearMonth.now();

	String formattedDate = "";		
	String formateado = ames.format(DateTimeFormatter.ofPattern("MMM - yy"));
	System.out.println("Formato manual..: " + formateado);
		
}

Y el resultado es

adjustInto()

Temporal	adjustInto(Temporal temporal)

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

En el ejemplo, vemos como podemos cambiar una fecha, sin modificar la hora ni la zona

public static void main(String[] args) {
	
	ZonedDateTime date = ZonedDateTime.now();
      System.out.println(date);  

      YearMonth date1 = YearMonth.parse("2017-02");
      date = (ZonedDateTime)date1.adjustInto(date);
      System.out.println(date);  

}

Generará el siguiente resultado

atDay(), atEndOfMonth()

LocalDate	atDay(int dayOfMonth)
LocalDate	atEndOfMonth()

Entrega un LocalDate con los valores de año y mes existentes en el YearMonth, añadiendo el día, en función de la orden dada

A continuación, presentamos dos ejemplos

public static void main(String[] args) {
	  YearMonth aMes = YearMonth.of(2020,12);
	  System.out.println("aMes                : " + aMes); 
      LocalDate hoy = aMes.atDay(25);
      System.out.println("atDay               : " + hoy); 
      
      LocalDate despues = aMes.atEndOfMonth();
      System.out.println("fin de año          : " + despues);  

}

Que nos presenta la fecha de Navidad y de fin de año

Conclusión

La clase YearMonth, mantiene un mes y año y puede ser reutilizados en el resto de clases de la api java.time

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