Representing Furthest Possible Date in Java

Last updated: January 8, 2024

Written by: baeldung

Reviewed by: Saajan Nagendra

Java Dates

Date Formatting

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Introduction

There are scenarios where it’s essential to represent the furthest conceivable date value, particularly when dealing with default or placeholder dates.

In this tutorial, we’ll learn how to represent the furthest possible date using the java.util.Date class and the java.lang.Long class.

2. Why Represent the Furthest Possible Date?

Let’s consider a scenario where we’re developing a software licensing system, and we want these licenses to be valid indefinitely unless they’re explicitly set to expire.

In scenarios like this one, it’s crucial to have a clear representation of the furthest possible date value in our code. This representation serves as a reference point for no expiration date, streamlining the logic of checking and managing license validity.

3. What Is the Furthest Possible Date?

The furthest possible date value in Java is the largest possible date that can be represented by the java.util.Date class.

This class stores the date and time as a long integer that represents the number of milliseconds since January 1, 1970, 00:00:00 GMT (the epoch).

The maximum value of a long integer is Long.MAX_VALUE, which is equal to 9223372036854775807. Therefore, Java’s furthest possible date value is the date and time corresponding to this number of milliseconds.

4. How to Represent the Furthest Possible Date?

To represent the furthest possible date in Java, we can use the following steps:

Create a Date object by passing Long.MAX_VALUE as the argument to its constructor. This creates a Date object with the furthest possible date and time.
Optionally, we can format the Date object using a SimpleDateFormat object to display it in a human-readable format.

Here’s an example of how to represent the furthest possible date:

public class MaxDateDisplay {
    public String getMaxDateValue() {
        Date maxDate = new Date(Long.MAX_VALUE);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        return "The maximum date value in Java is: " + sdf.format(maxDate);
    }
}

5. Unit Testing for Formatting the Furthest Possible Date

To verify, we create an instance of MaxDateDisplay and call the getMaxDateValue() method. Then, we can use assertEquals() to compare the expected output with the actual result:

@Test
void whenGetMaxDate_thenCorrectResult() {
    MaxDateDisplay display = new MaxDateDisplay();
    String result = display.getMaxDateValue();
    assertEquals("The maximum date value in Java is: 292278994-08-17 07:12:55.807", result);
}

6. Unit Testing for Comparing Date

When sorting or comparing dates, a known furthest possible date value can serve as a placeholder, particularly when null values aren’t desired. It signifies that a date is set to the furthest conceivable point in the future, making it a valuable tool in comparison operations.

Here’s an example of how to compare the date value:

@Test
void whenCompareTodayWithMaxDate_thenCorrectResult() {
    Date today = new Date();
    Date maxDate = new Date(Long.MAX_VALUE);
    int comparisonResult = today.compareTo(maxDate);
    assertTrue(comparisonResult < 0);
}

7. Conclusion

In this article, we learned how to represent the furthest possible date using the java.util.Date class and the java.lang.Long class. We also saw some examples of how to use this technique in some use cases of having the furthest possible date value.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.