Java LongStream allMatch() Method

The allMatch() method in Java, part of the java.util.stream.LongStream interface, is used to check if all elements of the stream match the given predicate. This method is useful when you need to verify that all elements in a stream satisfy a specific condition.

Table of Contents

1. Introduction
2. allMatch() Method Syntax
3. Understanding allMatch()
4. Examples
   • Basic Usage
   • Using allMatch() with Complex Conditions
5. Real-World Use Case
6. Conclusion

Introduction

The allMatch() method is a terminal operation that returns true if all elements of the stream match the provided predicate, otherwise it returns false. This method is useful for scenarios where you need to ensure that all elements in a stream meet a certain condition.

allMatch() Method Syntax

The syntax for the allMatch() method is as follows:

boolean allMatch(LongPredicate predicate)

Parameters:

• predicate: A LongPredicate that represents the condition to be checked against the elements of the stream.

Returns:

• true if all elements match the predicate; otherwise, false.

Throws:

• This method does not throw any exceptions.

Understanding allMatch()

The allMatch() method processes each element of the stream and returns true if all elements match the given predicate. If any element does not match the predicate, it short-circuits and returns false.

Examples

Basic Usage

To demonstrate the basic usage of allMatch(), we will create a LongStream and use allMatch() to check if all elements are positive.

Example

import java.util.stream.LongStream;

public class AllMatchExample {
    public static void main(String[] args) {
        LongStream stream = LongStream.of(1L, 2L, 3L, 4L, 5L);

        // Use allMatch() to check if all elements are positive
        boolean allPositive = stream.allMatch(n -> n > 0);

        System.out.println("All elements are positive: " + allPositive);
    }
}

Output:

All elements are positive: true

Using allMatch() with Complex Conditions

This example shows how to use allMatch() with a more complex predicate to check if all elements in a LongStream are even.

Example

import java.util.stream.LongStream;

public class AllMatchComplexExample {
    public static void main(String[] args) {
        LongStream stream = LongStream.of(2L, 4L, 6L, 8L);

        // Use allMatch() to check if all elements are even
        boolean allEven = stream.allMatch(n -> n % 2 == 0);

        System.out.println("All elements are even: " + allEven);
    }
}

Output:

All elements are even: true

Real-World Use Case

Checking All Transactions Are Above a Minimum Amount

In real-world applications, the allMatch() method can be used to ensure that all transactions are above a minimum amount in a stream of transaction amounts.

Example

import java.util.stream.LongStream;

public class AllMatchRealWorldExample {
    public static void main(String[] args) {
        LongStream transactions = LongStream.of(100L, 200L, 150L, 300L);

        long minimumAmount = 100L;

        // Use allMatch() to check if all transactions are above the minimum amount
        boolean allAboveMinimum = transactions.allMatch(amount -> amount >= minimumAmount);

        System.out.println("All transactions are above the minimum amount: " + allAboveMinimum);
    }
}

Output:

All transactions are above the minimum amount: true

Conclusion

The LongStream.allMatch() method is used to check if all elements of the stream match the given predicate. This method is particularly useful for ensuring that all elements in a stream satisfy a specific condition. By understanding and using this method, you can efficiently manage and process streams of values in your Java applications, ensuring that conditions are validated as needed.