Exemples de Date et Heure Android Java

// Android Java 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+)
public class ModernTimeGetter {

    // Get current instant
    public Instant getCurrentInstant() {
        return Instant.now();
    }

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

    // Get current zoned date-time
    public ZonedDateTime getCurrentZonedDateTime() {
        return ZonedDateTime.now();
    }

    // Get current zoned date-time with specific zone
    public ZonedDateTime getCurrentZonedDateTime(ZoneId zoneId) {
        return ZonedDateTime.now(zoneId);
    }

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

    // Get current timestamp (milliseconds since epoch)
    public long getCurrentTimestamp() {
        return Instant.now().toEpochMilli();
    }

    // Get current unix timestamp (seconds since epoch)
    public long getCurrentUnixTimestamp() {
        return Instant.now().getEpochSecond();
    }
}

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

    // Get current date
    public Date getCurrentDate() {
        return new Date();
    }

    // Get current calendar
    public Calendar getCurrentCalendar() {
        return Calendar.getInstance();
    }

    // Get current timestamp
    public long getCurrentTimestamp() {
        return System.currentTimeMillis();
    }

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

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

    // Get elapsed realtime (since boot)
    public long getElapsedRealtime() {
        return SystemClock.elapsedRealtime();
    }

    // Get elapsed realtime including deep sleep
    public long getElapsedRealtimeNanos() {
        return SystemClock.elapsedRealtimeNanos();
    }

    // Get uptime (since boot, excluding deep sleep)
    public long getUptimeMillis() {
        return SystemClock.uptimeMillis();
    }

    // Get current thread time
    public long getCurrentThreadTimeMillis() {
        return SystemClock.currentThreadTimeMillis();
    }

    // Get current thread CPU time
    public long getCurrentThreadCpuTimeNano() {
        return SystemClock.currentThreadCpuTimeNano();
    }
}

// 4. Time Components Extraction
public class TimeComponentExtractor {

    public static class TimeComponents {
        public int year;
        public int month;
        public int day;
        public int hour;
        public int minute;
        public int second;
        public int nano;
        public int dayOfWeek;
        public int dayOfYear;

        public TimeComponents(int year, int month, int day, int hour, int minute,
                            int second, int nano, int dayOfWeek, int dayOfYear) {
            this.year = year;
            this.month = month;
            this.day = day;
            this.hour = hour;
            this.minute = minute;
            this.second = second;
            this.nano = nano;
            this.dayOfWeek = dayOfWeek;
            this.dayOfYear = dayOfYear;
        }

        public void print() {
            System.out.println("Date: " + year + "-" + month + "-" + day);
            System.out.println("Time: " + hour + ":" + minute + ":" + second);
            System.out.println("Day of week: " + dayOfWeek);
            System.out.println("Day of year: " + dayOfYear);
            System.out.println("Nanos: " + nano);
        }
    }

    // Extract components using modern API
    public TimeComponents extractComponentsModern(LocalDateTime localDateTime) {
        return new TimeComponents(
            localDateTime.getYear(),
            localDateTime.getMonthValue(),
            localDateTime.getDayOfMonth(),
            localDateTime.getHour(),
            localDateTime.getMinute(),
            localDateTime.getSecond(),
            localDateTime.getNano(),
            localDateTime.getDayOfWeek().getValue(),
            localDateTime.getDayOfYear()
        );
    }

    // Extract components using legacy API
    public TimeComponents extractComponentsLegacy(Calendar calendar) {
        return new TimeComponents(
            calendar.get(Calendar.YEAR),
            calendar.get(Calendar.MONTH) + 1,
            calendar.get(Calendar.DAY_OF_MONTH),
            calendar.get(Calendar.HOUR_OF_DAY),
            calendar.get(Calendar.MINUTE),
            calendar.get(Calendar.SECOND),
            calendar.get(Calendar.MILLISECOND) * 1_000_000,
            calendar.get(Calendar.DAY_OF_WEEK),
            calendar.get(Calendar.DAY_OF_YEAR)
        );
    }

    // Get time of day
    public String getTimeOfDay(LocalDateTime localDateTime) {
        int hour = localDateTime.getHour();
        if (hour >= 0 && hour <= 5) {
            return "Early Morning";
        } else if (hour >= 6 && hour <= 11) {
            return "Morning";
        } else if (hour >= 12 && hour <= 17) {
            return "Afternoon";
        } else if (hour >= 18 && hour <= 21) {
            return "Evening";
        } else {
            return "Night";
        }
    }
}

// 5. Time Zone Operations
public class TimeZoneOperations {

    // Get current time in multiple timezones
    public java.util.Map<String, ZonedDateTime> getCurrentTimeInZones(java.util.List<String> zones) {
        java.util.Map<String, ZonedDateTime> result = new java.util.HashMap<>();
        for (String zone : zones) {
            ZoneId zoneId = ZoneId.of(zone);
            result.put(zone, ZonedDateTime.now(zoneId));
        }
        return result;
    }

    // Get available zone IDs
    public java.util.Set<String> getAvailableZoneIds() {
        return ZoneId.getAvailableZoneIds();
    }

    // Get system default timezone
    public ZoneId getSystemTimezone() {
        return ZoneId.systemDefault();
    }

    // Get offset from UTC
    public String getUTCOffset() {
        return getUTCOffset(ZoneId.systemDefault());
    }

    public String getUTCOffset(ZoneId zoneId) {
        ZonedDateTime now = ZonedDateTime.now(zoneId);
        return now.getOffset().getId();
    }
}

// 6. Time Comparisons
public class TimeComparer {

    public enum ComparisonResult {
        BEFORE, EQUAL, AFTER
    }

    // Compare two instants
    public ComparisonResult compareInstants(Instant instant1, Instant instant2) {
        if (instant1.isBefore(instant2)) {
            return ComparisonResult.BEFORE;
        } else if (instant1.isAfter(instant2)) {
            return ComparisonResult.AFTER;
        } else {
            return ComparisonResult.EQUAL;
        }
    }

    public static class DurationInfo {
        public long days;
        public long hours;
        public long minutes;
        public long seconds;
        public long millis;

        public DurationInfo(long days, long hours, long minutes, long seconds, long millis) {
            this.days = days;
            this.hours = hours;
            this.minutes = minutes;
            this.seconds = seconds;
            this.millis = millis;
        }

        public void print() {
            System.out.println("Duration: " + days + "d " + hours + "h " + minutes + "m " + seconds + "s");
        }
    }

    // Calculate duration between instants
    public DurationInfo calculateDuration(Instant instant1, Instant instant2) {
        java.time.Duration duration = java.time.Duration.between(instant1, instant2);
        return new DurationInfo(
            duration.toDays(),
            duration.toHours(),
            duration.toMinutes(),
            duration.getSeconds(),
            duration.toMillis()
        );
    }

    // Check if time is within range
    public boolean isWithinRange(Instant instant, Instant start, Instant end) {
        return !instant.isBefore(start) && !instant.isAfter(end);
    }
}

// Main demonstration
public class GetCurrentTimeDemo {
    public static void demonstrateGetCurrentTime() {
        System.out.println("=== Android Java Get Current Time Examples ===\n");

        // 1. Modern API
        System.out.println("--- 1. Modern API (API 26+) ---");
        ModernTimeGetter modernGetter = new ModernTimeGetter();

        Instant instant = modernGetter.getCurrentInstant();
        System.out.println("Current instant: " + instant);

        LocalDateTime localDateTime = modernGetter.getCurrentLocalDateTime();
        System.out.println("Local date-time: " + localDateTime);

        ZonedDateTime zonedDateTime = modernGetter.getCurrentZonedDateTime();
        System.out.println("Zoned date-time: " + zonedDateTime);

        long timestamp = modernGetter.getCurrentTimestamp();
        System.out.println("Timestamp (ms): " + timestamp);

        long unixTimestamp = modernGetter.getCurrentUnixTimestamp();
        System.out.println("Unix timestamp: " + unixTimestamp);

        // 2. Time in different zones
        System.out.println("\n--- 2. Time in Different Timezones ---");
        ZonedDateTime timeInUTC = modernGetter.getCurrentTimeInZone("UTC");
        System.out.println("UTC: " + timeInUTC);

        ZonedDateTime timeInNY = modernGetter.getCurrentTimeInZone("America/New_York");
        System.out.println("New York: " + timeInNY);

        ZonedDateTime timeInTokyo = modernGetter.getCurrentTimeInZone("Asia/Tokyo");
        System.out.println("Tokyo: " + timeInTokyo);

        ZonedDateTime timeInLondon = modernGetter.getCurrentTimeInZone("Europe/London");
        System.out.println("London: " + timeInLondon);

        // 3. Legacy API
        System.out.println("\n--- 3. Legacy API ---");
        LegacyTimeGetter legacyGetter = new LegacyTimeGetter();

        Date date = legacyGetter.getCurrentDate();
        System.out.println("Current date: " + date);

        Calendar calendar = legacyGetter.getCurrentCalendar();
        System.out.println("Calendar time: " + calendar.getTime());

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

        System.out.println("Elapsed realtime: " + systemGetter.getElapsedRealtime() + " ms");
        System.out.println("Uptime millis: " + systemGetter.getUptimeMillis() + " ms");
        System.out.println("Current thread time: " + systemGetter.getCurrentThreadTimeMillis() + " ms");

        // 5. Extract components
        System.out.println("\n--- 5. Extract Time Components ---");
        TimeComponentExtractor extractor = new TimeComponentExtractor();
        TimeComponentExtractor.TimeComponents components = extractor.extractComponentsModern(localDateTime);
        components.print();

        System.out.println("\nTime of day: " + extractor.getTimeOfDay(localDateTime));

        // 6. Multiple timezones
        System.out.println("\n--- 6. Multiple Timezones ---");
        TimeZoneOperations zoneOps = new TimeZoneOperations();

        java.util.List<String> zones = new java.util.ArrayList<>();
        zones.add("UTC");
        zones.add("America/Los_Angeles");
        zones.add("Europe/Paris");
        zones.add("Asia/Shanghai");

        java.util.Map<String, ZonedDateTime> timesInZones = zoneOps.getCurrentTimeInZones(zones);

        for (java.util.Map.Entry<String, ZonedDateTime> entry : timesInZones.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        System.out.println("System timezone: " + zoneOps.getSystemTimezone());
        System.out.println("UTC offset: " + zoneOps.getUTCOffset());

        // 7. Time comparison
        System.out.println("\n--- 7. Time Comparison ---");
        TimeComparer comparer = new TimeComparer();

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

        System.out.println("Compare now vs later: " + comparer.compareInstants(now, later));
        System.out.println("Compare now vs earlier: " + comparer.compareInstants(now, earlier));

        TimeComparer.DurationInfo duration = comparer.calculateDuration(now, later);
        System.out.println("Duration between now and later:");
        duration.print();

        System.out.println("\n=== All Get Current Time Examples Completed ===");
    }
}

// Android Java 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
public class ModernDateFormatter {

    // ISO format
    public String formatToISO(LocalDateTime localDateTime) {
        return localDateTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
    }

    // Custom pattern
    public String formatWithPattern(LocalDateTime localDateTime, String pattern) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return localDateTime.format(formatter);
    }

    // Pre-defined common formats
    public String formatDateFull(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        return localDateTime.format(formatter);
    }

    public String formatTimeFull(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        return localDateTime.format(formatter);
    }

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

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

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

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

// 2. Localized Formatting
public class LocalizedFormatter {

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

    // Format in different locales
    public java.util.Map<String, String> formatDateInMultipleLocales(LocalDateTime localDateTime) {
        java.util.Map<String, Locale> locales = new java.util.HashMap<>();
        locales.put("en", Locale.ENGLISH);
        locales.put("zh", Locale.CHINESE);
        locales.put("es", new Locale("es"));
        locales.put("fr", Locale.FRENCH);
        locales.put("de", Locale.GERMAN);
        locales.put("ja", Locale.JAPANESE);
        locales.put("ar", new Locale("ar"));

        java.util.Map<String, String> results = new java.util.HashMap<>();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy MMMM dd, EEEE HH:mm");

        for (java.util.Map.Entry<String, Locale> entry : locales.entrySet()) {
            String formatted = localDateTime.format(formatter.withLocale(entry.getValue()));
            results.put(entry.getKey(), formatted);
        }

        return results;
    }

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

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

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

// 3. Legacy Formatting (SimpleDateFormat)
public class LegacyDateFormatter {

    // Format Date using SimpleDateFormat
    public String formatDate(Date date, String pattern) {
        SimpleDateFormat formatter = new SimpleDateFormat(pattern);
        return formatter.format(date);
    }

    // Format Calendar
    public String formatCalendar(Calendar calendar, String pattern) {
        SimpleDateFormat formatter = new SimpleDateFormat(pattern);
        return formatter.format(calendar.getTime());
    }

    // Common formats
    public String formatISO(Date date) {
        return formatDate(date, "yyyy-MM-dd'T'HH:mm:ss");
    }

    public String formatReadable(Date date) {
        return formatDate(date, "MMMM dd, yyyy 'at' HH:mm");
    }

    public String formatShort(Date date) {
        return formatDate(date, "yy/MM/dd");
    }

    // Format with locale
    public String formatDateWithLocale(Date date, String pattern, Locale locale) {
        SimpleDateFormat formatter = new SimpleDateFormat(pattern, locale);
        return formatter.format(date);
    }
}

// 4. Pre-defined Formats
public class PredefinedFormats {

    // Date only formats
    public String formatDateOnly(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        return localDateTime.format(formatter);
    }

    public String formatDateSlash(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
        return localDateTime.format(formatter);
    }

    public String formatDateMonthName(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM dd, yyyy");
        return localDateTime.format(formatter);
    }

    // Time only formats
    public String formatTimeOnly(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        return localDateTime.format(formatter);
    }

    public String formatTime12Hour(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("hh:mm a");
        return localDateTime.format(formatter);
    }

    // Combined formats
    public String formatCompact(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss");
        return localDateTime.format(formatter);
    }

    public String formatHumanReadable(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("EEEE, MMMM dd, yyyy 'at' HH:mm");
        return localDateTime.format(formatter);
    }

    // Format for specific use cases
    public String formatForFilename(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss");
        return localDateTime.format(formatter);
    }

    public String formatForLog(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
        return localDateTime.format(formatter);
    }

    public String formatForDisplay(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMM dd, h:mm a");
        return localDateTime.format(formatter);
    }
}

// 5. Relative Time Formatting
public class RelativeTimeFormatter {

    public enum TimeScale {
        SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, YEAR
    }

    public static class TimeDelta {
        public long amount;
        public TimeScale scale;

        public TimeDelta(long amount, TimeScale scale) {
            this.amount = amount;
            this.scale = scale;
        }

        @Override
        public String toString() {
            String unit;
            switch (scale) {
                case SECOND:
                    unit = amount == 1 ? "second" : "seconds";
                    break;
                case MINUTE:
                    unit = amount == 1 ? "minute" : "minutes";
                    break;
                case HOUR:
                    unit = amount == 1 ? "hour" : "hours";
                    break;
                case DAY:
                    unit = amount == 1 ? "day" : "days";
                    break;
                case WEEK:
                    unit = amount == 1 ? "week" : "weeks";
                    break;
                case MONTH:
                    unit = amount == 1 ? "month" : "months";
                    break;
                case YEAR:
                    unit = amount == 1 ? "year" : "years";
                    break;
                default:
                    unit = "";
            }
            return amount + " " + unit;
        }
    }

    // Calculate time delta
    public TimeDelta calculateDelta(Instant past, Instant now) {
        long seconds = java.time.Duration.between(past, now).getSeconds();
        long absSeconds = Math.abs(seconds);

        if (absSeconds < 60) {
            return new TimeDelta(absSeconds, TimeScale.SECOND);
        } else if (absSeconds < 3600) {
            return new TimeDelta(absSeconds / 60, TimeScale.MINUTE);
        } else if (absSeconds < 86400) {
            return new TimeDelta(absSeconds / 3600, TimeScale.HOUR);
        } else if (absSeconds < 604800) {
            return new TimeDelta(absSeconds / 86400, TimeScale.DAY);
        } else if (absSeconds < 2592000) {
            return new TimeDelta(absSeconds / 604800, TimeScale.WEEK);
        } else if (absSeconds < 31536000) {
            return new TimeDelta(absSeconds / 2592000, TimeScale.MONTH);
        } else {
            return new TimeDelta(absSeconds / 31536000, TimeScale.YEAR);
        }
    }

    // Format relative time
    public String formatRelative(Instant past, Instant now) {
        TimeDelta delta = calculateDelta(past, now);
        boolean isFuture = past.isAfter(now);

        if (delta.amount == 0) {
            return "just now";
        }

        if (isFuture) {
            return "in " + delta.toString();
        } else {
            return delta.toString() + " ago";
        }
    }

    // Format short relative time
    public String formatShortRelative(Instant past, Instant now) {
        long seconds = java.time.Duration.between(past, now).getSeconds();
        long absSeconds = Math.abs(seconds);
        boolean isFuture = seconds > 0;

        if (absSeconds < 60) {
            return isFuture ? "soon" : "now";
        } else if (absSeconds < 3600) {
            long mins = absSeconds / 60;
            return isFuture ? "+" + mins + "m" : "-" + mins + "m";
        } else if (absSeconds < 86400) {
            long hours = absSeconds / 3600;
            return isFuture ? "+" + hours + "h" : "-" + hours + "h";
        } else {
            long days = absSeconds / 86400;
            return isFuture ? "+" + days + "d" : "-" + days + "d";
        }
    }
}

// 6. Format Conversion
public class FormatConverter {

    // Convert LocalDateTime to String
    public String toString(LocalDateTime localDateTime, String pattern) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return localDateTime.format(formatter);
    }

    // Convert Instant to String in specific timezone
    public String toString(Instant instant, ZoneId zone, String pattern) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return instant.atZone(zone).format(formatter);
    }

    // Convert legacy Date to String
    public String toString(Date date, String pattern) {
        SimpleDateFormat formatter = new SimpleDateFormat(pattern);
        return formatter.format(date);
    }

    // Convert legacy Calendar to String
    public String toString(Calendar calendar, String pattern) {
        SimpleDateFormat formatter = new SimpleDateFormat(pattern);
        return formatter.format(calendar.getTime());
    }
}

// Main demonstration
public class DateTimeFormattingDemo {
    public static void demonstrateDateTimeFormatting() {
        System.out.println("=== Android Java Date & Time Formatting Examples ===\n");

        LocalDateTime now = LocalDateTime.now();

        // 1. Modern formatting
        System.out.println("--- 1. Modern API Formatting ---");
        ModernDateFormatter modernFormatter = new ModernDateFormatter();

        System.out.println("ISO format: " + modernFormatter.formatToISO(now));
        System.out.println("Date full: " + modernFormatter.formatDateFull(now));
        System.out.println("Time full: " + modernFormatter.formatTimeFull(now));
        System.out.println("Date-Time full: " + modernFormatter.formatDateTimeFull(now));
        System.out.println("Short: " + modernFormatter.formatShort(now));
        System.out.println("With millis: " + modernFormatter.formatWithMillis(now));
        System.out.println("Custom (yyyy.MM.dd): " + modernFormatter.formatWithPattern(now, "yyyy.MM.dd"));

        // 2. Localized formatting
        System.out.println("\n--- 2. Localized Formatting ---");
        LocalizedFormatter localizedFormatter = new LocalizedFormatter();

        System.out.println("English (US): " + localizedFormatter.formatDateLocalized(now, Locale.US));
        System.out.println("French: " + localizedFormatter.formatDateLocalized(now, Locale.FRANCE));
        System.out.println("German: " + localizedFormatter.formatDateLocalized(now, Locale.GERMANY));
        System.out.println("Chinese: " + localizedFormatter.formatDateLocalized(now, Locale.CHINA));
        System.out.println("Japanese: " + localizedFormatter.formatDateLocalized(now, Locale.JAPAN));

        // Multiple locales
        System.out.println("\nMultiple locales:");
        java.util.Map<String, String> formattedDates = localizedFormatter.formatDateInMultipleLocales(now);
        for (java.util.Map.Entry<String, String> entry : formattedDates.entrySet()) {
            System.out.println("  " + entry.getKey() + ": " + entry.getValue());
        }

        // 3. Pre-defined formats
        System.out.println("\n--- 3. Pre-defined Formats ---");
        PredefinedFormats predefined = new PredefinedFormats();

        System.out.println("Date only: " + predefined.formatDateOnly(now));
        System.out.println("Date slash: " + predefined.formatDateSlash(now));
        System.out.println("Month name: " + predefined.formatDateMonthName(now));
        System.out.println("Time only: " + predefined.formatTimeOnly(now));
        System.out.println("Time 12-hour: " + predefined.formatTime12Hour(now));
        System.out.println("Compact: " + predefined.formatCompact(now));
        System.out.println("Human readable: " + predefined.formatHumanReadable(now));
        System.out.println("Filename: " + predefined.formatForFilename(now));
        System.out.println("Log: " + predefined.formatForLog(now));
        System.out.println("Display: " + predefined.formatForDisplay(now));

        // 4. Legacy formatting
        System.out.println("\n--- 4. Legacy API Formatting ---");
        LegacyDateFormatter legacyFormatter = new LegacyDateFormatter();

        Date currentDate = new Date();
        Calendar currentCalendar = Calendar.getInstance();

        System.out.println("Legacy ISO: " + legacyFormatter.formatISO(currentDate));
        System.out.println("Legacy readable: " + legacyFormatter.formatReadable(currentDate));
        System.out.println("Legacy short: " + legacyFormatter.formatShort(currentDate));
        System.out.println("Custom (dd-MM-yyyy): " + legacyFormatter.formatDate(currentDate, "dd-MM-yyyy"));
        System.out.println("Calendar formatted: " + legacyFormatter.formatCalendar(currentCalendar, "yyyy-MM-dd HH:mm:ss"));

        // 5. Relative time
        System.out.println("\n--- 5. Relative Time Formatting ---");
        RelativeTimeFormatter relativeFormatter = new RelativeTimeFormatter();

        Instant currentInstant = Instant.now();
        Instant oneMinuteAgo = currentInstant.minusSeconds(60);
        Instant oneHourAgo = currentInstant.minusSeconds(3600);
        Instant oneDayAgo = currentInstant.minusSeconds(86400);
        Instant oneWeekAgo = currentInstant.minusSeconds(604800);

        System.out.println("1 minute ago: " + relativeFormatter.formatRelative(oneMinuteAgo, currentInstant));
        System.out.println("1 hour ago: " + relativeFormatter.formatRelative(oneHourAgo, currentInstant));
        System.out.println("1 day ago: " + relativeFormatter.formatRelative(oneDayAgo, currentInstant));
        System.out.println("1 week ago: " + relativeFormatter.formatRelative(oneWeekAgo, currentInstant));

        System.out.println("\nShort relative:");
        System.out.println("1 minute ago: " + relativeFormatter.formatShortRelative(oneMinuteAgo, currentInstant));
        System.out.println("1 hour ago: " + relativeFormatter.formatShortRelative(oneHourAgo, currentInstant));
        System.out.println("1 day ago: " + relativeFormatter.formatShortRelative(oneDayAgo, currentInstant));

        System.out.println("\n=== All Date & Time Formatting Examples Completed ===");
    }
}

// Android Java 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.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Date;
import java.util.Calendar;
import java.util.Locale;

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

    // Parse from ISO format
    public LocalDateTime parseFromISO(String text) throws DateTimeParseException {
        return LocalDateTime.parse(text, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
    }

    // Parse from custom pattern
    public LocalDateTime parseWithPattern(String text, String pattern) throws DateTimeParseException {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return LocalDateTime.parse(text, formatter);
    }

    // Parse date only
    public LocalDate parseDate(String text, String pattern) throws DateTimeParseException {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return LocalDate.parse(text, formatter);
    }

    // Parse time only
    public LocalTime parseTime(String text, String pattern) throws DateTimeParseException {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return LocalTime.parse(text, formatter);
    }

    // Parse zoned datetime
    public ZonedDateTime parseZoned(String text, String pattern) throws DateTimeParseException {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return ZonedDateTime.parse(text, formatter);
    }
}

// 2. Safe Parsing with Error Handling
public class SafeDateParser {

    public static class ParseResult<T> {
        public boolean success;
        public T value;
        public String error;

        public ParseResult(boolean success, T value, String error) {
            this.success = success;
            this.value = value;
            this.error = error;
        }

        public static <T> ParseResult<T> success(T value) {
            return new ParseResult<>(true, value, null);
        }

        public static <T> ParseResult<T> failure(String error) {
            return new ParseResult<>(false, null, error);
        }
    }

    // Try parse with default value
    public LocalDateTime tryParse(String text, String pattern, LocalDateTime defaultValue) {
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
            return LocalDateTime.parse(text, formatter);
        } catch (DateTimeParseException e) {
            return defaultValue;
        }
    }

    // Try parse with result
    public ParseResult<LocalDateTime> tryParse(String text, String pattern) {
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
            LocalDateTime result = LocalDateTime.parse(text, formatter);
            return ParseResult.success(result);
        } catch (DateTimeParseException e) {
            return ParseResult.failure("Parse error: " + e.getMessage());
        }
    }

    // Parse with multiple patterns
    public ParseResult<LocalDateTime> parseWithMultiplePatterns(String text, String[] patterns) {
        for (String pattern : patterns) {
            try {
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
                LocalDateTime result = LocalDateTime.parse(text, formatter);
                return ParseResult.success(result);
            } catch (DateTimeParseException e) {
                // Try next pattern
            }
        }
        return ParseResult.failure("No matching pattern found");
    }

    // Parse or null
    public LocalDateTime parseOrNull(String text, String pattern) {
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
            return LocalDateTime.parse(text, formatter);
        } catch (DateTimeParseException e) {
            return null;
        }
    }
}

// 3. Parse Common Formats
public class CommonFormatParser {

    // Parse ISO date (yyyy-MM-dd)
    public LocalDate parseISODate(String text) throws DateTimeParseException {
        return LocalDate.parse(text);
    }

    // Parse ISO time (HH:mm:ss)
    public LocalTime parseISOTime(String text) throws DateTimeParseException {
        return LocalTime.parse(text);
    }

    // Parse US format (MM/dd/yyyy)
    public LocalDate parseUSFormat(String text) throws DateTimeParseException {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
        return LocalDate.parse(text, formatter);
    }

    // Parse European format (dd/MM/yyyy)
    public LocalDate parseEuropeanFormat(String text) throws DateTimeParseException {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
        return LocalDate.parse(text, formatter);
    }

    // Parse compact format (yyyyMMdd)
    public LocalDate parseCompactFormat(String text) throws DateTimeParseException {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
        return LocalDate.parse(text, formatter);
    }

    // Parse readable format (MMMM dd, yyyy)
    public LocalDate parseReadableFormat(String text) throws DateTimeParseException {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM dd, yyyy");
        return LocalDate.parse(text, formatter);
    }

    // Parse with time (yyyy-MM-dd HH:mm:ss)
    public LocalDateTime parseWithTime(String text) throws DateTimeParseException {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        return LocalDateTime.parse(text, formatter);
    }
}

// 4. Legacy Parsing (SimpleDateFormat)
public class LegacyDateParser {

    // Parse string to Date
    public Date parseDate(String text, String pattern) throws ParseException {
        SimpleDateFormat formatter = new SimpleDateFormat(pattern);
        return formatter.parse(text);
    }

    // Parse with locale
    public Date parseDate(String text, String pattern, Locale locale) throws ParseException {
        SimpleDateFormat formatter = new SimpleDateFormat(pattern, locale);
        return formatter.parse(text);
    }

    // Try parse with default
    public Date tryParse(String text, String pattern, Date defaultValue) {
        try {
            SimpleDateFormat formatter = new SimpleDateFormat(pattern);
            return formatter.parse(text);
        } catch (ParseException e) {
            return defaultValue;
        }
    }

    // Parse to Calendar
    public Calendar parseToCalendar(String text, String pattern) throws ParseException {
        SimpleDateFormat formatter = new SimpleDateFormat(pattern);
        Date date = formatter.parse(text);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar;
    }
}

// 5. Flexible Parsing
public class FlexibleParser {

    // Auto-detect format
    public LocalDateTime autoDetect(String text) {
        String[] patterns = {
            "yyyy-MM-dd HH:mm:ss",
            "yyyy-MM-dd'T'HH:mm:ss",
            "yyyy/MM/dd HH:mm:ss",
            "dd/MM/yyyy HH:mm:ss",
            "MM-dd-yyyy HH:mm:ss",
            "yyyyMMdd HHmmss"
        };

        SafeDateParser parser = new SafeDateParser();
        SafeDateParser.ParseResult<LocalDateTime> result = parser.parseWithMultiplePatterns(text, patterns);

        if (result.success) {
            return result.value;
        } else {
            throw new IllegalArgumentException("Unable to parse date: " + text);
        }
    }

    // Parse with lenient mode
    public LocalDateTime parseLenient(String text, String pattern) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        try {
            return LocalDateTime.parse(text, formatter);
        } catch (DateTimeParseException e) {
            // Try lenient parsing with legacy API
            try {
                SimpleDateFormat legacyFormatter = new SimpleDateFormat(pattern);
                legacyFormatter.setLenient(true);
                Date date = legacyFormatter.parse(text);
                return LocalDateTime.ofInstant(date.toInstant(), java.time.ZoneId.systemDefault());
            } catch (ParseException pe) {
                throw new IllegalArgumentException("Lenient parsing failed", pe);
            }
        }
    }

    // Parse and normalize
    public LocalDateTime parseAndNormalize(String text) {
        // Trim whitespace
        text = text.trim();

        // Try standard patterns
        String[] patterns = {
            "yyyy-MM-dd HH:mm:ss",
            "yyyy-MM-dd",
            "MM/dd/yyyy",
            "dd/MM/yyyy"
        };

        for (String pattern : patterns) {
            try {
                if (pattern.length() == text.length() || pattern.contains("y") && pattern.contains("M") && pattern.contains("d")) {
                    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
                    return LocalDateTime.parse(text, formatter);
                }
            } catch (DateTimeParseException e) {
                // Continue
            }
        }

        throw new IllegalArgumentException("Unable to parse and normalize: " + text);
    }
}

// 6. Validation
public class DateValidator {

    // Check if string is valid date
    public boolean isValidDate(String text, String pattern) {
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
            LocalDate.parse(text, formatter);
            return true;
        } catch (DateTimeParseException e) {
            return false;
        }
    }

    // Validate date is in valid range
    public boolean isValidRange(LocalDate date, LocalDate min, LocalDate max) {
        return !date.isBefore(min) && !date.isAfter(max);
    }

    // Check if string matches pattern
    public boolean matchesPattern(String text, String pattern) {
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
            LocalDate.parse(text, formatter);
            return true;
        } catch (DateTimeParseException e) {
            return false;
        }
    }

    // Validate and parse
    public SafeDateParser.ParseResult<LocalDate> validateAndParse(String text, String pattern) {
        if (!matchesPattern(text, pattern)) {
            return SafeDateParser.failure("Invalid format");
        }

        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
            LocalDate result = LocalDate.parse(text, formatter);
            return SafeDateParser.success(result);
        } catch (DateTimeParseException e) {
            return SafeDateParser.failure("Validation failed: " + e.getMessage());
        }
    }
}

// 7. Batch Parsing
public class BatchParser {

    // Parse multiple dates
    public java.util.List<LocalDate> parseMultiple(java.util.List<String> texts, String pattern) {
        java.util.List<LocalDate> results = new java.util.ArrayList<>();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);

        for (String text : texts) {
            try {
                LocalDate date = LocalDate.parse(text, formatter);
                results.add(date);
            } catch (DateTimeParseException e) {
                // Skip invalid dates
            }
        }

        return results;
    }

    // Parse with success/failure tracking
    public static class BatchParseResult {
        public java.util.List<LocalDate> successes = new java.util.ArrayList<>();
        public java.util.Map<String, String> failures = new java.util.HashMap<>();

        public void addSuccess(LocalDate date) {
            successes.add(date);
        }

        public void addFailure(String input, String error) {
            failures.put(input, error);
        }

        public void printSummary() {
            System.out.println("Successes: " + successes.size());
            System.out.println("Failures: " + failures.size());
            if (!failures.isEmpty()) {
                System.out.println("Failed inputs:");
                for (java.util.Map.Entry<String, String> entry : failures.entrySet()) {
                    System.out.println("  " + entry.getKey() + ": " + entry.getValue());
                }
            }
        }
    }

    public BatchParseResult parseBatch(java.util.List<String> texts, String pattern) {
        BatchParseResult result = new BatchParseResult();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);

        for (String text : texts) {
            try {
                LocalDate date = LocalDate.parse(text, formatter);
                result.addSuccess(date);
            } catch (DateTimeParseException e) {
                result.addFailure(text, e.getMessage());
            }
        }

        return result;
    }
}

// Main demonstration
public class DateTimeParsingDemo {
    public static void demonstrateDateTimeParsing() {
        System.out.println("=== Android Java Date & Time Parsing Examples ===\n");

        // 1. Basic parsing
        System.out.println("--- 1. Basic Parsing ---");
        ModernDateParser modernParser = new ModernDateParser();

        try {
            LocalDateTime dateTime1 = modernParser.parseWithPattern("2024-12-28 15:30:45", "yyyy-MM-dd HH:mm:ss");
            System.out.println("Parsed: " + dateTime1);

            LocalDate date = modernParser.parseDate("2024-12-28", "yyyy-MM-dd");
            System.out.println("Parsed date: " + date);

            LocalTime time = modernParser.parseTime("15:30:45", "HH:mm:ss");
            System.out.println("Parsed time: " + time);
        } catch (DateTimeParseException e) {
            System.out.println("Parse error: " + e.getMessage());
        }

        // 2. Common formats
        System.out.println("\n--- 2. Common Formats ---");
        CommonFormatParser commonParser = new CommonFormatParser();

        try {
            LocalDate isoDate = commonParser.parseISODate("2024-12-28");
            System.out.println("ISO date: " + isoDate);

            LocalDate usDate = commonParser.parseUSFormat("12/28/2024");
            System.out.println("US format: " + usDate);

            LocalDate euDate = commonParser.parseEuropeanFormat("28/12/2024");
            System.out.println("European format: " + euDate);

            LocalDate compactDate = commonParser.parseCompactFormat("20241228");
            System.out.println("Compact format: " + compactDate);

            LocalDate readableDate = commonParser.parseReadableFormat("December 28, 2024");
            System.out.println("Readable format: " + readableDate);

            LocalDateTime withTime = commonParser.parseWithTime("2024-12-28 15:30:45");
            System.out.println("With time: " + withTime);
        } catch (DateTimeParseException e) {
            System.out.println("Parse error: " + e.getMessage());
        }

        // 3. Safe parsing
        System.out.println("\n--- 3. Safe Parsing ---");
        SafeDateParser safeParser = new SafeDateParser();

        LocalDateTime defaultValue = LocalDateTime.now();
        LocalDateTime parsed = safeParser.tryParse("2024-12-28 15:30:45", "yyyy-MM-dd HH:mm:ss", defaultValue);
        System.out.println("Try parse (valid): " + parsed);

        LocalDateTime parsedInvalid = safeParser.tryParse("invalid", "yyyy-MM-dd HH:mm:ss", defaultValue);
        System.out.println("Try parse (invalid): " + parsedInvalid);

        SafeDateParser.ParseResult<LocalDateTime> result = safeParser.tryParse("2024-12-28 15:30:45", "yyyy-MM-dd HH:mm:ss");
        System.out.println("Parse result: success=" + result.success + ", value=" + result.value);

        // 4. Multiple patterns
        System.out.println("\n--- 4. Parse with Multiple Patterns ---");
        String[] patterns = {"yyyy-MM-dd", "MM/dd/yyyy", "dd/MM/yyyy", "yyyyMMdd"};
        SafeDateParser.ParseResult<LocalDateTime> multiResult = safeParser.parseWithMultiplePatterns("12/28/2024", patterns);
        System.out.println("Multi-pattern parse: success=" + multiResult.success + ", value=" + multiResult.value);

        // 5. Legacy parsing
        System.out.println("\n--- 5. Legacy API Parsing ---");
        LegacyDateParser legacyParser = new LegacyDateParser();

        try {
            Date legacyDate = legacyParser.parseDate("12/28/2024 15:30", "MM/dd/yyyy HH:mm");
            System.out.println("Legacy date: " + legacyDate);

            Calendar legacyCalendar = legacyParser.parseToCalendar("12/28/2024", "MM/dd/yyyy");
            System.out.println("Legacy calendar: " + legacyCalendar.getTime());

            Date tryLegacy = legacyParser.tryParse("invalid", "MM/dd/yyyy", new Date());
            System.out.println("Try parse legacy (fallback): " + tryLegacy);
        } catch (ParseException e) {
            System.out.println("Legacy parse error: " + e.getMessage());
        }

        // 6. Validation
        System.out.println("\n--- 6. Date Validation ---");
        DateValidator validator = new DateValidator();

        System.out.println("Valid date '2024-12-28': " + validator.isValidDate("2024-12-28", "yyyy-MM-dd"));
        System.out.println("Invalid date '2024-13-45': " + validator.isValidDate("2024-13-45", "yyyy-MM-dd"));

        LocalDate validDate = LocalDate.of(2024, 12, 28);
        LocalDate minDate = LocalDate.of(2024, 1, 1);
        LocalDate maxDate = LocalDate.of(2024, 12, 31);
        System.out.println("In range: " + validator.isValidRange(validDate, minDate, maxDate));

        // 7. Batch parsing
        System.out.println("\n--- 7. Batch Parsing ---");
        BatchParser batchParser = new BatchParser();

        java.util.List<String> dateStrings = new java.util.ArrayList<>();
        dateStrings.add("2024-12-28");
        dateStrings.add("2024-12-29");
        dateStrings.add("invalid");
        dateStrings.add("2024-12-30");

        BatchParser.BatchParseResult batchResult = batchParser.parseBatch(dateStrings, "yyyy-MM-dd");
        batchResult.printSummary();

        System.out.println("\n=== All Date & Time Parsing Examples Completed ===");
    }
}