Duration minusMinutes(long) method in Java with Examples

The minusMinutes(long minutes) method in the Duration class in Java is utilized to subtract the required number of minutes from a Duration instance. The Duration class is one of the classes in the java. It is a time-based feature that was added in Java 8 and represents an amount of time, for example, 34.5 seconds.

Method Signature

Duration: The return type of the method is Duration and that tell us that the method returns an object of the Duration class. The returned Duration is equal to the original duration reduced by the given number of minutes.

minusMinutes: It is the name of the method. The name of the method itself states that the method is designed to sub several minutes from a duration.

long minutes: The method takes a single parameter, minutes, which is of type long. The parameter specifies the number of minutes to subtract from the Duration instance on which the method is called.

Example 1: Basic Usage

In this example, we create a Duration object representing a duration of 2 hours using the ofHours method. This duration is stored in the variable duration. We invoke the minusMinutes(30) method on the duration object. This subtracts 30 minutes from the original duration and returns a new Duration object, which we store in the variable resultDuration. We print the original duration and the duration after subtracting 30 minutes.

Filename: DurationExample.java

import java.time.Duration;
public class DurationExample {
    public static void main(String[] args) {
        // Step 1: Create a Duration representing 2 hours
        Duration duration = Duration.ofHours(2);
        // Step 2: Subtract 30 minutes from the duration
        // Explanation: We use the minusMinutes method to subtract 30 minutes from the original duration.
        // The original duration remains unchanged as the Duration class is immutable.
        Duration resultDuration = duration.minusMinutes(30);
        // Step 3: Print the original and result durations
        // Explanation: We use System.out.println to display the durations to the console.
        // We concatenate the duration objects with strings for readability.
        System.out.println("Original Duration: " + duration);         // Output: PT2H
        System.out.println("Duration after subtracting 30 minutes: " + resultDuration); // Output: PT1H30M
    }
}

Output

Original Duration: PT2H
Duration after subtracting 30 minutes: PT1H30M

Example 2: Handling Negative Result

In this example, we create a Duration object representing a duration of 45 minutes using the ofMinutes method. We attempt to subtract 60 minutes from the original duration using the minusMinutes method. Since the subtraction exceeds the original duration, the resulting duration is negative (PT-15M). This indicates a duration of 15 minutes in the past. We print both the original duration (PT45M) and the resulting duration after the subtraction (PT-15M) as output.

Filename: DurationExample1.java

import java.time.Duration;
public class DurationExample1 {
    public static void main(String[] args) {
        // Example 1: Subtraction resulting in a negative duration
        // Create a Duration of 45 minutes
        Duration duration1 = Duration.ofMinutes(45);
        // Subtract 60 minutes from the duration
        Duration resultDuration1 = duration1.minusMinutes(60);
        // Print the original and result durations
        System.out.println("Example 1 - Original Duration: " + duration1);         // Output: PT45M
        System.out.println("Example 1 - Duration after subtracting 60 minutes: " + resultDuration1); // Output: PT-15M
        // Example 2: Subtraction resulting in a negative duration
        // Create a Duration of 1 hour
        Duration duration2 = Duration.ofHours(1);
        // Subtract 2 hours from the duration
        Duration resultDuration2 = duration2.minusMinutes(120);
        // Print the original and result durations
        System.out.println("Example 2 - Original Duration: " + duration2);         // Output: PT1H
        System.out.println("Example 2 - Duration after subtracting 2 hours: " + resultDuration2); // Output: PT-1H
    }
}

Output

Example 1 - Original Duration: PT45M
Example 1 - Duration after subtracting 60 minutes: PT-15M
Example 2 - Original Duration: PT1H
Example 2 - Duration after subtracting 2 hours: PT-1H

Example 3: Chaining with Other Methods

In this example, we create a Duration object representing a duration of 1 hour and 20 minutes using the ofHours and plusMinutes methods. We chain the minusMinutes(50) method to subtract 50 minutes from the original duration. Then, we chain the minusSeconds(10) method to further subtract 10 seconds from the previously obtained duration. The final resulting duration represents 30 minutes and 10 seconds. We print both the original duration and the resulting duration as output.

Filename: DurationExample2.java

import java.time.Duration;
public class DurationExample2 {
    public static void main(String[] args) {
        // Example 1: Basic Chaining
        // Create a Duration of 1 hour and 20 minutes
        Duration duration1 = Duration.ofHours(1).plusMinutes(20);
        // Subtract 50 minutes and 10 seconds from the duration
        Duration resultDuration1 = duration1.minusMinutes(50).minusSeconds(10);
        // Print the original and result durations
        System.out.println("Example 1 - Original Duration: " + duration1);
        System.out.println("Example 1 - Duration after subtracting 50 minutes and 10 seconds: " + resultDuration1);
        System.out.println(); // Adding a newline for clarity
        // Example 2: Chaining with Negative Result
        // Create a Duration of 1 hour
        Duration duration2 = Duration.ofHours(1);
        // Subtract 2 hours and 30 minutes from the duration
        Duration resultDuration2 = duration2.minusHours(2).minusMinutes(30);
        // Print the original and result durations
        System.out.println("Example 2 - Original Duration: " + duration2);
        System.out.println("Example 2 - Duration after subtracting 2 hours and 30 minutes: " + resultDuration2);
        System.out.println(); // Adding a newline for clarity
        // Example 3: Chaining with Large Numbers
        // Create a Duration of 5 hours
        Duration duration3 = Duration.ofHours(5);
        // Subtract a large number of minutes and seconds from the duration
        Duration resultDuration3 = duration3.minusMinutes(30000).minusSeconds(1000);
        // Print the original and result durations
        System.out.println("Example 3 - Original Duration: " + duration3);
        System.out.println("Example 3 - Duration after subtracting 30000 minutes and 1000 seconds: " + resultDuration3);
    }
}

Output

Example 1 - Original Duration: PT1H20M
Example 1 - Duration after subtracting 50 minutes and 10 seconds: PT29M50S
Example 2 - Original Duration: PT1H
Example 2 - Duration after subtracting 2 hours and 30 minutes: PT-1H-30M
Example 3 - Original Duration: PT5H
Example 3 - Duration after subtracting 30000 minutes and 1000 seconds: PT-495H-16M-40S

Example 4: Large Number of Minutes to Subtract

In this example, we create a Duration object representing 5 hours. The method ofHours(5) initializes this duration and stores it in the variable duration. We subtract 30,000 minutes from the original duration using minusMinutes(30000). Since 30,000 minutes is equivalent to 500 hours (30,000 / 60), this subtraction results in a significant reduction, turning the duration negative. We then subtract 1000 seconds from the already negative duration using minusSeconds(1000).

Filename: LargeNumberOfMinutesExample.java

import java.time.Duration;
public class LargeNumberOfMinutesExample {
    public static void main(String[] args) {
        // Example 1: Subtracting a large number of minutes
        // Create a Duration of 5 hours
        Duration duration1 = Duration.ofHours(5);
        // Subtract 30,000 minutes from the duration
        Duration resultDuration1 = duration1.minusMinutes(30000);
        // Further subtract 1000 seconds from the duration
        resultDuration1 = resultDuration1.minusSeconds(1000);
        // Print the original and result durations
        System.out.println("Example 1 - Original Duration: " + duration1); // Output: PT5H
        System.out.println("Example 1 - Duration after subtracting 30,000 minutes and 1000 seconds: " + resultDuration1); // Output: PT-499H-1000S
        System.out.println(); // Adding a newline for clarity
        // Example 2: Subtracting enough minutes to span days
        // Create a Duration of 48 hours (2 days)
        Duration duration2 = Duration.ofDays(2);
        // Subtract 3 days worth of minutes (3 * 24 * 60 = 4320 minutes)
        Duration resultDuration2 = duration2.minusMinutes(4320);
        // Print the original and result durations
        System.out.println("Example 2 - Original Duration: " + duration2); // Output: PT48H
        System.out.println("Example 2 - Duration after subtracting 4320 minutes: " + resultDuration2); // Output: PT-24H
        System.out.println(); // Adding a newline for clarity
        // Example 3: Subtracting a large number of minutes from a shorter duration
        // Create a Duration of 1 hour
        Duration duration3 = Duration.ofHours(1);
        // Subtract 5000 minutes from the duration
        Duration resultDuration3 = duration3.minusMinutes(5000);
        // Further subtract 2000 seconds from the duration
        resultDuration3 = resultDuration3.minusSeconds(2000);
        // Print the original and result durations
        System.out.println("Example 3 - Original Duration: " + duration3); // Output: PT1H
        System.out.println("Example 3 - Duration after subtracting 5000 minutes and 2000 seconds: " + resultDuration3); // Output: PT-83H-2000S
    }
}

Output

Example 1 - Original Duration: PT5H
Example 1 - Duration after subtracting 30,000 minutes and 1000 seconds: PT-495H-16M-40S
Example 2 - Original Duration: PT48H
Example 2 - Duration after subtracting 4320 minutes: PT-24H
Example 3 - Original Duration: PT1H
Example 3 - Duration after subtracting 5000 minutes and 2000 seconds: PT-82H-53M-20S

Applications

1. Scheduling Systems

Meeting Schedulers: Adjust the duration of meetings or events by subtracting preparation or buffer times. Task Management: Recalculate remaining time for tasks when the start time is delayed or when breaks are taken.

2. Event Countdown Timers

Countdown Clocks: Subtract elapsed time from the total duration to display the remaining time until an event. Timers for Sports: Adjust game or match timers dynamically based on pauses or interruptions.

3. Time Tracking Applications

Work Loggers: Deduct break times from the total working hours to compute effective working time. Project Management: Track and adjust the remaining time for project tasks when delays occur.

Next TopicInsert-a-string-into-another-string-in-java

← prev next →