Java Duration plus() Method

The plus() method in Java, part of the java.time.Duration class, is used to add a specified amount of time to a Duration instance. This method is useful for calculating durations that are a specified amount of time longer than the original duration.

Table of Contents

  1. Introduction
  2. plus() Method Syntax
  3. Understanding plus()
  4. Examples
    • Basic Usage
    • Adding Different Temporal Units
  5. Real-World Use Case
  6. Conclusion

Introduction

The plus() method allows you to add a specified duration or amount of time to an existing Duration instance. This is particularly useful when you need to adjust a duration by a specific amount of time, such as extending an interval or adding additional time to a task.

plus() Method Syntax

The Duration class provides several overloaded plus() methods to add various temporal units or another Duration instance. Here are the main variants:

  1. Adding a specified duration:
public Duration plus(Duration duration)
  1. Adding a specified amount of time:
public Duration plus(long amountToAdd, TemporalUnit unit)
  1. Adding a specified number of days:
public Duration plusDays(long daysToAdd)
  1. Adding a specified number of hours:
public Duration plusHours(long hoursToAdd)
  1. Adding a specified number of minutes:
public Duration plusMinutes(long minutesToAdd)
  1. Adding a specified number of seconds:
public Duration plusSeconds(long secondsToAdd)
  1. Adding a specified number of milliseconds:
public Duration plusMillis(long millisToAdd)
  1. Adding a specified number of nanoseconds:
public Duration plusNanos(long nanosToAdd)

Understanding plus()

The plus() method creates a new Duration instance by adding the specified amount of time to the original duration. The result is a new Duration object representing the adjusted time span.

Examples

Basic Usage

To demonstrate the basic usage of plus(), we will add a specified duration to an existing Duration instance.

Example

import java.time.Duration;

public class DurationPlusExample {
    public static void main(String[] args) {
        Duration originalDuration = Duration.ofHours(1);
        Duration addedDuration = originalDuration.plus(Duration.ofMinutes(30));

        System.out.println("Original duration: " + originalDuration);
        System.out.println("Added duration: " + addedDuration);
    }
}

Output:

Original duration: PT1H
Added duration: PT1H30M

Adding Different Temporal Units

This example shows how to use different variants of the plus() method to add various temporal units to a Duration instance.

Example

import java.time.Duration;

public class DurationAddUnitsExample {
    public static void main(String[] args) {
        Duration duration = Duration.ofHours(1);

        // Add hours
        Duration result1 = duration.plusHours(2);
        System.out.println("After adding 2 hours: " + result1);

        // Add minutes
        Duration result2 = duration.plusMinutes(30);
        System.out.println("After adding 30 minutes: " + result2);

        // Add seconds
        Duration result3 = duration.plusSeconds(120);
        System.out.println("After adding 120 seconds: " + result3);

        // Add milliseconds
        Duration result4 = duration.plusMillis(60000);
        System.out.println("After adding 60000 milliseconds: " + result4);

        // Add nanoseconds
        Duration result5 = duration.plusNanos(1000000000);
        System.out.println("After adding 1000000000 nanoseconds: " + result5);
    }
}

Output:

After adding 2 hours: PT3H
After adding 30 minutes: PT1H30M
After adding 120 seconds: PT1H2M
After adding 60000 milliseconds: PT1H1M
After adding 1000000000 nanoseconds: PT1H1S

Real-World Use Case

Extending Task Durations

In real-world applications, the plus() method can be used to extend task durations, such as adding additional time to a task or extending a deadline by a certain amount.

Example

import java.time.Duration;

public class TaskDurationExtensionExample {
    public static void main(String[] args) {
        Duration originalDuration = Duration.ofHours(2);
        long extraMinutes = 45;

        // Extend the original duration by adding extra minutes
        Duration extendedDuration = originalDuration.plusMinutes(extraMinutes);

        System.out.println("Original duration: " + originalDuration);
        System.out.println("Extended duration: " + extendedDuration);
    }
}

Output:

Original duration: PT2H
Extended duration: PT2H45M

Conclusion

The Duration.plus() method is used to add a specified amount of time to a Duration instance. This method is particularly useful for adjusting durations by adding specific time units. By understanding and using this method, you can effectively manage and manipulate time-based data in your Java applications.

Continue Learning with Java Guides

Want to take your programming skills to the next level? Explore my practical Udemy courses on Java, Spring Boot, Microservices, Full-Stack Development, Docker, and Generative AI. You can also follow my structured learning roadmaps to become a professional developer.

By Ramesh Fadatare - Udemy Instructor Partner

Comments