The Modern Way: `java.time` (Java 8+)

Before Java 8, handling dates with `java.util.Date` and `Calendar` was cumbersome. The introduction of the `java.time` package (JSR-310) revolutionized this. It provides immutable, thread-safe classes that are much more intuitive to use. The core class for representing a timestamp is `Instant`.

1. Get the Current Unix Timestamp

`Instant.now()` returns the current moment from the system clock in UTC. From this `Instant` object, you can get the timestamp in either seconds or milliseconds.

java

import java.time.Instant;

class Main {
  public static void main(String[] args) {
    Instant now = Instant.now();

    // Get timestamp in seconds (long)
    long epochSeconds = now.getEpochSecond();
    System.out.println("Seconds since epoch: " + epochSeconds);

    // Get timestamp in milliseconds (long)
    long epochMillis = now.toEpochMilli();
    System.out.println("Milliseconds since epoch: " + epochMillis);
  }
}

2. Convert a Unix Timestamp to a Date Object

You can create an `Instant` directly from a timestamp value. Use `ofEpochSecond` for second precision or `ofEpochMilli` for millisecond precision.

java

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;

class Main {
  public static void main(String[] args) {
    long timestampInSeconds = 1678886400L;

    // Create an Instant from the timestamp
    Instant instant = Instant.ofEpochSecond(timestampInSeconds);

    // To view it as a human-readable date, convert to LocalDateTime
    // Note: This requires specifying a timezone offset, UTC is common for servers
    LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneOffset.UTC);

    System.out.println("Instant: " + instant); // "2023-03-15T13:20:00Z"
    System.out.println("LocalDateTime (UTC): " + dateTime);
  }
}

3. Convert a Date Object to a Unix Timestamp

To perform the reverse, you can create a `LocalDateTime` object and then convert it to an `Instant` to extract the timestamp. This requires specifying a timezone, as a local date/time doesn't uniquely identify a moment without an offset.

java

import java.time.LocalDateTime;
import java.time.ZoneOffset;

class Main {
  public static void main(String[] args) {
    // Create a specific LocalDateTime
    LocalDateTime localDateTime = LocalDateTime.of(2024, 10, 12, 10, 30, 0);

    // Convert it to a timestamp, assuming it represents a UTC time
    long timestamp = localDateTime.toEpochSecond(ZoneOffset.UTC);

    System.out.println("LocalDateTime: " + localDateTime);
    System.out.println("Unix Timestamp (seconds): " + timestamp); // 1728712200
  }
}

4. Handling Timezones and Formatting

The `java.time` package excels at timezone management. Use `ZonedDateTime` to work with timezone-aware dates and `DateTimeFormatter` for custom output formats.

java

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

class Main {
  public static void main(String[] args) {
    long timestamp = 1678886400L;
    Instant instant = Instant.ofEpochSecond(timestamp);

    // Create a timezone-aware date for New York
    ZoneId nyZone = ZoneId.of("America/New_York");
    ZonedDateTime nyDateTime = ZonedDateTime.ofInstant(instant, nyZone);

    // Create a custom formatter
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z");

    System.out.println("New York Time: " + nyDateTime.format(formatter));
    // Expected Output: New York Time: 2023-03-15 09:20:00 EDT
  }
}

🔗 Related Guides