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
Descubre más desde Recursos para formacion
Suscríbete y recibe las últimas entradas en tu correo electrónico.
