Using Current Time as Filename in Java

 1. Introduction

In this tutorial, we’ll look at several methods for obtaining the current timestamp value in Java and using it as a filename.

To accomplish our goal, we’ll leverage several classes from the Java DateTime API and third-party libraries such as Joda-Time.

2. Initial Setup

In later sections, we’ll build several test cases showcasing each approach for acquiring the current timestamp and using it as a filename.

However, to convert the timestamp value into a specified string format, we first need to specify the timestamp format and then use it to define the formatter classes:

static final String TIMESTAMP_FORMAT = "yyyyMMddHHmmss";
static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern(TIMESTAMP_FORMAT);
static final SimpleDateFormat SIMPLEDATE_FORMAT = new SimpleDateFormat(TIMESTAMP_FORMAT);

Following that, we’ll write a method that converts the current time value into a valid filename. The sample output of this method will look like “20231209122307.txt“:

String getFileName(String currentTime) {
    return MessageFormat.format("{0}.txt", currentTime);
}

Since we’re writing test cases, we’ll create another method to check whether the output filename contains a timestamp with the correct format:

boolean verifyFileName(String fileName) {
    return Pattern
      .compile("[0-9]{14}+\\.txt", Pattern.CASE_INSENSITIVE)
      .matcher(fileName)
      .matches();
}

In this scenario, our filename is composed of numbers that represent the timestamp. It’s advised to ensure that the filename format avoids using characters that are forbidden in file names, which are specific to the respective operating system.

3. Current Time With Java DateTime API

Java supplies legacy classes such as Calendar and Date to deal with date and time information. However, due to design flaws, new classes were introduced with the Java 8 DateTime API. The Date, Calendar, and SimpleDateFormatter classes are mutable and not thread-safe.

We’ll first take a look at the legacy classes Calendar and Date to generate the timestamp and gain a basic understanding, followed by Java 8 DateTime API classes like Instant, LocalDateTime, ZonedDateTime, and OffsetDateTime.

Notably, using the Java 8 DateTime API classes is recommended over legacy Java date and time classes for newer Java programs.

3.1. Using Calendar

The most basic approach is to use the Calendar.getInstance() method that returns a Calendar instance using the default time zone and locale. Furthermore, the getTime() method gives us the time value in milliseconds:

@Test
public void whenUsingCalender_thenGetCurrentTime() {
    String currentTime = SIMPLEDATE_FORMAT.format(Calendar.getInstance().getTime());
    String fileName = getFileName(currentTime);
  
    assertTrue(verifyFileName(fileName));
}

The SimpleDateFormatter class can transform the time value into the appropriate timestamp format.

3.2. Using Date

Similarly, we may construct an object of the Date class that expresses the object’s creation time in milliseconds. SimpleDateFormatter transforms the millisecond time value to the desired string pattern:

@Test
public void whenUsingDate_thenGetCurrentTime() {
    String currentTime = SIMPLEDATE_FORMAT.format(new Date());
    String fileName = getFileName(currentTime);
  
    assertTrue(verifyFileName(fileName));
}

It’s recommended  to use the new Java 8 classes that we’ll see in the next sections.

3.3. Using Instant

In Java, the Instant class represents a single moment on the UTC timeline:

@Test
public void whenUsingInstant_thenGetCurrentTime() {
    String currentTime = Instant
      .now()
      .truncatedTo(ChronoUnit.SECONDS)
      .toString()
      .replaceAll("[:TZ-]", "");
    String fileName = getFileName(currentTime);
    assertTrue(verifyFileName(fileName));
}

Instant.now() method asks the system clock for the current instant. We can use the truncatedTo() method to round off the value to the nearest second. The second value can then be changed to a string to substitute any undesired characters in the time zone information from the timestamp.

3.4. Using LocalDateTime

LocalDateTime represents the date and time of the day without a time zone in the ISO-8601 calendar system:

@Test
public void whenUsingLocalDateTime_thenGetCurrentTime() {
    String currentTime = LocalDateTime.now().format(DATETIME_FORMATTER);
    String fileName = getFileName(currentTime);
    assertTrue(verifyFileName(fileName));
}

LocalDateTime.now() method queries the default system clock to provide date-time information. We can then pass a DateTimeFormatter to format the timestamp into a string

3.5. Using ZonedDateTime

ZonedDateTime is an immutable representation of a date-time with a time zone:

@Test
public void whenUsingZonedDateTime_thenGetCurrentTime() {
    String currentTime = ZonedDateTime
      .now(ZoneId.of("Europe/Paris"))
      .format(DATETIME_FORMATTER);
    String fileName = getFileName(currentTime);
    assertTrue(verifyFileName(fileName));
}

A time zone identifier is capable of uniquely identifying specific geographical locations on Earth, for example, “Europe/Paris“. Using this identification, we can obtain the ZoneId, which determines the time zone to use for the conversion from Instant to LocalDateTime.

ZonedDateTime automatically handles daylight savings time (DST) adjustments throughout the year.

3.6. Using OffsetDateTime

OffsetDateTime is a simplified version of ZonedDateTime that ignores time zones. Time zone offsets vary between different regions of the world. For example, “+2:00” denotes a time in a time zone two hours after UTC. We can alter the default time in UTC by using the offset value with ZoneOffSet:

@Test
public void whenUsingOffsetDateTime_thenGetCurrentTime() {
    String currentTime = OffsetDateTime
      .of(LocalDateTime.now(), ZoneOffset.of("+02:00"))
      .format(DATETIME_FORMATTER);
    String fileName = getFileName(currentTime);
    assertTrue(verifyFileName(fileName));
}

Both ZonedDateTime and OffsetDateTime store an instant of the timeline up to a precision of nanoseconds. Knowing their differences helps us choose between them.

4. Current Time With Joda-Time

Joda-Time is a well-known library for date and time processing. It’s one of the most popular libraries among developers as a replacement for troublesome legacy Java classes. It handles date and time values using immutable classes.

Let’s add the Joda-Time Maven dependency in pom.xml:

<dependency>
    <groupId>joda-time</groupId>
    <artifactId>joda-time</artifactId>
    <version>2.12.5</version>
</dependency>

4.1. Using Joda DateTime

DateTime.now() method obtains a DateTime set to the current system millisecond time using the default time zone. We can then convert it to a String with a defined timestamp format:

@Test
public void whenUsingJodaTime_thenGetCurrentTime() {
    String currentTime = DateTime.now().toString(TIMESTAMP_FORMAT);
    String fileName = getFileName(currentTime);
    assertTrue(verifyFileName(fileName));
}

4.2. Using Joda Instant

Joda-Time library also provides the Instant class to capture the moment in the current timeline. We can use DateTimeFormat to transform the timestamp into the desired string pattern:

@Test
public void whenUsingJodaTimeInstant_thenGetCurrentTime() {
    String currentTime = DateTimeFormat
      .forPattern(TIMESTAMP_FORMAT)
      .print(org.joda.time.Instant.now().toDateTime());
    String fileName = getFileName(currentTime);
    assertTrue(verifyFileName(fileName));
}

5. Conclusion

In this article, we discovered a variety of methods for obtaining the current timestamp within a Java program and utilized them to generate a filename. We acquired the current timestamp by using various Java DateTime API classes and the Joda-Time library.

As always, the full code for this article can be found over on GitHub.