Adding One Month to Current Date in Java
Last updated: January 8, 2024
Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
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.
Regression testing is an important step in the release process, to ensure that new code doesn't break the existing functionality. As the codebase evolves, we want to run these tests frequently to help catch any issues early on.
The best way to ensure these tests run frequently on an automated basis is, of course, to include them in the CI/CD pipeline. This way, the regression tests will execute automatically whenever we commit code to the repository.
In this tutorial, we'll see how to create regression tests using Selenium, and then include them in our pipeline using GitHub Actions:, to be run on the LambdaTest cloud grid:
1. Overview
In this short tutorial, we’ll learn how to add one month to the current date in Java.
First, we’ll understand how to do this using core Java methods. Then, we’ll see how to accomplish the same using external libraries such as Joda-Time and Apache Commons Lang3.
2. Core Java Methods
Java provides several convenient ways to manipulate the date and time. Let’s explore different options to add one month to the current date.
2.1. Using Calendar Class
For versions earlier than Java 8, we can use Calendar to handle temporal data. This class offers a set of methods that we can use to manipulate date and time.
So, let’s see it in action:
@Test
void givenCalendarDate_whenAddingOneMonth_thenDateIsChangedCorrectly() {
Calendar calendar = Calendar.getInstance();
// Dummy current date
calendar.set(2023, Calendar.APRIL, 20);
// add one month
calendar.add(Calendar.MONTH, 1);
assertEquals(Calendar.MAY, calendar.get(Calendar.MONTH));
assertEquals(20, calendar.get(Calendar.DAY_OF_MONTH));
assertEquals(2023, calendar.get(Calendar.YEAR));
}
As we can see, we used the add() method to add exactly one month to the given date. Calendar.MONTH is the constant that denotes months.
2.2. Using Date Class
Date class is another option to consider if we want to change the month of a particular date. However, the drawback of this choice is that this class is deprecated.
Let’s see the use of Date using a test case:
@SuppressWarnings("deprecation")
@Test
void givenDate_whenAddingOneMonth_thenDateIsChangedCorrectly() {
Date currentDate = new Date(2023, Calendar.DECEMBER, 20);
Date expectedDate = new Date(2024, Calendar.JANUARY, 20);
currentDate.setMonth(currentDate.getMonth() + 1);
assertEquals(expectedDate, currentDate);
}As we can see above, the Date class provides the getMonth() method which returns a number representing the month. Furthermore, we added 1 to the returned number. Then, we called setMonth() to update the Date object with the new month.
Notably, it’s always recommended to use the new Date/Time API of Java 8 instead of the old one.
2.3. Using LocalDate Class
Similarly, we can use the LocalDate class introduced in Java 8. This class offers a straightforward and concise way to add months to a specific date through the plusMonths() method:
@Test
void givenJavaLocalDate_whenAddingOneMonth_thenDateIsChangedCorrectly() {
LocalDate localDate = LocalDate.of(2023, 12, 20);
localDate = localDate.plusMonths(1);
assertEquals(1, localDate.getMonthValue());
assertEquals(20, localDate.getDayOfMonth());
assertEquals(2024, localDate.getYear());
}Unsurprisingly, the test case passes with success.
3. Using Joda-Time
If Java 8 isn’t an option, we can opt for the Joda-Time library to achieve the same objective.
First, we need to add its dependency to the pom.xml file:
<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>2.10</version>
</dependency>Joda-Time provides its own version of the LocalDate class. So, let’s see how we can use it to add one month:
@Test
void givenJodaTimeLocalDate_whenAddingOneMonth_thenDateIsChangedCorrectly() {
org.joda.time.LocalDate localDate = new org.joda.time.LocalDate(2023, 12, 20);
localDate = localDate.plusMonths(1);
assertEquals(1, localDate.getMonthOfYear());
assertEquals(20, localDate.getDayOfMonth());
assertEquals(2024, localDate.getYear());
}As we can see, LocalDate also comes with the same method plusMonths(). As the name indicates, it allows us to add a certain number of months, which is 1 in our case.
4. Using Apache Commons Lang3
Alternatively, we can use the Apache Commons Lang3 library. As usual, to get started using this library, we first need to add the Maven dependency :
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.14.0</version>
</dependency>Typically, Apache Commons Lang3 provides the DateUtils utility class to perform a bunch of date operations.
Let’s see how to use it using a practical example:
@Test
void givenApacheCommonsLangDateUtils_whenAddingOneMonth_thenDateIsChangedCorrectly() {
Date currentDate = new GregorianCalendar(2023, Calendar.APRIL, 20, 4, 0).getTime();
Date expectedDate = new GregorianCalendar(2023, Calendar.MAY, 20, 4, 0).getTime();
assertEquals(expectedDate, DateUtils.addMonths(currentDate, 1));
}In a nutshell, we used the addMonths() method to increment the specified month by one. An important point to note here is that this method returns a new Date object. The original object remains unchanged.
5. Conclusion
In this short article, we explored different ways of adding one month to the current date in Java.
First, we saw how to do this using core Java classes. Then, we learned how to achieve the same using third-party libraries such as Joda Time and Apache Commons Lang3.
