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("Asia/Tokyo");
ZonedDateTime tokyoNow = ZonedDateTime.now(tokyo);

System.out.println(tokyoNow);

Use named regions such as Asia/Tokyo or America/New_York rather than a fixed offset when daylight-saving rules should be applied.

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:

import java.time.Clock;
import java.time.LocalDate;

class ReportService {
    private final Clock clock;

    ReportService(Clock clock) {
        this.clock = clock;
    }

    LocalDate reportDate() {
        return LocalDate.now(clock);
    }
}

A test can use Clock.fixed(...) to get a predictable date. This avoids flaky tests around midnight or time-zone differences.

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");

A fixed offset never changes. It does not model daylight saving time. Use a region ID when regional rules matter:

ZoneId zone = ZoneId.of("America/New_York");

Mixing legacy and modern APIs unnecessarily

java.util.Date oldDate = new java.util.Date();

Legacy APIs may be required by older libraries, but use java.time in new code. Convert only at integration boundaries.

Assuming printed output has a fixed format

Do not parse toString() output manually. Use DateTimeFormatter when you need a specific display or API format.

ZonedDateTime vs OffsetDateTime

ZonedDateTime has a region such as Europe/London and therefore knows changing daylight-saving rules. OffsetDateTime only has an offset such as +01:00. Use ZonedDateTime for regional scheduling; use Instant or OffsetDateTime for many API and storage scenarios.

java.time vs java.util.Date

java.time provides separate, clearly named types and immutable objects. java.util.Date is a legacy type whose name is misleading because it also represents a timestamp. Prefer java.time for new code.

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.
• Avoid new uses of java.util.Date and Calendar when java.time is available.

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 new Date() in new Java code?

java.util.Date is a legacy API with a less clear design. The java.time API has immutable, thread-safe types that represent dates, local times, zones, and instants explicitly.

How can I test code that uses the current date in Java?

Inject a Clock and call methods such as LocalDate.now(clock). Tests can supply a fixed clock rather than relying on the real current time.

Is UTC always the best time zone?

UTC is usually best for storing global timestamps. However, local business rules, such as a store closing at midnight, must use the relevant regional ZoneId.

• 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.