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

Ends in 05h 23m 49s

Java 8 – OffsetTime

OffsetTimees un objeto de fecha y hora inmutable y thread-safe, que representa una hora, a menudo vista como hora-minuto-segundo-compensación. Esta clase almacena todos los campos de tiempo, con una precisión de nanosegundos, así como una compensación de zona. Por ejemplo, el valor «13:45.30.123456789+02:00» se puede almacenar en un archivo OffsetTime.

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

static OffsetTime	now()
static OffsetTime	now(Clock clock)
static OffsetTime	now(ZoneId zone)
static OffsetTime	of(int hour, int minute, int second, int nanoOfSecond, ZoneOffset offset)
static OffsetTime	of(LocalTime time, ZoneOffset offset)
static OffsetTime	ofInstant(Instant instant, ZoneId zone)
static OffsetTime	parse(CharSequence text)
static OffsetTime	parse(CharSequence text, DateTimeFormatter formatter)
static OffsetTime	from(TemporalAccessor temporal)

Se trata de los constructores del objeto OffsetTime 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 cuatro enteros mas la compensacion, correspondientes a hora, minuto, segundo y nanosegundo
  • Pasándole un objeto LocalTime, mas la ZonaOffset que deseamos utilizar
  • Pasándole un objeto Instant y el identificador de zona a utilizar
  • Indicando el texto en una string, añadiéndole patrón de formato si no es el estandar
  • Obteniéndolo desde otro objeto temporal COMPATIBLE

A continuación, vemos un ejemplo de como podemos utilizar estos métodos

public static void main(String[] args) {

	OffsetTime hoy = OffsetTime.now();

	Clock clock = Clock.systemDefaultZone();
	OffsetTime hoyDef = OffsetTime.now(clock);
	OffsetTime hoyMX = OffsetTime.now(ZoneId.of("America/Mexico_City"));
		
	System.out.println("Hoy        :" + hoy);
	System.out.println("Hoy Def    :" + hoyDef);
	System.out.println("Hoy MX     :" + hoyMX);
//---of				
	System.out.println("con detalle:" + 
			OffsetTime.of( 10, 45,30,14725,ZoneOffset.UTC));
		
//-- con LocalTime
	LocalTime unoT = LocalTime.of(14, 10, 0);
	ZoneOffset zoff = ZoneOffset.of("+02");
	System.out.println("Local??    :" + 
			OffsetTime.of(unoT, zoff));
//Instant
	Instant ins = Instant.now();
	System.out.println("Instant    :" + 
			OffsetTime.ofInstant(ins, zoff));
// parse		
	DateTimeFormatter formato = DateTimeFormatter.ofPattern("HH:mm");

	System.out.println("dParse     :" + 
			OffsetTime.parse("10:15:30+01:00"));
// from		
	System.out.println("dFrom      :" + 
			OffsetTime.from(ZonedDateTime.now()));
}

Y podemos ver en la consola

with(), withHour(), withMinute(), withNano(), withSecond(), withOffsetSameInstant(), withOffsetSameLocal, truncateTo().

OffsetTime	with(TemporalAdjuster adjuster)
OffsetTime	with(TemporalField field, long newValue)
OffsetTime	withHour(int hour)
OffsetTime	withMinute(int minute)
OffsetTime	withNano(int nanoOfSecond)
OffsetTime	withOffsetSameInstant(ZoneOffset offset)
OffsetTime	withOffsetSameLocal(ZoneOffset offset)
OffsetTime	withSecond(int second)

Obtiene un nuevo objeto OffsetTime, tras modificar el OffsetTime que se pasa, en la unidad indicada por el método, y con el valor aportado por el parámetro.

OffsetTime	truncatedTo(TemporalUnit unit)

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

En el ejemplo, podemos ver algunos usos

public static void main(String[] args) {
		
	OffsetTime ahora = OffsetTime.now();		
	System.out.println("Hoy        :" + ahora);
				
	OffsetTime cambioHora = ahora.withHour(15);
	System.out.println("cambioHora :" + cambioHora);
		
	OffsetTime cambioZona = ahora.withOffsetSameInstant(ZoneOffset.UTC);
	System.out.println("cambioZona :" + cambioZona);
		
	OffsetTime cambioLocal = ahora.withOffsetSameLocal(ZoneOffset.MAX);
	System.out.println("cambioLocal:" + cambioLocal);
		
	
	OffsetTime truncadoMinutos = ahora.truncatedTo(ChronoUnit.MINUTES);
	System.out.println("truncadoMinutos :" + truncadoMinutos);
}

Y conseguimos

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

OffsetTime	plus(long amountToAdd, TemporalUnit unit)

OffsetTime	plus(TemporalAmount amountToAdd)

OffsetTime	plusHours(long hours)

OffsetTime	plusMinutes(long minutes)

OffsetTime	plusNanos(long nanos)

OffsetTime	plusSeconds(long seconds)

Crea un nuevo objeto OffsetTime a partir del objeto pasado, tras sumar la cantidad, en las unidades indicadas por el método.

En el ejemplo vemos como podemos obtener una hora sumando una cantidad de unidades a otra. Esa cantidad de unidades adquieren valor en función del método utilizado y/o de la unidad indicada

public static void main(String[] args) {
	
	OffsetTime hora = OffsetTime.of(10, 45,30,14725,ZoneOffset.UTC);
	
	hora = hora.plusHours(5); // sumo 5 horas
	System.out.println(hora); // 15:45:30.000014725Z
	
	hora = hora.plus(20, ChronoUnit.MINUTES); // sumo 20 minutos
	System.out.println(hora); // 16:05:30.000014725Z
	
	hora = hora.plusMinutes(35); // sumo 35 minutos
	System.out.println(hora); // 16:40:30.000014725Z
	
	hora = hora.plus(Duration.ofHours(1)); // sumo 1 horas
	System.out.println(hora); // 17:40:30.000014725Z

}

Podemos ver el resultado calculado como

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

OffsetTime	minus(long amountToSubtract, TemporalUnit unit)
OffsetTime	minus(TemporalAmount amountToSubtract)
OffsetTime	minusHours(long hours)
OffsetTime	minusMinutes(long minutes)
OffsetTime	minusNanos(long nanos)
OffsetTime	minusSeconds(long seconds)

Crea un nuevo objeto OffsetTime a partir del objeto pasado, tras restar la cantidad, en las unidades indicadas por el método.

En el ejemplo vemos como podemos obtener una hora restando una cantidad de unidades a otra. Esa cantidad de unidades adquieren valor en función del método utilizado

public static void main(String[] args) {
	
	OffsetTime hora = OffsetTime.of(10, 45,30,14725,ZoneOffset.UTC);
	
	hora = hora.minusHours(5); // resto 5 horas
	System.out.println(hora); // 05:45:30.000014725Z
	
	hora = hora.minus(20, ChronoUnit.MINUTES); // resto 20 minutos
	System.out.println(hora); // 05:25:30.000014725Z
	
	hora = hora.minusMinutes(35); // resto 35 minutos
	System.out.println(hora); // 04:50:30.000014725Z
	
	hora = hora.minus(Duration.ofHours(1)); // resto 1 horas
	System.out.println(hora); // 03:50:30.000014725Z

}

Nos da los siguientes resultados

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

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

Dados dos OffsetTime, permite comparar si una hora es anterior a otra o son iguales, teniendo en cuenta también las zonas horarias

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

public static void main(String[] args) {
	
	OffsetTime d1 = OffsetTime.of(10, 45,30,14725,ZoneOffset.UTC);
	System.out.println("d1                : " + d1);
	
	OffsetTime d2 = OffsetTime.of(20, 45,30,14725,ZoneOffset.UTC);
	System.out.println("d2                : " + d2);

	System.out.println("d1 posterior a d2 : " + d1.isAfter(d2));
	System.out.println("d2 anterior  a d1 : " + d2.isBefore(d1));
	System.out.println("d1 igual  a d2    : " + d1.equals(d2));
	System.out.println("d1 compareto  d2  : " + d1.compareTo(d2));

}

Que nos calculara

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

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

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

public static void main(String[] args) {

OffsetTime d1 = OffsetTime.parse("12:20+01:00");
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);

}

Y, segun anunciamos, obtenemos

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

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

Facilita el valor correspondiente (hora, minuto, segundo, y desplazamiento) solicitado, del campo OffsetTime; 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) {
	OffsetTime ahora = OffsetTime.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("Offset :" + ahora.getOffset());

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

Y veremos en consola

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) {
	OffsetTime ahora = OffsetTime.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));
	
}

Nos presenta en consola

toLocalTime()

LocalTime	toLocalTime()

Nos facilita un LocalTime correspondiente a la hora indicada por el OffsetTime, pero sin indicar la zona

En el ejemplo, vemos su comportamiento

public static void main(String[] args) {
	OffsetTime ahora = OffsetTime.now();
		
	System.out.println("OffsetTime : " + ahora);
	System.out.println("LocalTime  : " 
			+ ahora.toLocalTime());	

}

y los valores que presenta

toString()

String	toString()

Nos presenta el contenido del campo como una string con formato 20:10:35+02:00

until()

long	until(Temporal endExclusive, TemporalUnit unit)

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

En el ejemplo, calculamos el tiempo transcurrido entre dos OffsetTime, y lo pedimos en horas, minutos y en segundos

public static void main(String[] args) {
	
	OffsetTime d1 = OffsetTime.parse("10:42+02:00");
	System.out.println("d1               :" + d1);
	
	OffsetTime d2 = OffsetTime.parse("10:43+06:00");
	System.out.println("d2               :" + d2);
	
	long h = d1.until(d2,ChronoUnit.HOURS);
	System.out.println("en horas             :" + h);
	
	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);

}

Y nos calcula el resultado, teniendo también en cuenta el offset

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) {
	
	OffsetTime ahora = OffsetTime.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 ZZZZ"));
	System.out.println("Formato manual..: " + formateado);
		
}

Y conseguimos la siguiente presentación

adjustInto()

Temporal	adjustInto(Temporal temporal)

Obtiene un objeto temporal tras aplicarle al OffsetTime 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);

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

}
Nos entrega

atDate()

OffsetDateTime	atDate(LocalDate date)

Combina el objeto OffsetTime, con una fecha, para obtener un objeto OffsetDateTime completo,

Podemos ver un ejemplo

public static void main(String[] args) {
      OffsetTime ahora = OffsetTime.now();
      LocalDate unDia = LocalDate.of(2022, 9,15);
      System.out.println("ahora      : " + ahora); 
      OffsetDateTime ahoraC = ahora.atDate(unDia);
      System.out.println("ahoraC     : " + ahoraC); 
}

Que conseguiría la siguiente información

Conclusión

La clase OffsetTime mantiene una hora(hora, minuto, segundo) pero tambien mantiene la Zona horaria 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 facilitó 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: 3.238.71.155
Proxy: 3.238.71.155
Remote host: ec2-3-238-71-155.compute-1.amazonaws.com
Remote port: 55114
** 3.238.71.155, 162.158.78.29