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

Ends in 05h 23m 49s

java 8 – OffsetDateTime

La clase OffsetDateTime representa una fecha y hora con un desplazamiento de UTC/Greenwich en el sistema de calendario ISO-8601, como 2022-12-03T10:15:30+02:00. Es una representación inmutable de una fecha y hora con un desplazamiento. Esta clase almacena todos los campos de fecha y hora, con una precisión de nanosegundos, así como el desplazamiento de UTC/Greenwich

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

static OffsetDateTime	now()
static OffsetDateTime	now(Clock clock)
static OffsetDateTime	now(ZoneId zone)
static OffsetDateTime	of(int year, int month, int dayOfMonth, int hour, int       minute, int second, int nanoOfSecond, ZoneOffset offset)
static OffsetDateTime	of(LocalDate date, LocalTime time, ZoneOffset offset)
static OffsetDateTime	of(LocalDateTime dateTime, ZoneOffset offset)
static OffsetDateTime	ofInstant(Instant instant, ZoneId zone)
static OffsetDateTime	parse(CharSequence text)
static OffsetDateTime	parse(CharSequence text, DateTimeFormatter formatter)
static OffsetDateTime	from(TemporalAccessor temporal)

Obtiene un objeto OffsetDateTime desde distintas fuentes. Se trata del constructor de la clase.Podemos crear el objeto

  • Desde el reloj del sistema
  • Desde un reloj definido
  • Desde el reloj del sistema en la zona indicada
  • Pasándole 8enteros correspondientes a año, mes, día, hora , minuto, segundo y nanosegundo y offset
  • Entregando un LocalDate, un LocalTime y un offset
  • Pasándole un LocalDateTime y un Offset
  • Pasándole un objeto Instant y la zona horaria
  • Indicando el texto en una string, añadiéndole patrón de formato si no es el estandar

En el ejemplo, mostramos todas las posibilidades indicadas

public static void main(String[] args) {

	OffsetDateTime hoy = OffsetDateTime.now();

	Clock clock = Clock.systemDefaultZone();
	OffsetDateTime hoyDef = OffsetDateTime.now(clock);
	OffsetDateTime hoyMX = OffsetDateTime.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:" + 
		OffsetDateTime.of(2021, 10, 29, 10, 45,30,14725,ZoneOffset.UTC));
		
//-- con LocalDate y LocalTime
	LocalDate uno = LocalDate.of(2020, 9, 15);
	LocalTime unoT = LocalTime.of(14, 10, 0);
	ZoneOffset zoff = ZoneOffset.of("+02");
	System.out.println("Local??    :" + 
			OffsetDateTime.of(uno, unoT, zoff));
//Instant
	Instant ins = Instant.now();
	System.out.println("Instant    :" + 
			OffsetDateTime.ofInstant(ins, zoff));
// parse		
	DateTimeFormatter formato = DateTimeFormatter.ofPattern("dd MMMM yyyy HH:mm");

	System.out.println("dParse     :" + 
			OffsetDateTime.parse("2022-12-03T10:15:30+01:00"));
// from		
	System.out.println("dFrom      :" + 
			OffsetDateTime.from(ZonedDateTime.now()));
	}

Que nos daría el siguiente resultado

with(), withDayOfMonth(), withDayOfYear(), withMonth(), withYear(), withHour(), withMinute(), withNano(), withSecond(), withOffsetSameInstant(), withOffsetSameLocal, truncateTo().

OffsetDateTime	with(TemporalAdjuster adjuster)
OffsetDateTime	with(TemporalField field, long newValue)
OffsetDateTime	withDayOfMonth(int dayOfMonth)
OffsetDateTime	withDayOfYear(int dayOfYear)
OffsetDateTime	withHour(int hour)
OffsetDateTime	withMinute(int minute)
OffsetDateTime	withMonth(int month)
OffsetDateTime	withNano(int nanoOfSecond)
OffsetDateTime	withOffsetSameInstant(ZoneOffset offset)
OffsetDateTime	withOffsetSameLocal(ZoneOffset offset)
OffsetDateTime	withSecond(int second)
OffsetDateTime	withYear(int year)

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

OffsetDateTime	truncatedTo(TemporalUnit unit)

Nos permite obtener un nuevo objeto OffsetDateTime, 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) {
		
	OffsetDateTime hoy = OffsetDateTime.now();		
	System.out.println("Hoy        :" + hoy);
			
	OffsetDateTime d10 = hoy.with(ChronoField.DAY_OF_MONTH,10);
	System.out.println("d10        :" + d10);
		
	OffsetDateTime dlm = hoy.with(TemporalAdjusters.lastDayOfMonth());
	System.out.println("dlm        :" + dlm);
		
	OffsetDateTime d20 = hoy.withDayOfMonth(20);
	System.out.println("d20        :" + d20);
		
	OffsetDateTime dAny = hoy.withDayOfYear(364);
	System.out.println("dAny       :" + dAny);
		
	OffsetDateTime cambioMes = hoy.withMonth(8);
	System.out.println("cambioMes  :" + cambioMes);
  
	OffsetDateTime cambioAny = hoy.withYear(2034);
	System.out.println("cambioAny  :" + cambioAny);
		
	OffsetDateTime cambioHora = hoy.withHour(15);
	System.out.println("cambioHora :" + cambioHora);
		
	OffsetDateTime cambioZona = hoy.withOffsetSameInstant(ZoneOffset.UTC);
	System.out.println("cambioZona :" + cambioZona);
		
	OffsetDateTime cambioLocal = hoy.withOffsetSameLocal(ZoneOffset.MAX);
	System.out.println("cambioLocal :" + cambioLocal);
		
	
	OffsetDateTime truncadoMinutos = hoy.truncatedTo(ChronoUnit.MINUTES);
	System.out.println("truncadoMinutos :" + truncadoMinutos);
}

Conseguimos el siguiente resultado

plus(), plusDays(), plusHours(), plusMinutes(), plusSeconds(), plusNanos(), plusMonths(), plusWeeks(), plusYears()

OffsetDateTime	plus(long amountToAdd, TemporalUnit unit)
OffsetDateTime	plus(TemporalAmount amountToAdd)
OffsetDateTime	plusDays(long days)
OffsetDateTime	plusHours(long hours)
OffsetDateTime	plusMinutes(long minutes)
OffsetDateTime	plusMonths(long months)
OffsetDateTime	plusNanos(long nanos)
OffsetDateTime	plusSeconds(long seconds)
OffsetDateTime	plusWeeks(long weeks)
OffsetDateTime	plusYears(long years)

Crea un nuevo objeto OffsetDateTime 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 fecha sumando 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) {
		
	OffsetDateTime date = OffsetDateTime.of(2018, 12, 25,10, 45,30,14725,ZoneOffset.UTC);
	date = date.plusDays(2); // sumo dos dias
	System.out.println(date); // 2018-12-27T10:45:30.000014725Z

	date = date.plusWeeks(1); // sumo 1 semana a 2018-12-27T10:45:30.000014725Z
	System.out.println(date); // 2019-01-03T10:45:30.000014725Z

	date = date.plusMonths(28); // sumo 28 meses
	System.out.println(date); // presenta 2021-05-03T10:45:30.000014725Z

	date = date.plusYears(1); // suma un año
	System.out.println(date); // 2022-05-03T10:45:30.000014725Z
		
	date = date.plusHours(5); // sumo 5 horas
	System.out.println(date); // 2022-05-03T15:45:30.000014725Z

}

Nos obtiene la siguiente información

minus(), minusDays(), minusHours(), minusMinutes(), minusSeconds(), minusNanos(), minusMonths(), minusWeeks(), minusYears()

OffsetDateTime	minus(long amountToSubtract, TemporalUnit unit)
OffsetDateTime	minus(TemporalAmount amountToSubtract)
OffsetDateTime	minusDays(long days)
OffsetDateTime	minusHours(long hours)
OffsetDateTime	minusMinutes(long minutes)
OffsetDateTime	minusMonths(long months)
OffsetDateTime	minusNanos(long nanos)
OffsetDateTime	minusSeconds(long seconds)
OffsetDateTime	minusWeeks(long weeks)
OffsetDateTime	minusYears(long years)

Crea un nuevo objeto OffsetDateTime 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 fecha 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) {
		
	OffsetDateTime date = OffsetDateTime.of(2016,3, 13, 20, 15, 30, 14725, ZoneOffset.UTC);
	date = date.minusDays(7); //resto 7 dias
	System.out.println(date); // 2016-03-06T20:15:30.000014725Z
		
	date = date.minusMonths(2); //resto 2 meses
	System.out.println(date); // 2016-01-06T20:15:30.000014725Z
		
	date = date.minus(100,ChronoUnit.DAYS); //resto 100 dias
	System.out.println(date); // 2015-09-28T20:15:30.000014725Z
		
	date = date.minusHours(2); //resto 2 horas
	System.out.println(date); // 2015-09-28T18:15:30.000014725Z		
		
}

Nos presenta la siguiente información

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

boolean	isAfter(OffsetDateTime other)
boolean	isBefore(OffsetDateTime other)
boolean	equals(OffsetDateTime obj)
boolean	isSupported(TemporalField field)
boolean	isSupported(TemporalUnit unit)
int	compareTo(OffsetDateTime  other)

Dados dos objetos OffsetDateTime, permite comparar si uno de ellos es anterior al otro o son iguales, así como comprobar si una determinada unidad temporal esta soportada por el objeto en cuestión

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

public static void main(String[] args) {

	OffsetDateTime d1 = OffsetDateTime
		.of(2022, 8, 13, 10, 22,0,0,ZoneOffset.ofHours(-2));
	OffsetDateTime d2 = OffsetDateTime
		.of(2022, 3, 13, 15, 32,0,0,ZoneOffset.ofHours(-2));

	System.out.println("d1               :" + d1);
	System.out.println("d2               :" + d2);
	System.out.println("d1.isAfter(d2 )  :" + d1.isAfter(d2));	

}

Nos dará los resultados siguientes

O bien, al probar si una unidad es soportada por el campo, podemos hacer

public static void main(String[] args) {
		
	OffsetDateTime d1 = OffsetDateTime.of(2022, 9, 13,20,25,0,0,ZoneOffset.MIN);
	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);
}

No dara como resultado que acepta estas unidades

get(), getDayOfMonth(), getDayOfWeek(), getDayOfYear(), getHour(), getLong(), getMinute(), getSecond(), getNano(), getMonth(), getMonthValue(), getYear()

int	get(TemporalField field)
int	getDayOfMonth()
DayOfWeek	getDayOfWeek()
int	getDayOfYear()
int	getHour()
long	getLong(TemporalField field)
int	getMinute()
int	getSecond()
int	getNano()
Month	getMonth()
int	getMonthValue()
int	getYear()
ZoneOffset	getOffset()

Nos proporciona información acerca del contenido del campo

En el ejemplo, vemos como se puede ir obteniendo la información de un campo OffsetDateTime

public static void main(String[] args) {
	OffsetDateTime d1 = 
			OffsetDateTime.of(2022, 10, 13, 10, 22,0,0,ZoneOffset.MAX);
		
	System.out.println("Dia semana     : " + 
			d1.getDayOfWeek());
	System.out.println("Dia del mes    : " + 
			d1.get(ChronoField.DAY_OF_MONTH));
	System.out.println("Mes            : " + 
			d1.get(ChronoField.MONTH_OF_YEAR));
	System.out.println("Hora           : " + 
			d1.get(ChronoField.HOUR_OF_DAY));
	System.out.println("Mes            : " + 
			d1.getMonth());
	System.out.println("Mes numero     : " + 
			d1.getMonthValue());
	System.out.println("Nano           : " + 
			d1.getNano());
	System.out.println("ZoneOffset     : " + 
			d1.getOffset());
	
}

Nos ofrece los siguientes resultados

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 y preguntando por las unidades que anteriormente hemos visto que soportaba con el isSupported()

public static void main(String[] args) {
	OffsetDateTime hoy = OffsetDateTime.now();
		
	System.out.println("Fecha                     :" + 
			hoy.toString());
		
	System.out.println("Rango  dias mes           :" + 
			hoy.range(ChronoField.DAY_OF_MONTH));
	System.out.println("Rango  dias año           :" + 
			hoy.range(ChronoField.DAY_OF_YEAR));
	System.out.println("Rango  segundos por minuto:" + 
			hoy.range(ChronoField.SECOND_OF_MINUTE));	
	System.out.println("Rango  segundos por dia   :" + 
			hoy.range(ChronoField.SECOND_OF_DAY));
		
}

Que obtiene

toEpochSecond(), toInstant(), toLocalDate(), toLocaldateTime(), toLocalTime(), toOffsetTime(), toZoneDateTime(), toString()


long	        toEpochSecond()
Instant	        toInstant()
LocalDate	toLocalDate()
LocalDateTime	toLocalDateTime()
LocalTime	toLocalTime()
OffsetTime	toOffsetTime()
String	        toString()
ZonedDateTime	toZonedDateTime()

Nos permite obtener el valor del OffsetDateTime (o parte del valor) a otro campo temporal

En el ejemplo, vemos algunos usos

public static void main(String[] args) {

	OffsetDateTime d1 = 
			OffsetDateTime.of(2022, 10, 13, 10, 22,0,0,ZoneOffset.MAX);
	System.out.println("toEpochSecond   :" + d1.toEpochSecond());
	System.out.println("toString        :" + d1.toString());
	System.out.println("toInstant       :" + d1.toInstant());
	System.out.println("toLocalDate     :" + d1.toLocalDate());
	System.out.println("toLocalDateTime :" + d1.toLocalDateTime());
	System.out.println("toLocalTime     :" + d1.toLocalTime());
	System.out.println("toOffsetTime    :" + d1.toOffsetTime());
	System.out.println("toZonedDateTime :" + d1.toZonedDateTime());
}

Que consigue los siguientes resultados

until()

long	until(Temporal endExclusive, TemporalUnit unit)

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

En el ejemplo, calculamos el tiempo transcurrido entre dos OffsetDateTime, y lo pedimos en días una vez, y en horas otra.

public static void main(String[] args) {
		
	OffsetDateTime d1 = 
			OffsetDateTime.of(2022, 3, 13,20,35,0,0,ZoneOffset.MAX);
	System.out.println("d1               :" + d1);
		
	OffsetDateTime d2 = 
			OffsetDateTime.of(2022, 4, 13,20,35,0,0,ZoneOffset.MAX);
	System.out.println("d2               :" + d2);
		
	long dias = d1.until(d2,ChronoUnit.DAYS);
	System.out.println("Dias             :" + dias);
	
	long horas = d1.until(d2, ChronoUnit.HOURS);
	System.out.println("Horas            :" + horas);

}

Que nos presenta esos cálculos

format()

String	format(DateTimeFormatter formatter)

Formatea la fecha y hora según la forma deseada

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

public static void main(String[] args) {

	OffsetDateTime hoy =  OffsetDateTime
				.parse("2018-12-12T13:30:30+05:00");
	DateTimeFormatter dtf = DateTimeFormatter
				.ofLocalizedDateTime(FormatStyle.SHORT);
	DateTimeFormatter dfu = DateTimeFormatter.ISO_TIME;

	String formattedDate = dtf.format(hoy);
	System.out.println("LONG format     : " + formattedDate);
	String formattedDateU = dfu.format(hoy);
	System.out.println("Full time format: " + formattedDateU);

	formattedDate = hoy.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
	System.out.println("MEDIUM format   : " + formattedDate);

	formattedDate = hoy.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT));
	System.out.println("SHORT format    : " + formattedDate);

	String formateado = hoy
		.format(DateTimeFormatter.ofPattern("dd - MMM - yy    hh:mm"));

	System.out.println("Formato manual..: " + formateado);
}

Que nos calcula

adjustInto()

Temporal	adjustInto(Temporal temporal)

Obtiene un objeto temporal tras aplicarle al objeto temporal 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) {
		
		OffsetDateTime date = OffsetDateTime.now();
	      System.out.println(date);  

	      LocalTime date1 = LocalTime.parse("20:15");
	      date = (OffsetDateTime)date1.adjustInto(date);
	      System.out.println(date);  

	      LocalDateTime date2 = LocalDateTime.now();
	      System.out.println(date2);  	      
	}
Podremos ver en consola la salida, como

atZoneSameInstant(), atZoneSimilarLocal

ZonedDateTime	atZoneSameInstant(ZoneId zone)
ZonedDateTime	atZoneSimilarLocal(ZoneId zone)

Combina el objeto OffsetDateTime con la zona para obtener em mismo instante, o la misma fecha y hora local

En el ejemplo vemos la diferencia entre los dos métodos, ya que mientras con uno, traslado la hora para que el instante coincida, en el otro caso, me limito a mover la zona, manteniendo la hora

public static void main(String[] args) {
	OffsetDateTime ahora = OffsetDateTime.now();
		  
	System.out.println("ahora      : " + ahora); 
	ZonedDateTime ahoraC = ahora.atZoneSameInstant(ZoneId.of("America/Mexico_City"));
	System.out.println("ahoraC     : " + ahoraC); 
	      
	ZonedDateTime otro = ahora.atZoneSimilarLocal(ZoneOffset.ofHours(2));
	System.out.println("Offset +2  : " + otro);  
}

Viendo en Consola, el trabajo realizado

Conclusión

La clase OffsetDateTime mantiene una fecha y hora(días, mes, año, hora, minuto, segundo, mas Zone) y puede ser reutilizados en el resto de clases de la api java.time, aparte que, al representar la hora internacional, se puede utilizar para trabajar con distintas zonas horarias, permitiendo cálculos universales

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: 35.172.230.21
Proxy: 35.172.230.21
Remote host: ec2-35-172-230-21.compute-1.amazonaws.com
Remote port: 53732
** 35.172.230.21, 172.71.194.177