Java Duration Clase

La clase Duration es una clase importante en la API de fecha y hora (paquete java.time) introducida en Java 8, utilizada para representar intervalos de tiempo o duraciones.

La clase Duration se utiliza principalmente para calcular la diferencia entre dos puntos de tiempo, o para representar una longitud de tiempo específica.

Conceptos básicos

Los intervalos de tiempo representados por la clase Duration pueden ser precisos a nivel de nanosegundos. Se utiliza principalmente para manejar cantidades basadas en el tiempo (horas, minutos, segundos y nanosegundos), sin involucrar conceptos de fecha o zona horaria.

Características principales:

  1. Inmutabilidad: los objetos Duration no se pueden modificar una vez creados
  2. Seguridad para subprocesos: se puede usar de forma segura en entornos multiproceso
  3. Alta precisión: puede ser preciso a nivel de nanosegundos
  4. Encadenamiento: admite el encadenamiento de métodos

Crear objetos Duration

La clase Duration proporciona varios métodos estáticos para crear instancias de Duration:

1. Crear mediante unidades de tiempo

Ejemplo

// Crear una Duration que dure 2 horas
Duration twoHours = Duration.ofHours(2);

// Crear una Duration que dure 30 minutos
Duration thirtyMinutes = Duration.ofMinutes(30);

// Crear una Duration que dure 45 segundos
Duration fortyFiveSeconds = Duration.ofSeconds(45);

// Crear una Duration que dure 500 milisegundos
Duration fiveHundredMillis = Duration.ofMillis(500);

// Crear una Duration que dure 1000000 nanosegundos
Duration oneMillionNanos = Duration.ofNanos(1_000_000);

2. Crear mediante cantidades de tiempo

Ejemplo

// Crear una Duration que dure 1 día, 2 horas y 3 minutos
Duration customDuration = Duration.ofDays(1).plusHours(2).plusMinutes(3);

3. Calcular entre dos puntos de tiempo

Ejemplo

Instant start = Instant.now();
// Realizar algunas operaciones...
Instant end = Instant.now();
Duration elapsed = Duration.between(start, end);

4. Crear mediante análisis de cadenas

Ejemplo

// Crear a partir de una cadena en formato ISO-8601
Duration parsedDuration = Duration.parse("PT2H30M15S"); // 2 horas 30 minutos 15 segundos

Métodos comunes

La clase Duration proporciona un amplio conjunto de métodos para manejar intervalos de tiempo:

1. Obtener valores de tiempo

Ejemplo

Duration duration = Duration.ofHours(2).plusMinutes(30);

long hours = duration.toHours();      // 2
long minutes = duration.toMinutes();  // 150
long seconds = duration.getSeconds(); // 9000
int nanos = duration.getNano();      // 0

2. Operaciones de tiempo

Ejemplo

Duration d1 = Duration.ofHours(2);
Duration d2 = Duration.ofMinutes(30);

// Suma
Duration sum = d1.plus(d2);  // 2 horas 30 minutos

// Resta
Duration diff = d1.minus(d2); // 1 hora 30 minutos

// Multiplicación
Duration multiplied = d1.multipliedBy(3); // 6 horas

// División
Duration divided = d1.dividedBy(2); // 1 hora

3. Operaciones de comparación

Ejemplo

Duration d1 = Duration.ofHours(1);
Duration d2 = Duration.ofMinutes(90);

boolean isEqual = d1.equals(d2);      // false
int comparison = d1.compareTo(d2);    // -1 (d1 < d2)
boolean isNegative = d1.isNegative(); // false
boolean isZero = d1.isZero();         // false

4. Otros métodos útiles

Ejemplo

Duration duration = Duration.ofMinutes(90);

// Convertir a otras unidades
long hours = duration.toHours();      // 1
long minutes = duration.toMinutes();  // 90
long seconds = duration.toSeconds();  // 5400
long millis = duration.toMillis();    // 5400000
long nanos = duration.toNanos();      // 5400000000000

// Obtener cada parte
long secondsPart = duration.getSeconds(); // 5400
int nanoPart = duration.getNano();       // 0

// Obtener el valor absoluto
Duration absDuration = duration.abs();

// Obtener el valor negativo
Duration negated = duration.negated();

Ejemplos de aplicación práctica

Ejemplo 1: Calcular el tiempo de ejecución del código

Ejemplo

Instant start = Instant.now();

// Simular una operación que consume tiempo
try {
    Thread.sleep(1500);
} catch (InterruptedException e) {
    e.printStackTrace();
}

Instant end = Instant.now();
Duration elapsed = Duration.between(start, end);

System.out.println("Tiempo de ejecución del código: " + elapsed.toMillis() + " milisegundos");

Ejemplo 2: Conversión de formato de tiempo

Ejemplo

Duration duration = Duration.ofMinutes(135);

// Convertir al formato "HH:MM:SS"
long hours = duration.toHours();
long minutes = duration.minusHours(hours).toMinutes();
long seconds = duration.minusHours(hours).minusMinutes(minutes).getSeconds();

String formatted = String.format("%02d:%02d:%02d", hours, minutes, seconds);
System.out.println(formatted); // Salida: 02:15:00

Ejemplo 3: Control de tiempo de espera

Ejemplo

Duration timeout = Duration.ofSeconds(30);
Instant startTime = Instant.now();

while (true) {
    // Comprobar si se ha agotado el tiempo
    if (Duration.between(startTime, Instant.now()).compareTo(timeout) > 0) {
        System.out.println("Tiempo de espera agotado");
        break;
    }
   
    // Realizar otras operaciones...
}

Ejemplo

import java.time.Duration;
import java.time.LocalTime;
import java.time.Instant;

public class DurationDemo {
    public static void main(String[] args) {
        // Varias formas de crear objetos Duration
       
        // 1. Usando el método of...()
        Duration duration1 = Duration.ofHours(2); // 2 horas
        Duration duration2 = Duration.ofMinutes(90); // 90 minutos
        System.out.println("Duration 1: " + duration1);
        System.out.println("Duration 2: " + duration2);
       
        // 2. Usando el método between() para calcular la duración entre dos puntos de tiempo
        LocalTime startTime = LocalTime.of(9, 0);
        LocalTime endTime = LocalTime.of(11, 30);
        Duration duration3 = Duration.between(startTime, endTime);
        System.out.println("Duration between times: " + duration3);
       
        // 3. Usando el método parse() para crear a partir de una cadena
        Duration duration4 = Duration.parse("PT2H30M"); // Formato ISO-8601
        System.out.println("Parsed Duration: " + duration4);
       
        // 4. Usando Instant para calcular la diferencia de tiempo
        Instant startInstant = Instant.now();
        // Simular una operación que consume tiempo
        try { Thread.sleep(1500); } catch (InterruptedException e) {}
        Instant endInstant = Instant.now();
        Duration duration5 = Duration.between(startInstant, endInstant);
        System.out.println("Execution duration: " + duration5.toMillis() + "ms");
    }
}

El resultado de la salida es:

Duration 1: PT2H
Duration 2: PT1H30M
Duration between times: PT2H30M
Parsed Duration: PT2H30M
Execution duration: 1501ms

Notas

  1. Problema de precisión: Duration puede ser preciso a nivel de nanosegundos, pero la precisión real depende del soporte del sistema operativo y el hardware.Diferencia con Period

  2. Duration se utiliza para medir horas, minutos, segundos y nanosegundos basados en el tiempo：

    • Period se utiliza para medir años, meses y días basados en fechas
    • Inmutabilidad: todos los objetos Duration son inmutables; cualquier operación de modificación devuelve una nueva instancia de Duration.

  3. Manejo de valores negativos: Duration puede representar intervalos de tiempo negativos, lo cual puede ocurrir al calcular diferencias de tiempo.Formato de cadena: utiliza el formato de duración ISO-8601

  4. , donde:P es el indicador de duración

  5. D es el número de díasT es el separador de la parte de tiempoPnDTnHnMn.nSH es el número de horas

    • M es el número de minutos
    • S es el número de segundos (puede tener parte decimal)
    • Resumen
    • La clase Duration de Java proporciona una herramienta potente y flexible para manejar intervalos de tiempo. Al dominar el uso de la clase Duration, los desarrolladores pueden manejar más fácilmente diversas necesidades relacionadas con el cálculo de tiempo, como medición de rendimiento, control de tiempo de espera, programación de tareas, etc. La clase Duration, utilizada junto con otras clases de fecha y hora introducidas en Java 8 (como Instant, LocalDateTime, etc.), puede construir un código de manejo de tiempo más robusto y legible.
    • Otras extensiones
    • IA pensando...

Resumen

Java InputStream Clase

Lista de notas