Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Kotlin

Android Date & Time Kotlin Samples

Android Kotlin date and time examples including getting current time, formatting dates, and parsing date strings

Samples

Entries inside this sample collection

CodekotlinSimple

Get Current Time

Get system current time in various formats and time zones

Difficulty

3/10

Estimated time

15 min

Tags

kotlin, android, datetime

Prerequisites

Basic Kotlin knowledge, Java Time API

kotlin
// Android Kotlin Get Current Time Examples
// Using java.time API (Android API 26+) and legacy Date API

import java.time.Instant
import java.time.LocalDateTime
import java.time.ZoneId
import java.time.ZonedDateTime
import java.time.Clock
import java.util.Date
import java.util.Calendar
import android.os.SystemClock

// 1. Current Time Using Modern API (API 26+)
class ModernTimeGetter {

    // Get current instant
    fun getCurrentInstant(): Instant {
        return Instant.now()
    }

    // Get current local date-time
    fun getCurrentLocalDateTime(): LocalDateTime {
        return LocalDateTime.now()
    }

    // Get current zoned date-time
    fun getCurrentZonedDateTime(zoneId: ZoneId = ZoneId.systemDefault()): ZonedDateTime {
        return ZonedDateTime.now(zoneId)
    }

    // Get current time in specific timezone
    fun getCurrentTimeInZone(zone: String): ZonedDateTime {
        val zoneId = ZoneId.of(zone)
        return ZonedDateTime.now(zoneId)
    }

    // Get current time from specific clock
    fun getCurrentTimeFromClock(clock: Clock): Instant {
        return Instant.now(clock)
    }

    // Get current timestamp (milliseconds since epoch)
    fun getCurrentTimestamp(): Long {
        return Instant.now().toEpochMilli()
    }

    // Get current unix timestamp (seconds since epoch)
    fun getCurrentUnixTimestamp(): Long {
        return Instant.now().epochSecond
    }
}

// 2. Current Time Using Legacy API
class LegacyTimeGetter {

    // Get current date
    fun getCurrentDate(): Date {
        return Date()
    }

    // Get current calendar
    fun getCurrentCalendar(): Calendar {
        return Calendar.getInstance()
    }

    // Get current timestamp
    fun getCurrentTimestamp(): Long {
        return System.currentTimeMillis()
    }

    // Get current time in specific timezone
    fun getCurrentTimeInTimezone(timezone: String): Calendar {
        return Calendar.getInstance(java.util.TimeZone.getTimeZone(timezone))
    }
}

// 3. System Time Measurements (Android)
class SystemTimeGetter {

    // Get elapsed realtime (since boot)
    fun getElapsedRealtime(): Long {
        return SystemClock.elapsedRealtime()
    }

    // Get elapsed realtime including deep sleep
    fun getElapsedRealtimeNanos(): Long {
        return SystemClock.elapsedRealtimeNanos()
    }

    // Get uptime (since boot, excluding deep sleep)
    fun getUptimeMillis(): Long {
        return SystemClock.uptimeMillis()
    }

    // Get current thread time
    fun getCurrentThreadTimeMillis(): Long {
        return SystemClock.currentThreadTimeMillis()
    }

    // Get current thread CPU time
    fun getCurrentThreadCpuTimeNano(): Long {
        return SystemClock.currentThreadCpuTimeNano()
    }
}

// 4. Time Components Extraction
class TimeComponentExtractor {

    // Extract components using modern API
    fun extractComponentsModern(localDateTime: LocalDateTime): TimeComponents {
        return TimeComponents(
            year = localDateTime.year,
            month = localDateTime.monthValue,
            day = localDateTime.dayOfMonth,
            hour = localDateTime.hour,
            minute = localDateTime.minute,
            second = localDateTime.second,
            nano = localDateTime.nano,
            dayOfWeek = localDateTime.dayOfWeek.value,
            dayOfYear = localDateTime.dayOfYear
        )
    }

    // Extract components using legacy API
    fun extractComponentsLegacy(calendar: Calendar): TimeComponents {
        return TimeComponents(
            year = calendar.get(Calendar.YEAR),
            month = calendar.get(Calendar.MONTH) + 1,
            day = calendar.get(Calendar.DAY_OF_MONTH),
            hour = calendar.get(Calendar.HOUR_OF_DAY),
            minute = calendar.get(Calendar.MINUTE),
            second = calendar.get(Calendar.SECOND),
            nano = calendar.get(Calendar.MILLISECOND) * 1_000_000,
            dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK),
            dayOfYear = calendar.get(Calendar.DAY_OF_YEAR)
        )
    }

    // Get time of day
    fun getTimeOfDay(localDateTime: LocalDateTime): String {
        val hour = localDateTime.hour
        return when (hour) {
            in 0..5 -> "Early Morning"
            in 6..11 -> "Morning"
            in 12..17 -> "Afternoon"
            in 18..21 -> "Evening"
            else -> "Night"
        }
    }
}

// Time Components Data Class
data class TimeComponents(
    val year: Int,
    val month: Int,
    val day: Int,
    val hour: Int,
    val minute: Int,
    val second: Int,
    val nano: Int,
    val dayOfWeek: Int,
    val dayOfYear: Int
) {
    fun print() {
        println("Date: $year-$month-$day")
        println("Time: $hour:$minute:$second")
        println("Day of week: $dayOfWeek")
        println("Day of year: $dayOfYear")
        println("Nanos: $nano")
    }
}

// 5. Time Zone Operations
class TimeZoneOperations {

    // Get current time in multiple timezones
    fun getCurrentTimeInZones(zones: List<String>): Map<String, ZonedDateTime> {
        val result = mutableMapOf<String, ZonedDateTime>()
        for (zone in zones) {
            val zoneId = ZoneId.of(zone)
            result[zone] = ZonedDateTime.now(zoneId)
        }
        return result
    }

    // Get available zone IDs
    fun getAvailableZoneIds(): Set<String> {
        return ZoneId.getAvailableZoneIds()
    }

    // Get system default timezone
    fun getSystemTimezone(): ZoneId {
        return ZoneId.systemDefault()
    }

    // Get offset from UTC
    fun getUTCOffset(zoneId: ZoneId = ZoneId.systemDefault()): String {
        val now = ZonedDateTime.now(zoneId)
        val offset = now.offset
        return offset.id
    }
}

// 6. Time Comparisons
class TimeComparer {

    // Compare two instants
    fun compareInstants(instant1: Instant, instant2: Instant): ComparisonResult {
        return when {
            instant1.isBefore(instant2) -> ComparisonResult.BEFORE
            instant1.isAfter(instant2) -> ComparisonResult.AFTER
            else -> ComparisonResult.EQUAL
        }
    }

    // Calculate duration between instants
    fun calculateDuration(instant1: Instant, instant2: Instant): DurationInfo {
        val duration = java.time.Duration.between(instant1, instant2)
        return DurationInfo(
            days = duration.toDays(),
            hours = duration.toHours(),
            minutes = duration.toMinutes(),
            seconds = duration.seconds,
            millis = duration.toMillis()
        )
    }

    // Check if time is within range
    fun isWithinRange(
                    instant: Instant,
                    start: Instant,
                    end: Instant
    ): Boolean {
        return !instant.isBefore(start) && !instant.isAfter(end)
    }
}

// Duration Info Data Class
data class DurationInfo(
    val days: Long,
    val hours: Long,
    val minutes: Long,
    val seconds: Long,
    val millis: Long
) {
    fun print() {
        println("Duration: ${days}d ${hours}h ${minutes}m ${seconds}s")
    }
}

// Comparison Result Enum
enum class ComparisonResult {
    BEFORE, EQUAL, AFTER
}

// Main demonstration
fun demonstrateGetCurrentTime() {
    println("=== Android Kotlin Get Current Time Examples ===\n")

    // 1. Modern API
    println("--- 1. Modern API (API 26+) ---")
    val modernGetter = ModernTimeGetter()

    val instant = modernGetter.getCurrentInstant()
    println("Current instant: $instant")

    val localDateTime = modernGetter.getCurrentLocalDateTime()
    println("Local date-time: $localDateTime")

    val zonedDateTime = modernGetter.getCurrentZonedDateTime()
    println("Zoned date-time: $zonedDateTime")

    val timestamp = modernGetter.getCurrentTimestamp()
    println("Timestamp (ms): $timestamp")

    val unixTimestamp = modernGetter.getCurrentUnixTimestamp()
    println("Unix timestamp: $unixTimestamp")

    // 2. Time in different zones
    println("\n--- 2. Time in Different Timezones ---")
    val timeInUTC = modernGetter.getCurrentTimeInZone("UTC")
    println("UTC: $timeInUTC")

    val timeInNY = modernGetter.getCurrentTimeInZone("America/New_York")
    println("New York: $timeInNY")

    val timeInTokyo = modernGetter.getCurrentTimeInZone("Asia/Tokyo")
    println("Tokyo: $timeInTokyo")

    val timeInLondon = modernGetter.getCurrentTimeInZone("Europe/London")
    println("London: $timeInLondon")

    // 3. Legacy API
    println("\n--- 3. Legacy API ---")
    val legacyGetter = LegacyTimeGetter()

    val date = legacyGetter.getCurrentDate()
    println("Current date: $date")

    val calendar = legacyGetter.getCurrentCalendar()
    println("Calendar time: ${calendar.time}")

    // 4. System time measurements
    println("\n--- 4. System Time Measurements ---")
    val systemGetter = SystemTimeGetter()

    println("Elapsed realtime: ${systemGetter.getElapsedRealtime()} ms")
    println("Uptime millis: ${systemGetter.getUptimeMillis()} ms")
    println("Current thread time: ${systemGetter.getCurrentThreadTimeMillis()} ms")

    // 5. Extract components
    println("\n--- 5. Extract Time Components ---")
    val extractor = TimeComponentExtractor()
    val components = extractor.extractComponentsModern(localDateTime)
    components.print()

    println("\nTime of day: ${extractor.getTimeOfDay(localDateTime)}")

    // 6. Multiple timezones
    println("\n--- 6. Multiple Timezones ---")
    val zoneOps = TimeZoneOperations()
    val zones = listOf("UTC", "America/Los_Angeles", "Europe/Paris", "Asia/Shanghai")
    val timesInZones = zoneOps.getCurrentTimeInZones(zones)

    timesInZones.forEach { (zone, time) ->
        println("$zone: $time")
    }

    println("\nSystem timezone: ${zoneOps.getSystemTimezone()}")
    println("UTC offset: ${zoneOps.getUTCOffset()}")

    // 7. Time comparison
    println("\n--- 7. Time Comparison ---")
    val comparer = TimeComparer()

    val now = Instant.now()
    val later = now.plusSeconds(3600)
    val earlier = now.minusSeconds(3600)

    println("Compare now vs later: ${comparer.compareInstants(now, later)}")
    println("Compare now vs earlier: ${comparer.compareInstants(now, earlier)}")

    val duration = comparer.calculateDuration(now, later)
    println("Duration between now and later:")
    duration.print()

    println("\n=== All Get Current Time Examples Completed ===")
}
CodekotlinIntermediate

Date & Time Formatting

Format date and time objects to strings using various patterns and locales

Difficulty

6/10

Estimated time

25 min

Tags

kotlin, android, datetime, formatting

Prerequisites

Intermediate Kotlin, Java Time API

kotlin
// Android Kotlin Date & Time Formatting Examples
// Using java.time.format (API 26+) and SimpleDateFormat

import java.time.LocalDateTime
import java.time.ZonedDateTime
import java.time.Instant
import java.time.ZoneId
import java.time.format.DateTimeFormatter
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
import java.util.Calendar

// 1. Basic Formatting Using Modern API
class ModernDateFormatter {

    // ISO format
    fun formatToISO(localDateTime: LocalDateTime): String {
        return localDateTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)
    }

    // Custom pattern
    fun formatWithPattern(localDateTime: LocalDateTime, pattern: String): String {
        val formatter = DateTimeFormatter.ofPattern(pattern)
        return localDateTime.format(formatter)
    }

    // Pre-defined common formats
    fun formatDateFull(localDateTime: LocalDateTime): String {
        return localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"))
    }

    fun formatTimeFull(localDateTime: LocalDateTime): String {
        return localDateTime.format(DateTimeFormatter.ofPattern("HH:mm:ss"))
    }

    fun formatDateTimeFull(localDateTime: LocalDateTime): String {
        return localDateTime.format(
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
        )
    }

    // Short format
    fun formatShort(localDateTime: LocalDateTime): String {
        return localDateTime.format(
            DateTimeFormatter.ofPattern("yy/MM/dd HH:mm")
        )
    }

    // With milliseconds
    fun formatWithMillis(localDateTime: LocalDateTime): String {
        return localDateTime.format(
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")
        )
    }

    // With nanoseconds
    fun formatWithNanos(localDateTime: LocalDateTime): String {
        return localDateTime.format(
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.nnnnnnnnn")
        )
    }
}

// 2. Localized Formatting
class LocalizedFormatter {

    // Format with locale
    fun formatDateLocalized(localDateTime: LocalDateTime, locale: Locale): String {
        val formatter = DateTimeFormatter.ofPattern(
            "yyyy MMMM dd, EEEE",
            locale
        )
        return localDateTime.format(formatter)
    }

    // Format in different locales
    fun formatDateInMultipleLocales(localDateTime: LocalDateTime):
            Map<String, String> {
        val locales = listOf(
            "en" to Locale.ENGLISH,
            "zh" to Locale.CHINESE,
            "es" to Locale("es"),
            "fr" to Locale.FRENCH,
            "de" to Locale.GERMAN,
            "ja" to Locale.JAPANESE,
            "ar" to Locale("ar")
        )

        return locales.mapValues { (_, locale) ->
            val formatter = DateTimeFormatter.ofPattern(
                "yyyy MMMM dd, EEEE HH:mm",
                locale
            )
            localDateTime.format(formatter)
        }
    }

    // Format using localized date style
    fun formatDateStyle(localDateTime: LocalDateTime, locale: Locale): String {
        val formatter = DateTimeFormatter
            .ofLocalizedDate(java.time.format.FormatStyle.FULL)
            .withLocale(locale)
        return localDateTime.format(formatter)
    }

    // Format using localized time style
    fun formatTimeStyle(localDateTime: LocalDateTime, locale: Locale): String {
        val formatter = DateTimeFormatter
            .ofLocalizedTime(java.time.format.FormatStyle.SHORT)
            .withLocale(locale)
        return localDateTime.format(formatter)
    }

    // Format using localized date-time style
    fun formatDateTimeStyle(
                    localDateTime: LocalDateTime,
                    locale: Locale,
                    style: java.time.format.FormatStyle
    ): String {
        val formatter = DateTimeFormatter
            .ofLocalizedDateTime(style)
            .withLocale(locale)
        return localDateTime.format(formatter)
    }
}

// 3. Formatting ZonedDateTime
class ZonedFormatter {

    // Format with timezone
    fun formatWithZone(zonedDateTime: ZonedDateTime): String {
        val formatter = DateTimeFormatter.ofPattern(
            "yyyy-MM-dd HH:mm:ss Z"
        )
        return zonedDateTime.format(formatter)
    }

    // Format with timezone name
    fun formatWithZoneName(zonedDateTime: ZonedDateTime): String {
        val formatter = DateTimeFormatter.ofPattern(
            "yyyy-MM-dd HH:mm:ss zzz"
        )
        return zonedDateTime.format(formatter)
    }

    // Format ISO with zone
    fun formatISOWithZone(zonedDateTime: ZonedDateTime): String {
        return zonedDateTime.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)
    }

    // Convert to different timezone and format
    fun formatInZone(
                    instant: Instant,
                    zoneId: ZoneId,
                    pattern: String
    ): String {
        val zoned = instant.atZone(zoneId)
        val formatter = DateTimeFormatter.ofPattern(pattern)
        return zoned.format(formatter)
    }
}

// 4. Legacy Formatting (SimpleDateFormat)
class LegacyDateFormatter {

    // Simple date format
    fun formatSimple(date: Date, pattern: String): String {
        val formatter = SimpleDateFormat(pattern)
        return formatter.format(date)
    }

    // Format with locale
    fun formatWithLocale(date: Date, pattern: String, locale: Locale): String {
        val formatter = SimpleDateFormat(pattern, locale)
        return formatter.format(date)
    }

    // Common date formats
    fun formatISO(date: Date): String {
        return SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").format(date)
    }

    fun formatReadable(date: Date): String {
        return SimpleDateFormat("MMMM dd, yyyy 'at' HH:mm").format(date)
    }

    fun formatShort(date: Date): String {
        return SimpleDateFormat("yy/MM/dd").format(date)
    }

    fun formatLong(date: Date): String {
        return SimpleDateFormat(
            "EEEE, MMMM dd, yyyy 'at' hh:mm a"
        ).format(date)
    }
}

// 5. Special Format Patterns
class SpecialFormatter {

    // Relative time (e.g., "2 hours ago")
    fun formatRelative(dateTime: LocalDateTime): String {
        val now = LocalDateTime.now()
        val duration = java.time.Duration.between(dateTime, now)

        val hours = duration.toHours()
        val minutes = duration.toMinutes()

        return when {
            minutes < 1 -> "just now"
            minutes < 60 -> "$minutes minutes ago"
            hours < 24 -> "$hours hours ago"
            hours < 48 -> "yesterday"
            else -> "${daysBetween(dateTime, now)} days ago"
        }
    }

    private fun daysBetween(start: LocalDateTime, end: LocalDateTime): Long {
        return java.time.Duration.between(start, end).toDays()
    }

    // Format duration
    fun formatDuration(duration: java.time.Duration): String {
        val days = duration.toDays()
        val hours = duration.toHours() % 24
        val minutes = duration.toMinutes() % 60
        val seconds = duration.seconds % 60

        return when {
            days > 0 -> "${days}d ${hours}h ${minutes}m ${seconds}s"
            hours > 0 -> "${hours}h ${minutes}m ${seconds}s"
            minutes > 0 -> "${minutes}m ${seconds}s"
            else -> "${seconds}s"
        }
    }

    // Format as timestamp
    fun formatAsTimestamp(localDateTime: LocalDateTime): String {
        return localDateTime.atZone(ZoneId.systemDefault())
            .toInstant()
            .toEpochMilli()
            .toString()
    }

    // Format with ordinal indicator
    fun formatWithOrdinal(localDateTime: LocalDateTime): String {
        val day = localDateTime.dayOfMonth
        val ordinal = when (day) {
            1, 21, 31 -> "st"
            2, 22 -> "nd"
            3, 23 -> "rd"
            else -> "th"
        }

        val formatter = DateTimeFormatter.ofPattern("MMMM")
        val month = localDateTime.format(formatter)

        return "$month $day$ordinal, ${localDateTime.year}"
    }
}

// 6. Custom Business Formats
class BusinessFormatter {

    // Format for logs
    fun formatForLog(localDateTime: LocalDateTime): String {
        return localDateTime.format(
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")
        )
    }

    // Format for filenames
    fun formatForFileName(localDateTime: LocalDateTime): String {
        return localDateTime.format(
            DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss")
        )
    }

    // Format for reports
    fun formatForReport(localDateTime: LocalDateTime): String {
        return localDateTime.format(
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")
        )
    }

    // Format for display
    fun formatForDisplay(localDateTime: LocalDateTime): String {
        return localDateTime.format(
            DateTimeFormatter.ofPattern("MMM dd, yyyy")
        )
    }

    // Format for invoices
    fun formatForInvoice(localDateTime: LocalDateTime): String {
        return localDateTime.format(
            DateTimeFormatter.ofPattern("yyyyMMdd")
        )
    }

    // Format week number
    fun formatWeek(localDateTime: LocalDateTime): String {
        val weekOfYear = localDateTime.get(
            java.time.temporal.WeekFields.ISO.weekOfYear()
        )
        return "${localDateTime.year}-W${weekOfYear}"
    }

    // Format quarter
    fun formatQuarter(localDateTime: LocalDateTime): String {
        val quarter = (localDateTime.monthValue - 1) / 3 + 1
        return "${localDateTime.year}-Q$quarter"
    }
}

// Main demonstration
fun demonstrateDateTimeFormatting() {
    println("=== Android Kotlin Date & Time Formatting Examples ===\n")

    val now = LocalDateTime.now()
    val zonedNow = ZonedDateTime.now()
    val date = Date()

    // 1. Basic modern formatting
    println("--- 1. Basic Modern Formatting ---")
    val modernFormatter = ModernDateFormatter()

    println("ISO format: ${modernFormatter.formatToISO(now)}")
    println("Date only: ${modernFormatter.formatDateFull(now)}")
    println("Time only: ${modernFormatter.formatTimeFull(now)}")
    println("Date-time: ${modernFormatter.formatDateTimeFull(now)}")
    println("Short: ${modernFormatter.formatShort(now)}")
    println("With millis: ${modernFormatter.formatWithMillis(now)}")

    // 2. Custom patterns
    println("\n--- 2. Custom Patterns ---")
    println("Custom 1: ${modernFormatter.formatWithPattern(now, "dd/MM/yyyy")}")
    println("Custom 2: ${modernFormatter.formatWithPattern(now, "MM-dd-yyyy HH:mm")}")
    println("Custom 3: ${modernFormatter.formatWithPattern(now, "EEEE, MMMM d, yyyy")}")

    // 3. Localized formatting
    println("\n--- 3. Localized Formatting ---")
    val localizedFormatter = LocalizedFormatter()
    val formattedLocales = localizedFormatter.formatDateInMultipleLocales(now)

    println("Date in different locales:")
    formattedLocales.forEach { (lang, dateStr) ->
        println("  $lang: $dateStr")
    }

    println("\nLocalized date style (English):")
    println("  ${localizedFormatter.formatDateStyle(now, Locale.ENGLISH)}")

    println("\nLocalized time style (English):")
    println("  ${localizedFormatter.formatTimeStyle(now, Locale.ENGLISH)}")

    // 4. Zoned formatting
    println("\n--- 4. Zoned Date-Time Formatting ---")
    val zonedFormatter = ZonedFormatter()

    println("With zone: ${zonedFormatter.formatWithZone(zonedNow)}")
    println("With zone name: ${zonedFormatter.formatWithZoneName(zonedNow)}")
    println("ISO with zone: ${zonedFormatter.formatISOWithZone(zonedNow)}")

    val instant = Instant.now()
    println("\nUTC time: ${zonedFormatter.formatInZone(instant, ZoneId.of("UTC"), "yyyy-MM-dd HH:mm:ss")}")
    println("NY time: ${zonedFormatter.formatInZone(instant, ZoneId.of("America/New_York"), "yyyy-MM-dd HH:mm:ss")}")

    // 5. Legacy formatting
    println("\n--- 5. Legacy Formatting ---")
    val legacyFormatter = LegacyDateFormatter()

    println("Simple: ${legacyFormatter.formatSimple(date, "yyyy-MM-dd")}")
    println("ISO: ${legacyFormatter.formatISO(date)}")
    println("Readable: ${legacyFormatter.formatReadable(date)}")
    println("Long: ${legacyFormatter.formatLong(date)}")

    // 6. Special formats
    println("\n--- 6. Special Formats ---")
    val specialFormatter = SpecialFormatter()

    val past = now.minusHours(2)
    println("Relative time: ${specialFormatter.formatRelative(past)}")

    val duration = java.time.Duration.ofHours(2).plusMinutes(30)
    println("Duration: ${specialFormatter.formatDuration(duration)}")

    println("With ordinal: ${specialFormatter.formatWithOrdinal(now)}")
    println("Timestamp: ${specialFormatter.formatAsTimestamp(now)}")

    // 7. Business formats
    println("\n--- 7. Business Formats ---")
    val businessFormatter = BusinessFormatter()

    println("Log format: ${businessFormatter.formatForLog(now)}")
    println("Filename format: ${businessFormatter.formatForFileName(now)}")
    println("Report format: ${businessFormatter.formatForReport(now)}")
    println("Display format: ${businessFormatter.formatForDisplay(now)}")
    println("Invoice format: ${businessFormatter.formatForInvoice(now)}")
    println("Week format: ${businessFormatter.formatWeek(now)}")
    println("Quarter format: ${businessFormatter.formatQuarter(now)}")

    println("\n=== All Date & Time Formatting Examples Completed ===")
}
CodekotlinIntermediate

Date & Time Parsing

Parse date and time strings from various formats into date objects

Difficulty

7/10

Estimated time

25 min

Tags

kotlin, android, datetime, parsing

Prerequisites

Intermediate Kotlin, Java Time API

kotlin
// Android Kotlin Date & Time Parsing Examples
// Using java.time.format (API 26+) and SimpleDateFormat

import java.time.LocalDateTime
import java.time.ZonedDateTime
import java.time.Instant
import java.time.LocalDate
import java.time.LocalTime
import java.time.ZoneId
import java.time.format.DateTimeFormatter
import java.time.format.DateTimeParseException
import java.text.SimpleDateFormat
import java.text.ParseException
import java.util.Date
import java.util.Locale

// 1. Basic Parsing Using Modern API
class ModernDateParser {

    // Parse ISO format
    fun parseISO(dateString: String): LocalDateTime? {
        return try {
            LocalDateTime.parse(dateString, DateTimeFormatter.ISO_LOCAL_DATE_TIME)
        } catch (e: DateTimeParseException) {
            println("Error parsing ISO date: ${e.message}")
            null
        }
    }

    // Parse with custom pattern
    fun parseWithPattern(dateString: String, pattern: String): LocalDateTime? {
        return try {
            val formatter = DateTimeFormatter.ofPattern(pattern)
            LocalDateTime.parse(dateString, formatter)
        } catch (e: DateTimeParseException) {
            println("Error parsing date: ${e.message}")
            null
        }
    }

    // Parse date only
    fun parseDate(dateString: String): LocalDate? {
        return try {
            LocalDate.parse(dateString)
        } catch (e: DateTimeParseException) {
            println("Error parsing date: ${e.message}")
            null
        }
    }

    // Parse time only
    fun parseTime(timeString: String): LocalTime? {
        return try {
            LocalTime.parse(timeString)
        } catch (e: DateTimeParseException) {
            println("Error parsing time: ${e.message}")
            null
        }
    }

    // Parse zoned date-time
    fun parseZoned(dateString: String): ZonedDateTime? {
        return try {
            ZonedDateTime.parse(dateString, DateTimeFormatter.ISO_ZONED_DATE_TIME)
        } catch (e: DateTimeParseException) {
            println("Error parsing zoned date: ${e.message}")
            null
        }
    }

    // Parse with multiple patterns
    fun parseWithPatterns(dateString: String, patterns: List<String>): LocalDateTime? {
        for (pattern in patterns) {
            try {
                val formatter = DateTimeFormatter.ofPattern(pattern)
                return LocalDateTime.parse(dateString, formatter)
            } catch (e: DateTimeParseException) {
                // Try next pattern
            }
        }
        println("Could not parse date with any pattern")
        return null
    }
}

// 2. Localized Parsing
class LocalizedParser {

    // Parse with locale
    fun parseWithLocale(dateString: String, pattern: String, locale: Locale): LocalDateTime? {
        return try {
            val formatter = DateTimeFormatter.ofPattern(pattern, locale)
            LocalDateTime.parse(dateString, formatter)
        } catch (e: DateTimeParseException) {
            println("Error parsing localized date: ${e.message}")
            null
        }
    }

    // Parse from different locales
    fun parseFromMultipleLocales(
                    dateString: String,
                    pattern: String
    ): Map<String, LocalDateTime?> {
        val locales = listOf(
            "en" to Locale.ENGLISH,
            "zh" to Locale.CHINESE,
            "es" to Locale("es"),
            "fr" to Locale.FRENCH,
            "de" to Locale.GERMAN
        )

        return locales.mapValues { (_, locale) ->
            try {
                val formatter = DateTimeFormatter.ofPattern(pattern, locale)
                LocalDateTime.parse(dateString, formatter)
            } catch (e: DateTimeParseException) {
                null
            }
        }
    }
}

// 3. Legacy Parsing (SimpleDateFormat)
class LegacyDateParser {

    // Simple parse
    fun parseSimple(dateString: String, pattern: String): Date? {
        return try {
            val formatter = SimpleDateFormat(pattern)
            formatter.parse(dateString)
        } catch (e: ParseException) {
            println("Error parsing date: ${e.message}")
            null
        }
    }

    // Parse with locale
    fun parseWithLocale(dateString: String, pattern: String, locale: Locale): Date? {
        return try {
            val formatter = SimpleDateFormat(pattern, locale)
            formatter.parse(dateString)
        } catch (e: ParseException) {
            println("Error parsing localized date: ${e.message}")
            null
        }
    }

    // Lenient parsing
    fun parseLenient(dateString: String, pattern: String): Date? {
        return try {
            val formatter = SimpleDateFormat(pattern)
            formatter.isLenient = false
            formatter.parse(dateString)
        } catch (e: ParseException) {
            println("Error parsing date (strict): ${e.message}")
            null
        }
    }

    // Parse to Calendar
    fun parseToCalendar(dateString: String, pattern: String): Calendar? {
        return try {
            val formatter = SimpleDateFormat(pattern)
            val date = formatter.parse(dateString)
            val calendar = Calendar.getInstance()
            calendar.time = date
            calendar
        } catch (e: ParseException) {
            println("Error parsing to calendar: ${e.message}")
            null
        }
    }
}

// 4. Parsing Special Formats
class SpecialFormatParser {

    // Parse Unix timestamp
    fun parseUnixTimestamp(timestamp: Long): LocalDateTime {
        return LocalDateTime.ofInstant(
            Instant.ofEpochSecond(timestamp),
            ZoneId.systemDefault()
        )
    }

    // Parse timestamp in milliseconds
    fun parseTimestampMillis(millis: Long): LocalDateTime {
        return LocalDateTime.ofInstant(
            Instant.ofEpochMilli(millis),
            ZoneId.systemDefault()
        )
    }

    // Parse Excel date serial
    fun parseExcelSerial(serial: Double): LocalDateTime {
        // Excel epoch is 1900-01-01, but with a bug (1900 is a leap year)
        val days = (serial - 25569).toLong() // Adjust to Unix epoch
        val seconds = days * 86400
        return LocalDateTime.ofInstant(
            Instant.ofEpochSecond(seconds),
            ZoneId.systemDefault()
        )
    }

    // Parse ISO 8601 with zone
    fun parseISO8601WithZone(dateString: String): ZonedDateTime? {
        return try {
            ZonedDateTime.parse(dateString)
        } catch (e: DateTimeParseException) {
            println("Error parsing ISO 8601: ${e.message}")
            null
        }
    }

    // Parse RFC 2822 date
    fun parseRFC2822(dateString: String): LocalDateTime? {
        val pattern = "EEE, dd MMM yyyy HH:mm:ss Z"
        return try {
            val formatter = DateTimeFormatter.ofPattern(pattern, Locale.ENGLISH)
            LocalDateTime.parse(dateString, formatter)
        } catch (e: DateTimeParseException) {
            println("Error parsing RFC 2822: ${e.message}")
            null
        }
    }

    // Parse relative date
    fun parseRelativeDate(relative: String): LocalDateTime? {
        val now = LocalDateTime.now()
        val pattern = Regex("([+-]?\\d+)\\s+(day|hour|minute|second)s?")

        return pattern.find(relative)?.let { match ->
            val amount = match.groupValues[1].toInt()
            val unit = match.groupValues[2]

            when (unit) {
                "day" -> now.plusDays(amount.toLong())
                "hour" -> now.plusHours(amount.toLong())
                "minute" -> now.plusMinutes(amount.toLong())
                "second" -> now.plusSeconds(amount.toLong())
                else -> null
            }
        }
    }
}

// 5. Flexible Parsing
class FlexibleParser {

    // Try multiple date formats
    fun parseAutoDetect(dateString: String): LocalDateTime? {
        val formats = listOf(
            "yyyy-MM-dd HH:mm:ss",
            "yyyy-MM-dd",
            "MM/dd/yyyy",
            "dd-MM-yyyy",
            "yyyy/MM/dd HH:mm",
            "MMM dd, yyyy",
            "dd MMM yyyy",
            "yyyy-MM-dd'T'HH:mm:ss",
            "ISO_OFFSET_DATE_TIME"
        )

        for (format in formats) {
            try {
                return when (format) {
                    "ISO_OFFSET_DATE_TIME" -> {
                        val zoned = ZonedDateTime.parse(dateString)
                        zoned.toLocalDateTime()
                    }
                    else -> {
                        val formatter = DateTimeFormatter.ofPattern(format)
                        LocalDateTime.parse(dateString, formatter)
                    }
                }
            } catch (e: Exception) {
                // Try next format
            }
        }

        println("Could not auto-detect format")
        return null
    }

    // Parse with fallback
    fun parseWithFallback(
                    dateString: String,
                    primaryPattern: String,
                    fallbackPattern: String
    ): LocalDateTime? {
        return parseWithPattern(dateString, primaryPattern)
            ?: parseWithPattern(dateString, fallbackPattern)
    }

    private fun parseWithPattern(dateString: String, pattern: String): LocalDateTime? {
        return try {
            val formatter = DateTimeFormatter.ofPattern(pattern)
            LocalDateTime.parse(dateString, formatter)
        } catch (e: DateTimeParseException) {
            null
        }
    }

    // Parse with normalization
    fun parseWithNormalization(dateString: String): LocalDateTime? {
        // Normalize: remove extra spaces, standardize separators
        val normalized = dateString
            .trim()
            .replace(Regex("\\s+"), " ")
            .replace("/", "-")
            .replace(".", "-")

        return parseAutoDetect(normalized)
    }
}

// 6. Validation and Sanitization
class DateInputValidator {

    // Validate date format
    fun isValidFormat(dateString: String, pattern: String): Boolean {
        return try {
            val formatter = DateTimeFormatter.ofPattern(pattern)
            LocalDateTime.parse(dateString, formatter)
            true
        } catch (e: DateTimeParseException) {
            false
        }
    }

    // Validate and parse
    fun validateAndParse(dateString: String, pattern: String): LocalDateTime? {
        return if (isValidFormat(dateString, pattern)) {
            parseWithPattern(dateString, pattern)
        } else {
            null
        }
    }

    private fun parseWithPattern(dateString: String, pattern: String): LocalDateTime? {
        return try {
            val formatter = DateTimeFormatter.ofPattern(pattern)
            LocalDateTime.parse(dateString, formatter)
        } catch (e: DateTimeParseException) {
            null
        }
    }

    // Sanitize date input
    fun sanitizeDateInput(dateString: String): String {
        return dateString
            .trim()
            .replace(Regex("\\s+"), " ")
            .replace(Regex("[^\\d\\w\\s:-]"), "")
    }

    // Check if date is reasonable
    fun isReasonableDate(localDateTime: LocalDateTime): Boolean {
        val now = LocalDateTime.now()
        val year = localDateTime.year

        return year in 1900..2100 &&
               !localDateTime.isAfter(now.plusYears(10))
    }
}

// Main demonstration
fun demonstrateDateTimeParsing() {
    println("=== Android Kotlin Date & Time Parsing Examples ===\n")

    val parser = ModernDateParser()

    // 1. Basic parsing
    println("--- 1. Basic Parsing ---")
    val isoDate = "2025-12-27T10:30:00"
    val parsed1 = parser.parseISO(isoDate)
    println("Parse ISO: $isoDate")
    println("Result: $parsed1")

    val customDate = "2025-12-27 14:30:45"
    val parsed2 = parser.parseWithPattern(customDate, "yyyy-MM-dd HH:mm:ss")
    println("\nParse custom: $customDate")
    println("Result: $parsed2")

    val dateOnly = "2025-12-27"
    val parsed3 = parser.parseDate(dateOnly)
    println("\nParse date only: $dateOnly")
    println("Result: $parsed3")

    // 2. Multiple patterns
    println("\n--- 2. Try Multiple Patterns ---")
    val ambiguousDate = "12/27/2025"
    val patterns = listOf("MM/dd/yyyy", "dd/MM/yyyy", "yyyy/MM/dd")
    val parsed4 = parser.parseWithPatterns(ambiguousDate, patterns)
    println("Parse '$ambiguousDate' with patterns:")
    patterns.forEach { println("  - $it") }
    println("Result: $parsed4")

    // 3. Localized parsing
    println("\n--- 3. Localized Parsing ---")
    val localizedParser = LocalizedParser()
    val englishDate = "December 27, 2025"
    val parsed5 = localizedParser.parseWithLocale(englishDate, "MMMM dd, yyyy", Locale.ENGLISH)
    println("English date: $englishDate")
    println("Parsed: $parsed5")

    // 4. Special formats
    println("\n--- 4. Special Formats ---")
    val specialParser = SpecialFormatParser()

    val timestamp = 1735300200L
    val parsed6 = specialParser.parseUnixTimestamp(timestamp)
    println("Unix timestamp: $timestamp")
    println("Result: $parsed6")

    val millis = 1735300200000L
    val parsed7 = specialParser.parseTimestampMillis(millis)
    println("\nMillis: $millis")
    println("Result: $parsed7")

    val isoZoned = "2025-12-27T10:30:00+02:00"
    val parsed8 = specialParser.parseISO8601WithZone(isoZoned)
    println("\nISO 8601 with zone: $isoZoned")
    println("Result: $parsed8")

    // 5. Flexible parsing
    println("\n--- 5. Flexible Parsing ---")
    val flexibleParser = FlexibleParser()

    val unknownFormat = "2025/12/27 10:30"
    val parsed9 = flexibleParser.parseAutoDetect(unknownFormat)
    println("Auto-detect format: $unknownFormat")
    println("Result: $parsed9")

    val normalized = " 2025 - 12 - 27  "
    val parsed10 = flexibleParser.parseWithNormalization(normalized)
    println("\nNormalize and parse: '$normalized'")
    println("Result: $parsed10")

    // 6. Validation
    println("\n--- 6. Validation ---")
    val validator = DateInputValidator()

    val validDate = "2025-12-27"
    val invalidDate = "2025-13-45"

    println("'$validDate' valid format: ${validator.isValidFormat(validDate, "yyyy-MM-dd")}")
    println("'$invalidDate' valid format: ${validator.isValidFormat(invalidDate, "yyyy-MM-dd")}")

    val parsed11 = validator.validateAndParse(validDate, "yyyy-MM-dd")
    println("\nValidate and parse: $parsed11")

    val reasonable = LocalDateTime.of(2025, 12, 27, 10, 30)
    println("\nIs reasonable: ${validator.isReasonableDate(reasonable)}")

    // 7. Legacy parsing
    println("\n--- 7. Legacy Parsing ---")
    val legacyParser = LegacyDateParser()

    val legacyDate = "27/12/2025 10:30"
    val parsed12 = legacyParser.parseSimple(legacyDate, "dd/MM/yyyy HH:mm")
    println("Legacy parse: $legacyDate")
    println("Result: $parsed12")

    println("\n=== All Date & Time Parsing Examples Completed ===")
}

Tools

Tools frequently paired with this sample

Related

Related sample collections

Related

Related workflows

Hub

Date and Time Normalization and Deadline Calculation

Turn ambiguous or mixed-format date inputs into validated, timezone-aware, business-ready timestamps, deadlines, and duration facts.

Hub

Text Encoding, Width, Date, and Currency Conversion Workflow

Prepare imported or copied text for reuse by recovering its encoding, choosing a character-width convention, standardizing inline dates or currency, and selecting a final text representation.

Hub

Infer JSON Schema from Samples and Spreadsheets

Derive a reviewable JSON Schema draft from representative JSON samples or XLSX rows, then inspect types, requiredness, nulls, and outliers before treating it as a contract.

Hub

Astronomical Coordinate, Time, and Orbit Workflows

Convert celestial coordinates, lock the observation time scale, and solve orbital or sky-position questions with explicit precision limits.

Home
Tools3212
Samples593
Visualizations471
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact

Validation

Date & Time Validator

Validate date and time formats including ISO8601, custom formats, leap year, and month/day validation

Text Processing

Date Extractor (日期提取器)

Extract dates from text in multiple formats including Chinese, ISO, and US formats with detailed analysis and summary

Format Conversion

Date Formatter

Convert date strings to various formatted date formats

Utilities

Text Date Format Unifier

Find and unify date formats within text content

Date & Time

Time Duration Formatter

Format time duration into various human-readable formats

Utilities

Date Format Unifier

Convert various date formats to a unified format

Date & Time

Time Adder/Subtractor

Add or subtract time from a date

Utilities

Date Adder

Add or subtract time periods from a date (years, months, days, hours, minutes, seconds)

Java

Android Date & Time Java Samples

Android Java date and time examples including getting current time, formatting dates, and parsing date strings

Swift

macOS Date & Time Swift Samples

macOS Swift date and time examples including getting current time, formatting, and parsing dates

Go

Web Date & Time Go Samples

Web Go date and time examples including getting current time, formatting, parsing, and timezone operations

Python

Web Date & Time Python Samples

Web Python date and time examples including getting current time, formatting, parsing, and timezone operations

TypeScript

Web Date Time TypeScript Samples

Web TypeScript date and time examples including getting current time, formatting, parsing, and manipulation

C++

Windows Date and Time - C++ Samples

Comprehensive C++ date and time examples for Windows platform including time acquisition, formatting, and parsing operations