Course Content

Stream API

1. Fundamentals and Functional Capabilities of Stream API

Architecture Principles What Is a Functional Interface?Predicate: Data Filtering Challenge: Filtering Corporate Email Addresses Function: Data Transformation Challenge: Income Tax Calculation Comparable: Natural Ordering of Data Comparator: Custom Comparison of Data Challenge: Sorting Employees Consumer: Processing Data Supplier: Data Generation Bi-versions of Functional Interfaces Challenge: Filtering Users by Two Criteria BinaryOperator: Combining Two Values

2. Intermediate Operations in Stream API

Transforming Elements with the map() Method Filtering Elements with the filter() Method Challenge: Factory Product Filtering Working with Nested Structures with the flatMap() Method Arranging Items in Order with the sorted() Method Challenge: Selecting the Best Cars on the Production Line Eliminating Duplicates with the distinct() Method Challenge: Factory Quality Control Restricting and Skipping Elements with the limit() and skip() Methods Challenge: Finding the Top 3 Hardest-Working Employees Intermediate Processing with the peek() Method

3. Terminal Operations in the Stream API

collect() Gathering Stream Elements into a Collection Challenge: Build a Custom Collector for Category Counting Collectors Utility Class for Stream API Processing Elements with the forEach() Method Handling Values with the Optional Class Aggregating Elements with the reduce() Method Challenge: Calculating Total Cost with Discounts and Tax Calculating Stream Statistics with count(), max(), and min()Retrieving Stream Summary Metrics with summaryStatistics() Method Retrieving Elements from a Stream with findFirst() and findAny()Challenge: Selecting Random Products Within a Category Checking Stream Elements Against a Condition with allMatch()Challenge: Ensuring Fast Delivery for Expensive Products

4. Practical Applications of Stream API

Real-World Examples of Using Stream API Performance in Stream API Exception Handling in Stream API Summary

Checking Stream Elements Against a Condition with allMatch()

When working with data streams, you often need to check whether elements meet certain conditions. For example, you might want to verify that all items in a shopping cart are in stock, that at least one item is discounted, or that there are no canceled orders.

To handle these cases, Stream API provides three useful methods: allMatch(), anyMatch(), and noneMatch(). These methods allow you to quickly check whether stream elements satisfy a given predicate.

allMatch() Method

The allMatch() method checks whether all elements in a stream satisfy a given predicate. If at least one element does not meet the condition, the method returns false.

This method takes a predicate—a function that returns a boolean—and applies it to each element in the stream. If all elements satisfy the condition, it returns true; otherwise, it returns false.

Practical Example

In an online store, free shipping is available if all items in the cart cost more than $10. You need to check whether free shipping applies to the current order.

Main


              1234567891011121314151617
            
package com.example;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> prices = List.of(15, 20, 12, 9); // Item prices

        boolean freeShipping = prices.stream().allMatch(price -> price > 10);

        if (freeShipping) {
            System.out.println("Free shipping applied.");
        } else {
            System.out.println("Not all items qualify for free shipping.");
        }
    }
}

In this code, you create a list of item prices: [15, 20, 12, 9]. The method allMatch(price -> price > 10) checks if all items cost more than $10. If they do, a message about successful free shipping is displayed; otherwise, a message indicating that not all items qualify appears.

anyMatch() Method

The anyMatch() method checks whether at least one element in a stream satisfies a given predicate. If at least one element meets the condition, the method returns true and stops processing.

This method takes a predicate and applies it to each element in the stream. As soon as it finds a matching element, it returns true and stops execution.

Practical Example

An online store offers a VIP program if at least one item in the cart costs more than $500. You need to check if the customer qualifies for VIP status.

Main


              1234567891011121314151617
            
package com.example;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> prices = List.of(530, 300, 40, 120); // Item prices

        boolean hasExpensiveItem = prices.stream().anyMatch(price -> price > 500);

        if (hasExpensiveItem) {
            System.out.println("Customer qualifies for VIP status.");
        } else {
            System.out.println("No expensive items in the cart.");
        }
    }
}

Here, the method anyMatch(price -> price > 500) checks whether there is at least one item priced over $500. If found, hasExpensiveItem becomes true, and a message about qualifying for VIP status is printed; otherwise, a message indicating no expensive items in the cart appears.

noneMatch() Method

The noneMatch() method checks whether none of the elements in a stream satisfy a given predicate. If no elements match the condition, the method returns true.

This method takes a predicate and applies it to each element in the stream. If no elements meet the condition, it returns true; otherwise, it returns false.

Practical Example

An online store does not allow items with a price below zero. You need to check if there are any such items in the cart.

Main


              1234567891011121314151617
            
package com.example;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> prices = List.of(1500, 2000, 3000, 0); // Item prices

        boolean noFreeItems = prices.stream().noneMatch(price -> price < 0);

        if (noFreeItems) {
            System.out.println("All items have valid prices.");
        } else {
            System.out.println("The cart contains an item with a zero price.");
        }
    }
}

In this example, noneMatch(price -> price < 0) checks if there are no items priced below $0. If all items have a valid price, a message confirming this is printed; otherwise, a message indicating the presence of an item with an invalid price appears.

1. Which method checks if at least one element in the stream satisfies a condition?

2. Which method should you use to ensure there are no values less than zero in a list?

Everything was clear?

Thanks for your feedback!

Section 3. Chapter 12