Duke Guardian

En el artículo Revisando Java 8, entre varias novedades se mencionó la nueva Date API.

Desde la versión Java 1.0, los años en el API empiezan en 1900 y los meses inician con el índice 0. Por lo tanto, cualquier fecha representada haciendo uso de la clase java.util.Date no era legible. Por ejemplo, representaremos la fecha en que Java 8 fue liberado 18 de Marzo del 2014:

Date date = new Date(114, 2, 18);
System.out.println(date);

Como resultado de la línea anterior tenemos lo siguiente:

Tue Mar 18 00:00:00 AEST 2014

En Java 1.1, la clase java.util.Calendar fue agregada y varios métodos de la clase java.util.Date fueron deprecados. Hacer uso de la clase java.util.Calendar no dio mayores beneficios dado su diseño.

Calendar calendar = new GregorianCalendar(2014, 2, 18);
System.out.println(calendar.getTime());

A partir de Java 8, la nueva Date API es amigable y esta basada en el proyecto Joda-Time la cual fue adoptada como JSR-310.

En el paquete java.time, se puede encontrar las nuevas clases del Date API como LocalDate, LocalTime, LocalDateTime, Instant, Duration y Period, de las cuales hablaremos a continuación.

LocalDate, LocalTime and LocalDateTime

LocalDate

LocalDate, representa una fecha sin tener en cuenta el tiempo. Haciendo uso del método of(int year, int month, int dayOfMonth), se puede crear un LocalDate.

LocalDate date = LocalDate.of(1989, 11, 11); //1989-11-11
System.out.println(date.getYear()); //1989
System.out.println(date.getMonth()); //NOVEMBER
System.out.println(date.getDayOfMonth()); //11

También, se puede hacer uso del enum Month para dar legibilidad al código.

LocalDate date = LocalDate.of(1989, Month.NOVEMBER, 11);

Finalmente, para capturar el LocalDate actual se puede usar el método now():

LocalDate date = LocalDate.now();

LocalTime

De manera similar, se tiene LocalTime, la cual representa un tiempo determinado. Haciendo uso del método of(), esta clase puede crear un LocalTime teniendo en cuenta la hora y minuto; hora, minuto y segundo y finalmente hora, minuto, segundo y nanosegundo.

LocalTime time = LocalTime.of(5, 30, 45, 35); //05:30:45:35
System.out.println(time.getHour()); //5
System.out.println(time.getMinute()); //30
System.out.println(time.getSecond()); //45
System.out.println(time.getNano()); //35

Finalmente, para capturar el LocalTime actual se puede usar el método now():

LocalTime time = LocalTime.now();

LocalDateTime

LocalDateTime, es una clase compuesta, la cual combina las clases anteriormente mencionadas LocalDate y LocalTime.

En el siguiente fragmento de código se puede apreciar como construir un LocalDateTime haciendo uso de todos los campos (año, mes, día, hora, minuto, segundo, nanosegundo):

LocalDateTime dateTime = LocalDateTime.of(1989, 11, 11, 5, 30, 45, 35); //1989-11-11T05:30:45.000000035

También, se puede crear un objeto LocalDateTime basado en los tipos LocalDate y LocalTime, a continuación se muestra el uso del método of(LocalDate date, LocalTime time):

LocalDate date = LocalDate.of(1989, 11, 11);
LocalTime time = LocalTime.of(5, 30, 45, 35);
LocalDateTime dateTime = LocalDateTime.of(date, time);

Finalmente, se puede capturar el LocalDateTime exacto de la ejecución usando el método now(), como se muestra a continuación.

LocalDateTime dateTime = LocalDateTime.now();

NOTA: Estos objetos no tienen ninguna información relacionada al timezone.

Instant

Instant, representa el número de segundos desde 1 de Enero de 1970. Es un modelo de fecha y tiempo fácil de interpretar para una máquina.

Instant instant = Instant.ofEpochSecond(120);
System.out.println(instant);

El código anterior da como resultado:

1970-01-01T00:02:00Z

De igual manera que las clases ya mencionadas, Instant provee el método now().

Instant instant = Instant.now();

Duration and Period

Duration

Duration, hace referencia a la diferencia que existe entre dos objetos de tiempo.

En el siguiente ejemplo, la duración se calcula haciendo uso de dos objetos LocalTime:

LocalTime localTime1 = LocalTime.of(12, 25);
LocalTime localTime2 = LocalTime.of(17, 35);
Duration duration = Duration.between(localTime1, localTime2);

Otra opción de calcular la duración entre dos objetos es usando dos objetos LocalDateTime:

LocalDateTime localDateTime1 = LocalDateTime.of(2016, Month.JULY, 18, 14, 13);
LocalDateTime localDateTime2 = LocalDateTime.of(2016, Month.JULY, 20, 12, 25);
Duration duration = Duration.between(localDateTime1, localDateTime2);

También, se puede crear una duración basada en el método of(long amount, TemporalUnit unit). En el siguiente ejemplo, se muestra como crear un Duration de un día.

Duration oneDayDuration = Duration.of(1, ChronoUnit.DAYS);

Se puede apreciar el uso del enum ChronoUnit, la cual es una implementación de TemporalUnit y nos brinda una serie de unidades de períodos de tiempo como ERAS, MILLENNIA, CENTURIES, DECADES, YEARS, MONTHS, WEEKS, etc.

También, se puede crear Duration basado en los métodos ofDays(long days), ofHours(long hours), ofMilis(long milis), ofMinutes(long minutes), ofNanos(long nanos), ofSeconds(long seconds). El ejemplo anterior puede ser reemplazado por la siguiente línea:

Duration oneDayDuration = Duration.ofDays(1);

Period

Period, hace referencia a la diferencia que existe entre dos fechas.

LocalDate localDate1 = LocalDate.of(2016, Month.JULY, 18);
LocalDate localDate2 = LocalDate.of(2016, Month.JULY, 20);
Period period = Period.between(localDate1, localDate2);

Se puede crear Period basado en el método of(int years, int months, int days). En el siguiente ejemplo, se crea un período de 1 año 2 meses y 3 días:

Period period = Period.of(1, 2, 3);

Del mismo modo que Duration, se puede crear Period basado en los métodos ofDays(int days), ofMonths(int months), ofWeeks(int weeks), ofYears(int years).

Period period = Period.ofYears(1);

Gracias a Takipi por dejarme usar sus imágenes.


Eddú Meléndez

Java Software Engineer, Open Source Contributor