Duration — यह क्या है, Android में अवधि की गणना करना

Duration क्या है?

Duration एक क्लास है जो सेकंड और नैनोसेकंड में समय की मात्रा को मॉडल करता है। यह समय-आधारित अवधि दर्शाता है, अर्थात सेकंड की एक भौतिक संख्या जो कैलेंडर से बंधी नहीं है। Duration को “125 मिनट” या “2 घंटे 5 मिनट” के रूप में सोचा जा सकता है — Period के विपरीत, जो “2 महीने” कहेगा।

Duration का आंतरिक प्रतिनिधित्व दो फ़ील्ड से बना है: long seconds (सेकंड) और int nanos (नैनोसेकंड, 0 से 999999999)। मान नकारात्मक हो सकता है — इसका मतलब समय में “पीछे” की अवधि है। अधिकतम मान ±31557014167219200 सेकंड है।

Baeldung (2024) के अनुसार, Duration संचालन अवधि की गणना, टाइमआउट सेट करने और प्रदर्शन मापने के लिए एक महत्वपूर्ण क्लास है। Duration अपरिवर्तनीय और थ्रेड-सेफ है, जो इसे बिना सिंक्रनाइज़ेशन के मल्टीथ्रेडेड वातावरण में उपयोग करने की अनुमति देता है।

क्लास Comparable, TemporalAmount और TemporalUnit इंटरफ़ेस को लागू करता है। TemporalAmount Duration को LocalTime, LocalDateTime, Instant और ZonedDateTime क्लास के plus/minus विधियों में उपयोग करने की अनुमति देता है।

Duration बनाम Period: क्या अंतर है?

मुख्य अंतर यह है कि Duration सेकंड की सटीक संख्या मापता है (समय-आधारित), जबकि Period कैलेंडर इकाइयाँ मापता है (तिथि-आधारित): वर्ष, महीने, दिन। Duration कहता है: “86400 सेकंड बीत गए।” Period कहता है: “1 दिन बीत गया।” अंतर डेलाइट सेविंग टाइम परिवर्तनों के दौरान स्पष्ट होता है — Period में 1 दिन हमेशा 1 कैलेंडर दिन होता है, जबकि Duration में 86400 सेकंड DST के दौरान 23 या 25 घंटे के अनुरूप हो सकते हैं।

Duration भौतिक समय मापने के लिए उपयोग किया जाता है: कनेक्शन टाइमआउट, क्वेरी निष्पादन समय, दो Instant के बीच अंतराल। Period कैलेंडर गणनाओं के लिए उपयोग किया जाता है: व्यक्ति की आयु (Period.between(dateOfBirth, today)), अनुबंध अवधि।

Duration सेकंड और नैनोसेकंड के साथ काम करता है, इसलिए इसे भागों (घंटे, मिनट) में विभाजित किया जा सकता है। Period वर्षों, महीनों और दिनों के साथ काम करता है — अविभाज्य कैलेंडर इकाइयाँ। Oracle Java Tutorial (2024) के अनुसार, Duration और Period के बीच चुनाव कार्य के प्रकार पर निर्भर करता है: सटीक समय बनाम कैलेंडर तिथियाँ।

Duration बनाना

सबसे सामान्य तरीका Duration.between(Temporal start, Temporal end) है। Temporal Instant, LocalTime, LocalDateTime, ZonedDateTime — कोई भी प्रकार जो Temporal को लागू करता है। विधि start - end अंतर दर्शाने वाली Duration लौटाती है (नकारात्मक हो सकती है)।

स्थैतिक फैक्ट्री विधियाँ: Duration.ofSeconds(long), ofMinutes(long), ofHours(long), ofDays(long), ofMillis(long), ofNanos(long)। मनमानी इकाइयों के लिए of(long amount, TemporalUnit unit) भी है — ChronoUnit.HOURS, ChronoUnit.MINUTES और अन्य।

parse(CharSequence) विधि ISO-8601 प्रारूप में स्ट्रिंग स्वीकार करती है: “PT1H30M” (1 घंटा 30 मिनट), “PT45S” (45 सेकंड), “P2DT3H” (2 दिन 3 घंटे)। स्ट्रिंग हमेशा “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")

Duration के साथ अंकगणित

Duration अंकगणितीय संचालन का पूरा सेट समर्थन करता है। plus(Duration) और minus(Duration) विधियाँ दूसरी अवधि जोड़ती या घटाती हैं। plusDays(), plusHours(), plusMinutes(), plusSeconds(), plusMillis(), plusNanos() विधियाँ — विशिष्ट इकाइयाँ जोड़ने के लिए।

गुणा और भाग के लिए multipliedBy(long) और dividedBy(long) का उपयोग करें। Duration.multipliedBy(2) अवधि को दोगुना करता है। Duration.dividedBy(3) नीचे की ओर गोल करके तीन भागों में विभाजित करता है। negated() विधि चिह्न को उल्टा करती है — धनात्मक ऋणात्मक हो जाता है और इसके विपरीत।

abs() विधि निरपेक्ष (धनात्मक) मान के साथ Duration लौटाती है। isNegative() और isZero() जाँच हैं। toDays(), toHours(), toMinutes(), toSeconds(), toMillis(), toNanos() संबंधित इकाइयों में परिवर्तित करते हैं।

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 की तुलना

Duration Comparable इंटरफ़ेस को लागू करता है, जो अवधियों की प्राकृतिक रूप से तुलना करने की अनुमति देता है। compareTo() विधि ऋणात्मक संख्या, शून्य या धनात्मक संख्या लौटाती है। isNegative() और isZero() त्वरित जाँच हैं। स्पष्ट तुलना के लिए equals() का उपयोग करें — दो Duration बराबर हैं यदि उनके सेकंड और नैनोसेकंड मेल खाते हैं।

चूँकि Duration नकारात्मक हो सकता है, “से बड़ा” या “से छोटा” तुलनाएँ चिह्न को ध्यान में रखकर काम करती हैं। -5 मिनट 2 मिनट से छोटा है। abs() विधि दिशा से स्वतंत्र “निरपेक्ष” लंबाई की तुलना करने के लिए उपयोगी है।

Kotlin में, Duration ऑपरेटर ओवरलोडिंग के माध्यम से तुलना ऑपरेटरों का समर्थन करता है: a < b, a > b, a <= b। साथ ही plus और minus ऑपरेटरों के रूप में उपलब्ध हैं: a + b, a - b।

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

if (short < long) {
    Log.d("Duration", "5 मिनट 10 से कम है")
}

val negative = Duration.ofMinutes(-3)
Log.d("Duration", "नकारात्मक: ${negative.isNegative()}")

वास्तविक Android कार्यों में Duration

पहला उदाहरण सर्वर के साथ आवधिक सिंक्रनाइज़ेशन कॉन्फ़िगर करना है। Duration का उपयोग सिंक्रनाइज़ेशन के बीच अंतराल की गणना करने और जाँचने के लिए किया जाता है कि बिना अपडेट के समय सीमा पार हो गई है या नहीं।

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)
}

दूसरा उदाहरण प्रदर्शन लॉगिंग के लिए संचालन निष्पादन समय मापना है।

fun measureExecution(
    tag: String,
    block: () -> Unit
) {
    val start = Instant.now()
    block()
    val duration = Duration.between(start, Instant.now())
    Log.d(tag, "${duration.toMillis()} मिलीसेकंड में निष्पादित")
}

तीसरा उदाहरण टाइमर के शेष समय की गणना करना है (उदाहरण के लिए, प्रचार समाप्ति तक की उलटी गिनती)।

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 को स्ट्रिंग में बदलना

toString() विधि ISO-8601 प्रारूप में Duration लौटाती है: “PT1H30M” (1 घंटा 30 मिनट), “PT45.5S” (45.5 सेकंड)। यह प्रारूप मशीन आदान-प्रदान के लिए सुविधाजनक है लेकिन उपयोगकर्ता प्रदर्शन के लिए नहीं।

मानव-पठनीय प्रारूप के लिए, toDays(), toHours(), toMinutes(), toSeconds() का उपयोग करें और फिर मैन्युअल रूप से स्ट्रिंग बनाएँ। उदाहरण: “${days} दि ${hours} घं ${minutes} मि”। ध्यान दें कि toHours() कुल घंटों की संख्या लौटाता है, न कि दिन के भीतर के घंटे।

Duration को घटकों में तोड़ने के लिए सूत्र का उपयोग करें: val hours = duration.toHours(); val minutes = duration.toMinutes() % 60; val seconds = duration.seconds % 60। Apache Commons Lang (2024) के अनुसार, DurationFormatUtils लाइब्रेरी अतिरिक्त स्वरूपण क्षमताएँ प्रदान करती है।

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")
    }
}

सामान्य गलतियाँ

पहली गलती तिथियों के साथ काम करते समय Duration और Period को भ्रमित करना है। Duration सेकंड मापता है, इसलिए Duration.ofDays(1) हमेशा 24 घंटे (86400 सेकंड) होता है, डेलाइट सेविंग टाइम परिवर्तनों की परवाह किए बिना। यदि कैलेंडर दिन की आवश्यकता है, तो Period.ofDays(1) का उपयोग करें।

दूसरी गलती रूपांतरण के दौरान नैनोसेकंड खोना है। Duration नैनोसेकंड संग्रहीत कर सकता है, लेकिन toMillis() और toSeconds() उन्हें हटा देते हैं। सटीक गणनाओं के लिए toNanos() का उपयोग करें या प्रिमिटिव में रूपांतरित किए बिना सीधे Duration के साथ काम करें।

तीसरी गलती नकारात्मक Duration को अनदेखा करना है। Duration.between(start, end) start - end लौटाता है। यदि start end के बाद है, तो Duration नकारात्मक होगा। abs() विधि निरपेक्ष मान प्राप्त करने में मदद करती है, और isNegative() तर्क क्रम की जाँच करता है।

चौथी गलती UI के लिए गलत Duration स्वरूपण है। Duration.toString() ISO-8601 लौटाता है, जो पठनीय नहीं है। उपयोगकर्ता को प्रदर्शित करने के लिए हमेशा toHours(), toMinutes() और toSeconds() का उपयोग करके Duration को मैन्युअल रूप से प्रारूपित करें, विभाजन के सही शेषफल के साथ।