Exemples de Date et Heure Android Java

Exemples de date et heure Android Java incluant obtenir l'heure actuelle, formater les dates et analyser les chaînes de date

Key Facts

Category: Java
Items: 3
Format Families: text

Sample Overview

Exemples de date et heure Android Java incluant obtenir l'heure actuelle, formater les dates et analyser les chaînes de date This sample set belongs to Java and can be used to test related workflows inside Elysia Tools.

💻 Obtenir l'Heure Actuelle java

🟢 simple ⭐⭐

Obtenir l'heure système actuelle dans divers formats et fuseaux horaires

⏱️ 15 min 🏷️ java, android, datetime

Prerequisites: Basic Java knowledge, Java Time API

// 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+)
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
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)
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
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
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
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
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 ===");
    }
}

💻 Formatage de Date et Heure java

🟡 intermediate ⭐⭐⭐

Formater les objets date et heure en chaînes utilisant divers modèles et paramètres régionaux

⏱️ 25 min 🏷️ java, android, datetime

Prerequisites: Intermediate Java, DateTimeFormatter

// 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
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
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)
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
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
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
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
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 ===");
    }
}

💻 Analyse de Date et Heure java

🟡 intermediate ⭐⭐⭐

Analyser les chaînes de date en objets date utilisant divers formats et gérer les erreurs d'analyse

⏱️ 30 min 🏷️ java, android, datetime