Enjoy A New Student Discount All 55,000 Courses on sale for Only $12.99

Ends in 05h 23m 49s

Java 8 – El acceso al tiempo con LocalDate, LocalTime y LocalDateTime (II)

LocalTime

Al nivel de LocalDate, LocalTime se trata de una clase capaz de guardar y trabajar con horas, minutos y segundos, pero sin especificar la zona horaria a la que esos datos pueden pertenecer. La precision con la que trabaja es de nanosegundos, con lo que podemos conservar en un campo de dicha clase un valor de tipo «13:45.30.123456789»

now(), of(), ofNanoOfDay(), ofSecondOfDay(), parse(), from()

static LocalTime	now()
static LocalTime	now(Clock clock)
static LocalTime	now(ZoneId zone)
static LocalTime	of(int hour, int minute)
static LocalTime	of(int hour, int minute, int second)
static LocalTime	of(int hour, int minute, int second, int nanoOfSecond)
static LocalTime	ofNanoOfDay(long nanoOfDay)
static LocalTime	ofSecondOfDay(long secondOfDay)
static LocalTime	parse(CharSequence text)
static LocalTime	parse(CharSequence text, DateTimeFormatter formatter)
static LocalTime	from(TemporalAccessor temporal)

Se trata de los constructores del objeto LocalTime que nos lo permiten obtener desde:

  • Desde el reloj del sistema
  • Desde un reloj definido
  • Desde el reloj del sistema en la zona indicada
  • Pasándole dos enteros correspondientes a hora y minuto
  • Pasándole tres enteros correspondientes a hora, minuto y segundo
  • Pasándole cuatro enteros correspondientes a hora, minuto, segundo y nanosegundo
  • Pasándole el numero de nanosegundos transcurridos desde la 00:00
  • Indicando el numero de segundos transcurridos desde la 00:00
  • Indicando el texto en una string, añadiéndole patrón de formato si no es el estandar
  • Obteniendolo desde otro objeto temporal COMPATIBLE

En el ejemplo, mostramos todas las posibilidades indicadas

public static void main(String[] args) {
		
	LocalTime ahora= LocalTime.now();
	
	Clock clock = Clock.systemDefaultZone();		
	LocalTime ahoraDef = LocalTime.now(clock);		
	LocalTime ahoraMX = LocalTime.now(ZoneId.of("America/Mexico_City"));
	
	System.out.println("Ahora        :" + ahora);
	System.out.println("Ahora Def    :" + ahoraDef);
	System.out.println("Ahora MX     :" + ahoraMX);
//---of		
	LocalTime unaHora = LocalTime.of(11, 40);
	LocalTime otraHora = LocalTime.of(12, 15 ,52);
		
	System.out.println("unaHora      :" + unaHora);
	System.out.println("otraHora    :" + otraHora);
//ofNanoDay		
	long nanos = unaHora.getLong(ChronoField.NANO_OF_DAY);
	nanos += 200000000000L;
	LocalTime desdeNanos = LocalTime.ofNanoOfDay(nanos);
	LocalTime desdesegundos  = LocalTime.ofSecondOfDay(72153);
		
	System.out.println("desdeNanos :" + desdeNanos);
	System.out.println("desdesegundos  :" + desdesegundos);
// parse		
	LocalTime dParse = LocalTime.parse("14:10:22");
	
	DateTimeFormatter formato = DateTimeFormatter.ofPattern("HH mm ss");
        LocalTime dParseF = LocalTime.parse("12 50 21", formato);
        
        System.out.println("dParse     :" + dParse);
	System.out.println("dParseF    :" + dParseF);		
// from		
	LocalDateTime mas = LocalDateTime.now();
	LocalTime pFrom = LocalTime.from(mas);
	System.out.println("dFrom      :" + pFrom);	
}

Obteniendo en consola la siguiente información:

with(), withHour(), withMinute(), withNano(), withSecond(), truncateTo()

LocalTime	with(TemporalAdjuster adjuster)
LocalTime	with(TemporalField field, long newValue)
LocalTime	withHour(int hour)
LocalTime	withMinute(int minute)
LocalTime	withNano(int nanoOfSecond)
LocalTime	withSecond(int second)

Nos permite obtener un nuevo objeto LocalTime, a partir de uno ya existente, modificando únicamente la información seleccionada. (Hora, minuto, segundo….)

LocalTime	truncatedTo(TemporalUnit unit)

Nos permite obtener un nuevo objeto LocalTime, a partir de uno ya existente, redondeando al nivel que nos interese, dejando las unidades inferiores a 0

A continuación vemos ejemplos de como cambiar la hora con estas herramientas, y, el ultimo caso, también, de como truncar el reloj a una unidad concreta; en nuestro caso, lo hemos hecho a horas, pero hubiéramos podido hacerlo a minutos, a segundos,…..

public static void main(String[] args) {
		
		LocalTime ahora = LocalTime.now();		
		System.out.println("Hoy        :" + ahora);
			
		LocalTime h21 = ahora.with(ChronoField.HOUR_OF_DAY,21);
		System.out.println("h21        :" + h21);
		
		LocalTime hmn = ahora.with(LocalTime.MIDNIGHT);
		System.out.println("hmn        :" + hmn);
		
		LocalTime h20 = ahora.withHour(20);
		System.out.println("h20        :" + h20);
		
		LocalTime cMinuto= ahora.withMinute(36);
		System.out.println("cMinuto    :" + cMinuto);
		
		LocalTime cambioNano = ahora.withNano(333);
		System.out.println("cambioNano :" + cambioNano);
  
		LocalTime cambioSegun = ahora.withSecond(45);
		System.out.println("cambioSegun:" + cambioSegun);
		
		LocalTime truncaH = ahora.truncatedTo(ChronoUnit.HOURS);
		System.out.println("truncaH    :" + truncaH);
	}

Los resultados obtenidos, serán:

plus(), plusHours(), plusMinutes(), plusNanos(), plusSeconds()

LocalTime	plus(long amountToAdd, TemporalUnit unit)
LocalTime	plus(TemporalAmount amountToAdd)
LocalTime	plusHours(long hoursToAdd)
LocalTime	plusMinutes(long minutesToAdd)
LocalTime	plusNanos(long nanosToAdd)
LocalTime	plusSeconds(long secondstoAdd)

Obtiene un nuevo LocalTime con un LocalTime existente sumándole la cantidad especificada por la función

En el ejemplo, podemos ver algunos usos

public static void main(String[] args) {
		
		LocalTime unaHora = LocalTime.of(10,35,20);
		unaHora = unaHora.plusHours(2); // sumo dos horas
		System.out.println(unaHora); // presenta 12:35:20

		unaHora = unaHora.plusMinutes(1); // sumo 1 minuto
		System.out.println(unaHora); // presenta 12:36:20

		unaHora = unaHora.plusSeconds(17);
		System.out.println(unaHora); // presenta 12:36:37

		unaHora = unaHora.plus(10000, ChronoUnit.MICROS); // 
		System.out.println(unaHora); // presenta 12:36:37.010

	}

Que nos presenta en consola

minus(), minusHours(), minusMinutes(), minusNanos(), minusSeconds()

LocalTime	minus(long amountToSubtract, TemporalUnit unit)
LocalTime	minus(TemporalAmount amountToSubtract)
LocalTime	minusHours(long hoursToSubtract)
LocalTime	minusMinutes(long minutesToSubtract)
LocalTime	minusNanos(long nanosToSubtract)
LocalTime	minusSeconds(long secondsToSubtract)

En este caso, podemos obtener un nuevo objeto de la clase LocalTime, a partir de un objeto LocalTime existente y restándole la cantidad indicada de la unidad señalada por el método.

Vemos algunos usos en el ejemplo

public static void main(String[] args) {
		
		LocalTime unaHora = LocalTime.of(10,35,20);
		unaHora = unaHora.minusHours(2); // resto dos horas
		System.out.println(unaHora); // presenta 08:35:20

		unaHora = unaHora.minusMinutes(1); // resto 1 minuto
		System.out.println(unaHora); // presenta 08:34:20

		unaHora = unaHora.minusSeconds(17);
		System.out.println(unaHora); // presenta 08:34:03

		unaHora = unaHora.minus(10000, ChronoUnit.MICROS); // 
		System.out.println(unaHora); // presenta 08:34:02.990

	}

Con la siguiente salida en Consola

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

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

Dados dos LocalTime, permite comparar si una hora es anterior a otra o son iguales

En el ejemplo, podemos ver el funcionamiento de estos métodos al comparar dos fechas

public static void main(String[] args) {
		
		LocalTime d1 = LocalTime.of(15,30,48);
		System.out.println("d1                : " + d1);
		
		LocalTime d2 = LocalTime.of(8,10);
		System.out.println("d2                : " + d2);
	
		System.out.println("d1 posterior a d2 : " + d1.isAfter(d2));
		System.out.println("d2 anterior  a d1 : " + d2.isAfter(d1));
		System.out.println("d1 igual  a d2    : " + d1.equals(d2));
		System.out.println("d1 compareto  d2  : " + d1.compareTo(d2));

	}

Los resultados son:

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

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

En el ejemplo, vemos como solo se soportan unidades de tiempo

public static void main(String[] args) {
		
		LocalTime d1 = LocalTime.of(7,40);
		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);
	

	}

Con resultado:

get(), getHour(), getMinute(), getSecond(), getNano(), getLong()

int	get(TemporalField field)
int	getHour()
int	getMinute()
int	getSecond()
int	getNano()
long	getLong(TemporalField field)

Facilita el valor correspondiente (hora, minuto, segundo) solicitado, del campo LocalTime; tanto get(), como getLong() nos permite indicar por parámetro el dato que queremos obtener.

En el ejemplo, presentamos un momento en el tiempo, y le vamos extrayendo cada componente. Al final, utilizamos get() para obtener el minuto del día en el que estamos, y el getLong(), para conseguir los nanosegundos del día en los que estamos (Para nanos, necesitamos un long)

public static void main(String[] args) {
	LocalTime ahora = LocalTime.now();
		
	System.out.println("Ahora  :" + ahora.toString());
	System.out.println("hora   :" + ahora.getHour());	
	System.out.println("minuto :" + ahora.getMinute());	
	System.out.println("Segundo:" + ahora.getSecond());
	System.out.println("Nano   :" + ahora.getNano());

	System.out.println("Minuto del dia  :" + ahora.get(ChronoField.MINUTE_OF_DAY));	
	System.out.println("Nano del dia    :" + 	ahora.getLong(ChronoField.NANO_OF_DAY));	
}

Que nos presenta:

range()

ValueRange	range(TemporalField field)

Facilita el rango con que podemos filtrar cualquiera de los valores soportados, y por tanto una manera muy fácil de calcular dinámicamente filtros

En el ejemplo, vemos como calcular los filtros para distintas entradas, utilizando los ValueRange

public static void main(String[] args) {
		LocalTime ahora = LocalTime.now();
		
		System.out.println("Hora           :" + 
				ahora.toString());
		
		System.out.println("Rango  horas        :" + 
				ahora.range(ChronoField.HOUR_OF_DAY));
		System.out.println("Rango  minutos      :" + 
				ahora.range(ChronoField.MINUTE_OF_HOUR));	
		System.out.println("Rango  segundos      :" + 
				ahora.range(ChronoField.SECOND_OF_MINUTE));	
		System.out.println("Rango  minutos en dia:" + 
				ahora.range(ChronoField.MINUTE_OF_DAY));	

	}

Que nos facilita los siguientes resultados

toNanoOfDay(), toSecondOfDay(), toString()

long	toNanoOfDay()
int	toSecondOfDay()
String	toString()

Nos facilita, la hora como numero de nanosegundos o segundos transcurridos desde el inicio del día, o la version imprimible de la hora, con el formato HH:mm:ss

En el ejemplo, vemos como podemos utilizarlos

public static void main(String[] args) {
		LocalTime ahora = LocalTime.now();
		
		System.out.println("Fecha          :" + 
				ahora.toString());
		
		System.out.println("a segundos     :" + 
				ahora.toSecondOfDay());		
		System.out.println("a nanos        :" + 
				ahora.toNanoOfDay  ());	

	}

Que nos contesta

until()

long	until(Temporal endExclusive, TemporalUnit unit)

Calcula el tiempo que hay entre dos objetos LocalTime en la unidad indicada

En el ejemplo, calculamos el tiempo transcurrido entre dos LocalTime, y lo pedimos en minutos una vez, y en segundos otra.

public static void main(String[] args) {
		
		LocalTime d1 = LocalTime.of(10,43);
		System.out.println("d1               :" + d1);
		
		LocalTime d2 = LocalTime.of(15,42,22);
		System.out.println("d2               :" + d2);
		
		long p = d1.until(d2,ChronoUnit.MINUTES);
		System.out.println("en minutos           :" + p);
		
		long r = d1.until(d2, ChronoUnit.SECONDS);
		System.out.println("en segundos          :" + r);

	}

El resultado será

format()

String	format(DateTimeFormatter formatter)

Formatea la hora según la forma deseada

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

public static void main(String[] args) {
		
	LocalTime ahora = LocalTime.now();

	String formattedTime = ahora.format(DateTimeFormatter.ISO_TIME);
	System.out.println("LONG format     : " + formattedTime);

	formattedTime = ahora.format(DateTimeFormatter               .ofLocalizedTime(FormatStyle.MEDIUM));
	System.out.println("MEDIUM format   : " + formattedTime);

	formattedTime = ahora.format(DateTimeFormatter
		    .ofLocalizedTime(FormatStyle.SHORT));
	System.out.println("SHORT format    : " + formattedTime);
	
	String formateado = ahora.format(DateTimeFormatter.ofPattern("HH - mm - ss"));
	System.out.println("Formato manual..: " + formateado);
			
}

Daria como resultado

adjustInto()

Temporal	adjustInto(Temporal temporal)

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

En el ejemplo, vemos como podemos cambiar una hora, sin modificar nada mas

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

	      LocalTime date1 = LocalTime.parse("14:37:00");
	      date = (ZonedDateTime)date1.adjustInto(date);
	      System.out.println(date);  

	}

Obteniendo como resultado

atDate(), atOffset()

LocalDateTime	atDate(LocalDate date)
OffsetTime	atOffset(ZoneOffset offset)

Combina el objeto LocalTime, con una fecha, para obtener un objeto LocalDateTime completo, o le asignamos un offset para poder identificar la hora sobre la zona

Podemos ver un ejemplo

public static void main(String[] args) {
	  LocalTime ahora = LocalTime.now();
	  LocalDate unDia = LocalDate.of(2022, 9,15);
	  System.out.println("ahora      : " + ahora); 
	  LocalDateTime ahoraC = ahora.atDate(unDia);
	  System.out.println("ahoraC     : " + ahoraC); 
	      
	  OffsetTime otro = ahora.atOffset(ZoneOffset.ofHours(2));
	  System.out.println("Offset +2  : " + otro);  


}

Que nos facilita

Conclusión

La clase LocalTime mantiene una hora(hora, minuto, segundo) 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

Deja un comentario

/*Si te ha gustado el artículo
no dudes en compartirlo*/

Facebook
Twitter
LinkedIn

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies

ACEPTAR
Aviso de cookies

Ver mi IP

Ver ip de mi máquina
tipo valor
Ip: 34.204.169.230
Proxy: 34.204.169.230
Remote host: ec2-34-204-169-230.compute-1.amazonaws.com
Remote port: 55618
** 34.204.169.230, 172.70.175.231