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

Retrieving Elements from a Stream with findFirst() and findAny()

In Stream API, you can also extract just one matching element from the entire stream.

For example, in an online store, you might look for the first discounted product or any item in stock. In such cases, the findFirst and findAny methods are useful because they allow you to quickly extract an element from a data stream.

The findFirst() Method

The findFirst() method is used to retrieve the first element in a stream. This is especially useful when the order of elements matters, such as when working with an ordered stream.

This method returns an Optional<T>, meaning the element may or may not be found.

Example Usage

In an online store, you need to find the first discounted product and print its name:

Main


              12345678910111213141516171819202122232425262728293031323334353637383940
            
package com.example;

import java.util.List;
import java.util.Optional;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        List<Product> products = Arrays.asList(
                new Product("Laptop", false),
                new Product("Smartphone", true),
                new Product("Tablet", true)
        );

        Optional<Product> discountedProduct = products.parallelStream()
                .filter(Product::hasDiscount)
                .findFirst();

        discountedProduct.ifPresent(product ->
                System.out.println("Discounted product: " + product.getName()));
    }
}

class Product {
    private String name;
    private boolean discount;

    public Product(String name, boolean discount) {
        this.name = name;
        this.discount = discount;
    }

    public boolean hasDiscount() {
        return discount;
    }

    public String getName() {
        return name;
    }
}

The code creates a list of Product objects, each with a discount field. The filter(Product::hasDiscount) method selects only discounted products, and findFirst() retrieves the first one. If a product is found, its name is printed.

The findAny() Method

The findAny() method retrieves any element from a stream. It is particularly useful in parallel processing since it can return the first available element, making it faster than findFirst() in some cases.

Like findFirst(), this method returns an Optional<T>, helping to avoid issues with null.

Example Usage

Let's find any available product and print its name:

Main


              123456789101112131415161718192021222324252627282930313233343536373839404142
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<Product> products = Arrays.asList(
                new Product("Laptop", false),
                new Product("Smartphone", true),
                new Product("Tablet", true)
        );

        Optional<Product> availableProduct = products.parallelStream()
                .filter(Product::hasDiscount)
                .findAny();

        availableProduct.ifPresent(product ->
                System.out.println("Product found: " + product.getName()));
    }
}

class Product {
    private String name;
    private boolean discount;

    public Product(String name, boolean discount) {
        this.name = name;
        this.discount = discount;
    }

    public boolean hasDiscount() {
        return discount;
    }

    public String getName() {
        return name;
    }
}

This code creates a products list containing Product objects with a discount field. The filter(Product::hasDiscount) method filters out only discounted products, and findAny() selects a random one. If a product is found, its name is printed.