How to get the current date and time in Java

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now(); // date and time, no zone
        LocalDate today = LocalDate.now();       // just the date
        LocalTime time = LocalTime.now();        // just the time

        // Each run gets a different moment, so this page prints checks.
        // In your own code: System.out.println(now);
        System.out.println(now.getClass().getSimpleName());
        System.out.println("year >= 2026: " + (now.getYear() >= 2026));
        System.out.println("today matches yyyy-MM-dd: "
                + today.toString().matches("\\d{4}-\\d{2}-\\d{2}"));
        System.out.println("hour is 0-23: " + (time.getHour() >= 0 && time.getHour() < 24));

        // Every field has a getter; month and weekday are enums.
        System.out.println("month 1-12: " + (now.getMonthValue() >= 1 && now.getMonthValue() <= 12));
        System.out.println(now.getMonth().getClass().getSimpleName() + ", "
                + now.getDayOfWeek().getClass().getSimpleName());

        // The toString() shape: ISO 8601 with a T, down to the nanosecond
        System.out.println("has a T: " + now.toString().contains("T"));
    }
}

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        // A frozen clock, so the output is the same every run.
        // In real code: LocalDateTime now = LocalDateTime.now();
        Clock clock = Clock.fixed(Instant.parse("2026-09-25T14:05:09.123Z"), ZoneOffset.UTC);
        LocalDateTime now = LocalDateTime.now(clock);

        // Build a formatter once and reuse it: it's immutable and thread-safe.
        DateTimeFormatter stamp = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
        System.out.println(now.format(stamp));

        System.out.println(now.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")));
        System.out.println(now.format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss")));

        // Names of months and days depend on the locale, so pass one.
        DateTimeFormatter human = DateTimeFormatter.ofPattern("EEEE, MMMM d, yyyy 'at' h:mm a", Locale.US);
        System.out.println(now.format(human));
        System.out.println(now.format(DateTimeFormatter.ofPattern("EEEE d MMMM yyyy", Locale.FRANCE)));

        // ISO 8601, no pattern needed
        System.out.println(now.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
        System.out.println(now.format(DateTimeFormatter.ISO_LOCAL_DATE));

        // The live clock works the same way:
        String live = LocalDateTime.now().format(stamp);
        System.out.println("live matches the pattern: "
                + live.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3}"));
    }
}

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Locale;

public class Main {
    static void show(LocalDateTime t, String pattern) {
        String out = t.format(DateTimeFormatter.ofPattern(pattern, Locale.US));
        System.out.printf("%-24s %s%n", pattern, out);
    }

    public static void main(String[] args) {
        LocalDateTime t = LocalDateTime.of(2026, 12, 28, 21, 7, 3, 45_000_000);

        show(t, "yyyy-MM-dd HH:mm:ss.SSS"); // correct
        show(t, "YYYY-MM-dd");  // Y = week-based year
        show(t, "yyyy-mm-dd");  // mm = minutes, not months
        show(t, "yyyy-MM-DD");  // D = day of the year
        show(t, "hh:mm:ss");    // hh = 12-hour clock...
        show(t, "hh:mm:ss a");  // ...so add a for AM/PM
        show(t, "HH:mm:ss.S");  // S = fraction digits, not milliseconds

        // toString() is ISO 8601, but it drops parts that are zero
        System.out.println(LocalDateTime.of(2026, 9, 25, 14, 5));
        System.out.println(LocalDateTime.of(2026, 9, 25, 14, 5)
                .format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    }
}

import java.time.Clock;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        // The JVM's default zone. On this sandbox it's GMT.
        System.out.println("default zone: " + ZoneId.systemDefault());

        // Live: "now" in a named zone. Tokyo has no daylight saving,
        // so its offset is the same on every run.
        ZonedDateTime tokyo = ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));
        System.out.println("Tokyo offset: " + tokyo.getOffset());

        // Instant.now() is the zone-free moment; epoch millis is the same moment as a long.
        long millis = System.currentTimeMillis();
        Instant instant = Instant.now();
        System.out.println("millis has 13 digits: " + (String.valueOf(millis).length() == 13));
        System.out.println("same moment (within 1s): " + (Math.abs(instant.toEpochMilli() - millis) < 1000));

        // One fixed instant, rendered in three zones
        Clock clock = Clock.fixed(Instant.parse("2026-09-25T14:05:09.123Z"), ZoneOffset.UTC);
        Instant fixed = Instant.now(clock);
        System.out.println(fixed);
        System.out.println(fixed.atZone(ZoneId.of("America/New_York")));
        System.out.println(ZonedDateTime.now(clock.withZone(ZoneId.of("Asia/Kolkata")))
                .format(DateTimeFormatter.ISO_OFFSET_DATE_TIME));

        // Epoch values, and back again
        System.out.println(fixed.toEpochMilli() + " ms, " + fixed.getEpochSecond() + " s");
        System.out.println(Instant.ofEpochMilli(1_790_345_109_123L));
        System.out.println(Instant.ofEpochSecond(0));
    }
}

import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeParseException;
import java.util.Calendar;
import java.util.Date;

public class Main {
    public static void main(String[] args) throws Exception {
        ZoneId utc = ZoneId.of("UTC");

        // LocalDateTime -> Date: a Date is an instant, so pick a zone first
        LocalDateTime local = LocalDateTime.of(2026, 9, 25, 14, 5, 9);
        Date date = Date.from(local.atZone(utc).toInstant());
        System.out.println(date.getTime());
        System.out.println(date); // toString() uses the JVM's default zone

        // Date -> LocalDateTime: go through its Instant
        LocalDateTime back = LocalDateTime.ofInstant(date.toInstant(), utc);
        System.out.println(back);
        System.out.println("round trip equal: " + back.equals(local));

        // The zone matters: the same wall-clock time in New York is 4 hours later
        Date ny = Date.from(local.atZone(ZoneId.of("America/New_York")).toInstant());
        System.out.println((ny.getTime() - date.getTime()) / 3_600_000 + " hours apart");

        // Instant <-> Date is direct, and new Date() is the legacy "now"
        System.out.println(date.toInstant());
        Date legacyNow = new Date();
        System.out.println("new Date() is now: "
                + (Math.abs(legacyNow.toInstant().toEpochMilli() - Instant.now().toEpochMilli()) < 1000));

        // Why java.time replaced these: Calendar months start at 0...
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        System.out.println("Calendar.MONTH for September: " + cal.get(Calendar.MONTH));

        // ...and SimpleDateFormat quietly rolls invalid dates over
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println(sdf.format(sdf.parse("2026-13-45")));
        try {
            LocalDate.parse("2026-13-45");
        } catch (DateTimeParseException e) {
            System.out.println(e.getMessage());
        }
    }
}