How to get Epoch/UNIX timestamps in java

In Java, getting Epoch timestamps is straightforward, and there are multiple methods to accomplish this task. This article explores different ways to get Epoch timestamps in Java and provides practical use cases.

Using the System.currentTimeMillis() Method

Java provides the System.currentTimeMillis() method to fetch the current time in milliseconds since the Unix Epoch. You can use this method to calculate the current Epoch timestamp.

public class Main {
    public static void main(String[] args) {
        long epochTime = System.currentTimeMillis() / 1000;
        System.out.println("Current Epoch timestamp: " + epochTime);
    }
}

This code snippet utilizes the System.currentTimeMillis() method to obtain the current time in milliseconds and then converts it to seconds to obtain the Epoch timestamp.

Use Case 1: Logging timestamps

public class Main {
    public static void main(String[] args) {
        long epochTime = System.currentTimeMillis() / 1000;
        String data = "Sensor data reading...";
        System.out.println(data + " - timestamp: " + epochTime);
    }
}

In this example, Java code is adapted for logging data with timestamps. It first obtains the current Epoch timestamp and then combines it with sensor data for logging.

Use Case 2: Time Duration Calculation

public class Main {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis() / 1000;

        // Perform a task or operation

        long endTime = System.currentTimeMillis() / 1000;
        long timeElapsed = endTime - startTime;

        System.out.println("Time taken: " + timeElapsed + " seconds");
    }
}

This use case demonstrates how to measure the time taken for a task. It records the start and end times in System.currentTimeMillis() and calculates the time elapsed in seconds.

Using the Instant.now() Method

Java 8 introduced the java.time.Instant class, which provides a modern way to work with time. You can use Instant.now() to obtain the current time and calculate the current Epoch timestamp.

import java.time.Instant;

public class Main {
    public static void main(String[] args) {
        Instant now = Instant.now();
        long epochTime = now.getEpochSecond();
        System.out.println("Current Epoch timestamp: " + epochTime);
    }
}

This code snippet showcases how to use Instant.now() to fetch the current time and obtain the Epoch timestamp from it.

Use Case 3: Expiry timestamp for Cache

import java.time.Instant;

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

        String cacheKey = "cached_data";
        long expiryTime = epochTime + 600; // 10 minutes from now

        System.out.println("Cached data that expires at " + expiryTime);

        if (epochTime > expiryTime) {
            System.out.println("Cache expired. Recaching data...");
            // Re-cache the data
        }
    }
}

In this example, the Java code calculates the expiry time for cache data in the Instant class and checks if the cache has expired.

Use Case 4: Event Scheduling

import java.time.Instant;

public class Main {
    public static void main(String[] args) {
        Instant now = Instant.now();
        long epochTime = now.getEpochSecond();
        long eventTime = epochTime + 3600; // 1 hour from now

        while (true) {
            now = Instant.now();
            epochTime = now.getEpochSecond();

            if (epochTime >= eventTime) {
                System.out.println("Event occurred!");
                break;
            }
        }
    }
}

This use case demonstrates how to schedule an event to occur in the future. Java code adds 3600 seconds (1 hour) to the current time to set the event time and continuously checks for its occurrence.

These code examples illustrate how to get Epoch/UNIX timestamps in Java and showcase their applications in practical scenarios. Whether you need to log data with timestamps, calculate time durations, set cache expiry times, or schedule events, Epoch timestamps are versatile tools in Java for precise time-related operations.