Get the Current Date and Time in Java with java.time

You will learn how to read the current date and time with Java's modern java.time API. You will know when to use LocalDate, LocalDateTime, ZonedDateTime, and Instant, and how to make time-dependent code easier to test with Clock.

Java represents “now” in several forms because applications need different amounts of time information.

• LocalDate stores a calendar date only: year, month, and day.
• LocalTime stores a clock time only: hour, minute, second, and nanoseconds.
• LocalDateTime combines a date and time, but has no time zone.
• ZonedDateTime combines a date, time, and named time zone such as Europe/Paris.
• Instant is a single, global moment on the UTC timeline. It is ideal for timestamps exchanged by systems and stored in databases.

For modern Java code, use the java.time package, available since Java 8. Its classes are immutable, thread-safe, and clearer than legacy types such as java.util.Date and Calendar.

The best type is determined by what the value means. A birthday needs a LocalDate; an event shown in a user's city may need a ZonedDateTime; an audit log usually needs an Instant.

Think of time data as different kinds of appointment notes:

• LocalDate is a note saying, “The holiday is on July 4.” There is no clock time.
• LocalDateTime is a note saying, “Meet at 09:30 on July 4.” It still does not say where the meeting happens.
• ZonedDateTime adds the location: “Meet at 09:30 on July 4 in America/New_York.”
• Instant is a universally numbered point on a timeline. Everyone around the world refers to the same instant, even though their local clocks display different dates or times.

Choose the smallest type that fully expresses your requirement. Add a time zone when local-time interpretation matters.

Import the modern date-time classes:

import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZonedDateTime;

Get common forms of the current time:

LocalDate today = LocalDate.now();
LocalDateTime localNow = LocalDateTime.now();
ZonedDateTime zonedNow = ZonedDateTime.now();
Instant timestamp = Instant.now();

System.out.println(today);
System.out.println(localNow);
System.out.println(zonedNow);
System.out.println(timestamp);

Example output will vary by machine and moment:

2025-03-08
2025-03-08T14:25:30.123
2025-03-08T14:25:30.123+01:00[Europe/Paris]
2025-03-08T13:25:30.123Z

LocalDateTime.now() uses the JVM's default time zone but does not retain that zone in the result. When the zone must be explicit, pass a ZoneId:

import java.time.ZoneId;
import java.time.ZonedDateTime;

ZoneId tokyo  ZoneId.of();
   ZonedDateTime.now(tokyo);

System.out.println(tokyoNow);

Consider this program:

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class CurrentTimeExample {
    public static void main(String[] args) {
        Instant now = Instant.now();
        ZoneId zone = ZoneId.of("America/New_York");
        ZonedDateTime localTime = now.atZone(zone);

        System.out.println(now);
        System.out.println(localTime);
    }
}

Step by step:

1. Instant.now() reads the current moment from the system clock. It represents that moment on the UTC timeline.
2. ZoneId.of("America/New_York") looks up the rules for New York, including daylight-saving transitions.
3. now.atZone(zone) displays the same instant as a date and clock time in New York.
4. The two printed values refer to one moment. Their hour and possibly their calendar date can differ because one uses UTC and the other uses New York local time.

For example, an instant near midnight UTC might still be the previous evening in New York.

• User interfaces: Display the current local date in a dashboard with LocalDate.now().
• Audit logs: Record when an account was created with Instant.now() so all servers use an unambiguous timestamp.
• Scheduled reports: Create a daily report based on a business zone, such as ZonedDateTime.now(ZoneId.of("Europe/London")).
• Expiration checks: Compare the current Instant with a token expiration timestamp.
• Billing periods: Determine the current calendar month in the organization's time zone before generating invoices.
• API responses: Return UTC timestamps, commonly formatted from an Instant, so clients can convert them to their own zones.

In production applications, developers usually make the time zone and clock source deliberate.

Store moments as Instant

For created-at, updated-at, and event timestamps, store a global moment:

Instant createdAt = Instant.now();

Convert it to a user's zone only when presenting it:

ZonedDateTime visibleTime = createdAt.atZone(userZone);

Use a business time zone for date rules

A server's default time zone can differ between developer machines, containers, and production servers. Specify the zone for business logic:

ZoneId businessZone = ZoneId.of("Australia/Sydney");
LocalDate businessToday = LocalDate.now(businessZone);

Inject Clock for testable code

Calling now() directly makes tests depend on the actual clock. Accept a Clock instead:

Using LocalDateTime for a global event timestamp

// Risky for data shared across time zones
LocalDateTime submittedAt = LocalDateTime.now();

This value does not identify a unique global moment without an associated zone or offset. Prefer Instant for logs, events, and data sent between systems.

Instant submittedAt = Instant.now();

Depending accidentally on the server's default zone

LocalDate today = LocalDate.now();

This is fine only when the machine's configured zone is truly the intended zone. For business rules, specify one:

LocalDate today = LocalDate.now(ZoneId.of("Europe/Berlin"));

Using a fixed offset as a replacement for a region

ZoneId zone = ZoneId.of("-05:00");

import java.time.*;

// Current calendar date in the JVM default zone
LocalDate date = LocalDate.now();

// Current local date and time, without a stored zone
LocalDateTime dateTime = LocalDateTime.now();

// Current moment in UTC
Instant instant = Instant.now();

// Current date and time in an explicit region
ZoneId zone = ZoneId.of("Europe/Paris");
ZonedDateTime zoned = ZonedDateTime.now(zone);

// Convert one instant for display in a zone
ZonedDateTime displayed = instant.atZone(zone);

• Use LocalDate when only the calendar date matters.
• Use Instant for a unique moment shared across machines and time zones.
• Use ZonedDateTime when regional clock rules matter.
• Prefer named zone IDs like America/Los_Angeles over fixed offsets when daylight saving time applies.
• Use Clock and now(clock) in services that need deterministic tests.

What is the best way to get the current date and time in Java?

Use the Java 8+ java.time API. Choose LocalDate.now(), LocalDateTime.now(), ZonedDateTime.now(), or Instant.now() based on the information your program needs.

Does LocalDateTime.now() include a time zone?

No. It reads the JVM default zone to calculate its fields, but the resulting LocalDateTime does not store a zone or offset.

Should I use Instant.now() or LocalDateTime.now()?

Use Instant.now() for an unambiguous event timestamp, especially for databases, logs, and APIs. Use LocalDateTime.now() only when a local date and clock time without zone information is meaningful.

How do I get the current time in a specific Java time zone?

Pass a ZoneId:

ZonedDateTime now = ZonedDateTime.now(ZoneId.of("Asia/Singapore"));

Why should I avoid in new Java code?

• Java LocalDate — represents date-only values such as birthdays and report days.
• Java LocalTime — represents a time of day without a date or zone.
• Java LocalDateTime — represents local date and time fields without zone information.
• Java Instant — represents a single global moment, useful for timestamps.
• Java ZonedDateTime — represents a date-time in a named geographical time zone.
• Java ZoneId — selects regional time-zone rules, including daylight saving time.
• Java Clock — supplies time to code and makes time-based tests predictable.
• Java DateTimeFormatter — formats and parses date-time values safely.