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

Intermediate Processing with the peek() Method

The peek() method allows us to insert logging at the processing stage without altering the data stream, and then proceed with operations on elements that pass the necessary filtering.

This method accepts an object implementing the Consumer interface, which performs an operation on each stream element.

Practical Example

A factory needs to inspect products to ensure their names start with "product-" and match a specific pattern. At the same time, you want to log all products in the list. Valid products should be collected into a list and printed to the console.

Main


              123456789101112131415161718192021
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        List<String> items = Arrays.asList("product-H31KD", "product-A12ZX", "item-X99KD", "product-B67QF", "product-12345", "invalidData");

        // Example of using peek for logging and collecting filtered elements into a new list
        List<String> validProducts = items.stream()
                .peek(item -> System.out.println("Checking item: " + item))
                .filter(item -> item.startsWith("product-"))
                .toList();  // Collecting filtered elements into a list

        // Printing the list of validated products
        System.out.println("List of validated products: " + validProducts);
    }
}

The code filters elements from the items list, keeping only those that start with "product-". The peek() method logs each checked element, and the valid products are collected into a list and printed to the console.

Everything was clear?

Thanks for your feedback!

Section 2. Chapter 11