Duration — wat is het, berekenen van tijdsduur in Android

Wat is Duration?

Duration — is een klasse die de hoeveelheid tijd in seconden en nanoseconden modelleert. Het vertegenwoordigt een tijdgebaseerde duur, dat wil zeggen het fysieke aantal seconden, niet gebonden aan een kalender. Duration kan worden weergegeven als „125 minuten” of „2 uur 5 minuten” — in tegenstelling tot Period, dat „2 maanden” zal zeggen.

De interne representatie van Duration bestaat uit twee velden: long seconds (seconden) en int nanos (nanoseconden, van 0 tot 999999999). De waarde kan negatief zijn — dit betekent een duur „terug” in de tijd. De maximale waarde is ±31557014167219200 seconden.

Volgens Baeldung (2024), is Duration de sleutelklasse voor het berekenen van operationele duur, het instellen van time-outs en het meten van prestaties. Duration is onveranderlijk en thread-safe, waardoor het in een multi-thread omgeving zonder synchronisatie kan worden gebruikt.

De klasse implementeert de interfaces Comparable, TemporalAmount en TemporalUnit. TemporalAmount maakt het mogelijk Duration te gebruiken in de plus/minus methoden van LocalTime, LocalDateTime, Instant en ZonedDateTime.

Duration vs Period: wat is het verschil?

Het belangrijkste verschil — Duration meet het exacte aantal seconden (time-based), terwijl Period kalendereenheden meet (date-based): jaren, maanden, dagen. Duration zegt: „er is 86400 seconden verstreken”. Period zegt: „er is 1 dag verstreken”. Het verschil wordt duidelijk bij de overgang naar zomertijd — 1 dag in Period is altijd gelijk aan 1 dag in de kalender, terwijl 86400 seconden in Duration kunnen overeenkomen met 23 of 25 uur bij DST.

Duration wordt gebruikt voor het meten van fysieke tijd: verbindingstime-outs, uitvoertijd van een verzoek, interval tussen twee Instant. Period wordt gebruikt voor kalenderberekeningen: leeftijd van een persoon (Period.between(geboortedatum, vandaag)), contractduur.

Duration werkt met seconden en nanoseconden, dus het kan worden verdeeld in delen (uren, minuten). Period werkt met jaren, maanden en dagen — ondeelbare kalendereenheden. Volgens Oracle Java Tutorial (2024), hangt de keuze tussen Duration en Period af van het type taak: exacte tijd versus kalenderdatums.

Duration maken

De meest voorkomende manier — Duration.between(Temporal start, Temporal end). Temporal kan Instant, LocalTime, LocalDateTime, ZonedDateTime zijn — elk type dat Temporal implementeert. De methode retourneert een Duration die het verschil start - end vertegenwoordigt (kan negatief zijn).

Statische fabrieksmethoden: Duration.ofSeconds(long), ofMinutes(long), ofHours(long), ofDays(long), ofMillis(long), ofNanos(long). Er is ook of(long amount, TemporalUnit unit) voor willekeurige eenheden — ChronoUnit.HOURS, ChronoUnit.MINUTES en andere.

De methode parse(CharSequence) accepteert een string in ISO-8601 formaat: „PT1H30M” (1 uur 30 minuten), „PT45S” (45 seconden), „P2DT3H” (2 dagen 3 uur). De string begint altijd met „PT” (Period of Time).

val betweenMoments = Duration.between(
    Instant.parse("2026-07-21T10:00:00Z"),
    Instant.parse("2026-07-21T14:30:00Z")
)

val fromMinutes = Duration.ofMinutes(90)
val fromHours = Duration.ofHours(2)
val parsed = Duration.parse("PT1H30M")

Rekenen met Duration

Duration ondersteunt een volledige set rekenkundige bewerkingen. De methoden plus(Duration) en minus(Duration) voegen een andere duur toe of trekken deze af. De methoden plusDays(), plusHours(), plusMinutes(), plusSeconds(), plusMillis(), plusNanos() — voor het precies toevoegen van eenheden.

Voor vermenigvuldiging en deling worden multipliedBy(long) en dividedBy(long) gebruikt. Duration.multipliedBy(2) verdubbelt de duur. Duration.dividedBy(3) deelt in drie delen met afronding naar beneden. De methode negated() keert het teken om — positief wordt negatief en vice versa.

De methode abs() retourneert een Duration met de absolute (positieve) waarde. isNegative() en isZero() — controles. toDays(), toHours(), toMinutes(), toSeconds(), toMillis(), toNanos() — conversie naar de overeenkomstige eenheden.

val oneHour = Duration.ofHours(1)
val twoHours = oneHour.plus(Duration.ofMinutes(60))
val halfHour = oneHour.dividedBy(2)

val minutes = twoHours.toMinutes()
val absDuration = (Duration.ofHours(-1)).abs()

Duration vergelijken

Duration implementeert de interface Comparable, wat natuurlijke vergelijking van duurtijden mogelijk maakt. De methode compareTo() retourneert een negatief getal, nul of een positief getal. De methoden isNegative() en isZero() — snelle controles. Voor expliciete vergelijking gebruikt u equals() — twee Duration zijn gelijk als ze dezelfde seconden en nanoseconden hebben.

Omdat Duration negatief kan zijn, werkt vergelijking „groter” of „kleiner” rekening houdend met het teken. -5 minuten is kleiner dan 2 minuten. De methode abs() is handig als u „absolute” lengtes moet vergelijken ongeacht de richting.

In Kotlin ondersteunt Duration vergelijkingsoperatoren via operator overloading: a < b, a > b, a <= b. Ook plus en minus zijn beschikbaar als operatoren: a + b, a - b.

val short = Duration.ofMinutes(5)
val long = Duration.ofMinutes(10)

if (short < long) {
    Log.d("Duration", "5 min is minder dan 10")
}

val negative = Duration.ofMinutes(-3)
Log.d("Duration", "Negatief: ${negative.isNegative()}")

Duration in echte Android-taken

Het eerste voorbeeld — het instellen van periodieke synchronisatie met de server. Duration wordt gebruikt om het interval tussen synchronisaties te berekenen en te controleren of de tijdslimiet zonder update is overschreden.

data class SyncConfig(
    val interval: Duration = Duration.ofMinutes(15),
    val retryDelay: Duration = Duration.ofSeconds(30)
)

fun calculateNextSync(
    lastSync: Instant,
    config: SyncConfig
): Duration {
    val elapsed = Duration.between(lastSync, Instant.now())
    return config.interval.minus(elapsed)
        .coerceAtLeast(Duration.ZERO)
}

Het tweede voorbeeld — het meten van de uitvoeringstijd van een operatie voor prestatielogging.

fun measureExecution(
    tag: String,
    block: () -> Unit
) {
    val start = Instant.now()
    block()
    val duration = Duration.between(start, Instant.now())
    Log.d(tag, "Uitgevoerd in ${duration.toMillis()} ms")
}

Het derde voorbeeld — het berekenen van de resterende tijd van een timer (bijvoorbeeld voor aftellen tot het einde van een actie).

class CountdownTimer(
    private val expiresAt: Instant
) {
    fun getRemainingTime(): Duration {
        val remaining = Duration.between(
            Instant.now(), expiresAt
        )
        return remaining.coerceAtLeast(Duration.ZERO)
    }

    fun isExpired(): Boolean = getRemainingTime() == Duration.ZERO
}

Duration omzetten naar string

De methode toString() retourneert Duration in ISO-8601 formaat: „PT1H30M” (1 uur 30 minuten), „PT45.5S” (45.5 seconden). Dit formaat is handig voor machine-uitwisseling, maar niet voor weergave aan de gebruiker.

Voor een menselijk leesbaar formaat gebruikt u toDays(), toHours(), toMinutes(), toSeconds() met handmatige samenstelling van de string. Bijvoorbeeld: „${days} d ${hours} u ${minutes} min”. Merk op dat toHours() het totale aantal uren retourneert, niet de uren binnen een dag.

Voor het opsplitsen van Duration in componenten wordt de formule gebruikt: val hours = duration.toHours(); val minutes = duration.toMinutes() % 60; val seconds = duration.seconds % 60. Volgens Apache Commons Lang (2024), biedt de bibliotheek DurationFormatUtils extra formatteringsmogelijkheden.

fun formatDuration(duration: Duration): String {
    val hours = duration.toHours()
    val minutes = duration.toMinutes() % 60
    val seconds = duration.seconds % 60

    return buildString {
        if (hours > 0) append("${hours} h ")
        if (minutes > 0) append("${minutes} min ")
        append("${seconds} sec")
    }
}

Veelvoorkomende fouten

De eerste fout — verwarring tussen Duration en Period bij het werken met datums. Duration meet seconden, dus Duration.ofDays(1) is altijd 24 uur (86400 seconden), ongeacht de overgang naar zomertijd. Als u een kalenderdag nodig heeft, gebruik dan Period.ofDays(1).

De tweede fout — verlies van nanoseconden bij conversie. Duration kan nanoseconden opslaan, maar toMillis() en toSeconds() gooien ze weg. Voor nauwkeurige berekeningen gebruikt u toNanos() of werkt u rechtstreeks met Duration, zonder conversie naar primitieve typen.

De derde fout — het negeren van negatieve Duration. Duration.between(start, end) retourneert start - end. Als start na end is, zal Duration negatief zijn. De methode abs() helpt bij het verkrijgen van de absolute waarde, en isNegative() om de volgorde van argumenten te controleren.

De vierde fout — onjuiste opmaak van Duration voor de UI. Duration.toString() retourneert ISO-8601, wat onleesbaar is. Formatteer Duration altijd handmatig voor weergave aan de gebruiker, met toHours(), toMinutes() en toSeconds() met de juiste rest van deling.