Last Updated: 

Convert 10-Digit Timestamp to Date in Java

In Java, dealing with timestamps and dates is a common task in many applications. A 10 - digit timestamp typically represents the number of seconds that have elapsed since the Unix epoch (January 1, 1970, 00:00:00 UTC). Converting such a timestamp to a human-readable date is often necessary for data presentation, logging, and other purposes. This blog post will guide you through the process of converting a 10 - digit timestamp to a date in Java, covering core concepts, typical usage scenarios, common pitfalls, and best practices.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Converting 10 - Digit Timestamp to Date in Java
    • Using java.util.Date and SimpleDateFormat
    • Using java.time Package
  4. Common Pitfalls
  5. Best Practices
  6. Conclusion
  7. FAQ
  8. References

Core Concepts#

Unix Epoch#

The Unix epoch is the time 00:00:00 UTC on January 1, 1970. A 10 - digit timestamp is the number of seconds that have passed since this moment. For example, the timestamp 1630464000 represents a specific point in time after the Unix epoch.

Time Zones#

When converting a timestamp to a date, it's important to consider the time zone. Different time zones have different offsets from UTC, which can affect the final date and time representation.

Date and Time APIs in Java#

Java has two main date and time APIs: the legacy java.util.Date and java.text.SimpleDateFormat, and the modern java.time package introduced in Java 8. The java.time package provides a more robust, immutable, and thread-safe way to handle dates and times.

Typical Usage Scenarios#

  • Data Presentation: When displaying data from a database or an API, timestamps are often used to record events. Converting these timestamps to dates makes the data more understandable for users.
  • Logging: In log files, timestamps are used to record when events occurred. Converting them to dates helps in analyzing and debugging the application.
  • Data Analysis: When performing data analysis, it's often necessary to group data by date. Converting timestamps to dates allows for easier categorization and aggregation.

Converting 10 - Digit Timestamp to Date in Java#

Using java.util.Date and SimpleDateFormat#

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
 
public class TimestampToDateLegacy {
    public static void main(String[] args) {
        // 10 - digit timestamp
        long timestamp = 1630464000;
        // Convert seconds to milliseconds
        long timestampInMillis = timestamp * 1000;
        // Create a Date object
        Date date = new Date(timestampInMillis);
        // Create a SimpleDateFormat object with the desired format
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy - MM - dd HH:mm:ss");
        // Set the time zone if needed
        sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
        // Format the date
        String formattedDate = sdf.format(date);
        System.out.println("Formatted Date: " + formattedDate);
    }
}

In this code:

  1. We first convert the 10 - digit timestamp (in seconds) to milliseconds because the Date constructor expects the timestamp in milliseconds.
  2. We create a Date object using the timestamp in milliseconds.
  3. We create a SimpleDateFormat object with the desired date format.
  4. We set the time zone to UTC if needed.
  5. Finally, we format the Date object to a string.

Using java.time Package#

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
 
public class TimestampToDateModern {
    public static void main(String[] args) {
        // 10 - digit timestamp
        long timestamp = 1630464000;
        // Create an Instant object from the timestamp
        Instant instant = Instant.ofEpochSecond(timestamp);
        // Convert the Instant to a LocalDateTime object in a specific time zone
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.of("UTC"));
        // Create a DateTimeFormatter object with the desired format
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy - MM - dd HH:mm:ss");
        // Format the LocalDateTime object
        String formattedDate = localDateTime.format(formatter);
        System.out.println("Formatted Date: " + formattedDate);
    }
}

In this code:

  1. We create an Instant object from the 10 - digit timestamp using Instant.ofEpochSecond().
  2. We convert the Instant to a LocalDateTime object in a specific time zone.
  3. We create a DateTimeFormatter object with the desired date format.
  4. Finally, we format the LocalDateTime object to a string.

Common Pitfalls#

  • Time Zone Issues: Not specifying the correct time zone can lead to incorrect date and time representations. For example, if you are working with data from different regions, you need to ensure that the time zone is set correctly.
  • Thread Safety: The SimpleDateFormat class is not thread-safe. If used in a multi-threaded environment, it can lead to inconsistent results or exceptions.
  • Timestamp Unit: A 10 - digit timestamp is in seconds, but the Date constructor and some other methods expect the timestamp in milliseconds. Failing to convert the timestamp to milliseconds can result in incorrect dates.

Best Practices#

  • Use the java.time Package: The java.time package introduced in Java 8 provides a more modern, thread-safe, and immutable way to handle dates and times. It is recommended to use this package over the legacy java.util.Date and SimpleDateFormat classes.
  • Specify Time Zones Explicitly: Always specify the time zone when converting timestamps to dates to avoid confusion and incorrect results.
  • Handle Exceptions: When using date and time formatting, handle exceptions such as DateTimeParseException to ensure the robustness of your code.

Conclusion#

Converting a 10 - digit timestamp to a date in Java is a common task that can be achieved using either the legacy java.util.Date and SimpleDateFormat classes or the modern java.time package. The java.time package is preferred due to its thread-safety, immutability, and better API design. By following the best practices and being aware of the common pitfalls, you can effectively convert timestamps to dates in your Java applications.

FAQ#

Q: What is the difference between a 10 - digit and a 13 - digit timestamp? A: A 10 - digit timestamp represents the number of seconds since the Unix epoch, while a 13 - digit timestamp represents the number of milliseconds since the Unix epoch.

Q: Can I use the java.time package in Java 7? A: No, the java.time package was introduced in Java 8. If you are using Java 7 or earlier, you need to use the legacy java.util.Date and SimpleDateFormat classes.

Q: How can I handle different date formats? A: You can use the SimpleDateFormat or DateTimeFormatter classes to specify different date formats. For example, "yyyy - MM - dd" for the format 2023 - 09 - 01 or "dd/MM/yyyy" for the format 01/09/2023.

References#

2025-10