Increment Date in Java

1. Overview

In this tutorial, we’ll look at ways to increment date by one day using Java. Before Java 8, the standard Java date and time libraries weren’t very user-friendly. Hence, Joda-Time became the de facto standard date and time library for Java prior to Java 8.

There are also other classes and libraries that could be used to accomplish the task, like java.util.Calendar and Apache Commons.

Java 8 included a better date and time API to address the shortcomings of its older libraries.

Therefore, we’re looking at how to increment date by one day using Java 8, Joda-Time API, Java’s Calendar class and Apache Commons library.

2. Maven Dependencies

The following dependencies should be included in the pom.xml file:

<dependencies>
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.10</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.5</version>
    </dependency>
</dependencies>

You can find the latest version of the Joda-Time on Maven Central, and also the latest version of Apache Commons Lang.

3. Using java.time

The java.time.LocalDate class is an immutable date-time representation, often viewed as year-month-day.

LocalDate has many methods for date manipulation, let’s see how we can use it to accomplish the same task:

public static String addOneDay(String date) {
    return LocalDate
      .parse(date)
      .plusDays(1)
      .toString();
}

In this example, we’re using java.time.LocalDate class and its plusDays() method to increment the date by one day.

Now, let’s verify that this method is working as expected:

@Test
public void givenDate_whenUsingJava8_thenAddOneDay() 
  throws Exception {
 
    String incrementedDate = addOneDay("2018-07-03");
    assertEquals("2018-07-04", incrementedDate);
}

4. Using java.util.Calendar

Another approach is using java.util.Calendar and its add() method to increment the date.

We’ll use it along with java.text.SimpleDateFormat for date formatting purposes:

public static String addOneDayCalendar(String date) 
  throws ParseException {
 
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Calendar c = Calendar.getInstance();
    c.setTime(sdf.parse(date));
    c.add(Calendar.DATE, 1);
    return sdf.format(c.getTime());
}

java.text.SimpleDateFormat is there to ensure the expected date format is used. The date is increased via the add() method.

Once again, let’s make sure this approach works as intended:

@Test
public void givenDate_whenUsingCalendar_thenAddOneDay() 
  throws Exception {
 
    String incrementedDate = addOneDayCalendar("2018-07-03");
    assertEquals("2018-07-04", incrementedDate);
}

5. Using Joda-Time

The org.joda.time.DateTime class has many methods that help to properly deal with date and time.

Let’s see how we can use it to increment the date by one day:

public static String addOneDayJodaTime(String date) {
    DateTime dateTime = new DateTime(date);
    return dateTime
      .plusDays(1)
      .toString("yyyy-MM-dd");
}

Here, we use org.joda.time.DateTime class and its plusDays() method to increment the date by one day.

We can verify that the code above works with the following unit test:

@Test
public void givenDate_whenUsingJodaTime_thenAddOneDay() throws Exception {
    String incrementedDate = addOneDayJodaTime("2018-07-03");
    assertEquals("2018-07-04", incrementedDate);
}

6. Using Apache Commons

Another library commonly used for date manipulation (among other things) is Apache Commons. It’s a suite of utilities surrounding the use of the java.util.Calendar and java.util.Date objects.

For our task, we can use the org.apache.commons.lang3.time.DateUtils class and its addDays() method (note that SimpleDateFormat is again used for date formatting):

public static String addOneDayApacheCommons(String date) 
  throws ParseException {
 
    SimpleDateFormat sdf
      = new SimpleDateFormat("yyyy-MM-dd");
    Date incrementedDate = DateUtils
      .addDays(sdf.parse(date), 1);
    return sdf.format(incrementedDate);
}

As usual, we’ll verify the results with a unit test:

@Test
public void givenDate_whenUsingApacheCommons_thenAddOneDay()
  throws Exception {
 
    String incrementedDate = addOneDayApacheCommons(
      "2018-07-03");
    assertEquals("2018-07-04", incrementedDate);
}

7. Conclusion

In this quick article, we looked at various approaches to dealing with a simple task of incrementing date by one day. We’ve shown how it can be accomplished using Java’s core APIs as well as some popular 3rd party libraries.

The code samples used in this article can be found over on GitHub.