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

Consumer: Processing Data

You've already explored many functional interfaces in Java, but what if you need to perform an operation that takes an argument, applies some changes, or produces a side effect—without returning a result? This is where the Consumer functional interface comes in.

Consumer Interface

It is commonly used for performing actions that modify state or produce side effects without returning a value.

The Consumer interface is part of the java.util.function package and is defined as follows:

The accept(T t) method takes an object of type T as input and performs an operation on it without returning a result.

Practical Application

Let's say you have a list of strings, and for each string, you need to print it along with a unique id, separated by a space. You can achieve this using the Consumer interface by passing each string along with its index (id).

Main


              12345678910111213141516171819
            
package com.example;

import java.util.List;
import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
       List<String> names = List.of("Alice", "Bob", "Charlie");

       // Creating a `Consumer` that prints each string with its id
       Consumer<String> printNameWithId = (name) -> {
          int id = names.indexOf(name) + 1;  // id = index + 1
          System.out.println(id + " " + name);
       };

       // Using `Consumer` to print each string with its id
       names.forEach(printNameWithId);
    }
}

In this example, you use Consumer to print each string from the list with a unique identifier. The id for each element is calculated using its index in the list, and the result is printed in the format "id string". This allows us to process list elements without explicitly using a loop.

You can also simplify our code by writing the lambda expression directly inside the forEach loop:

Main


              123456789101112
            
package com.example;

import java.util.List;

public class Main {
    public static void main(String[] args) {
       List<String> names = List.of("Alice", "Bob", "Charlie");

       // Using `forEach` with a lambda expression to print the ID and name
       names.forEach(name -> System.out.println((names.indexOf(name) + 1) + " " + name));
    }
}

As you can see, the result remains the same, with the code becoming more concise and easier to read.

Using Default Method

The Consumer interface also includes a default method that enables combining multiple operations.

The andThen() method allows you to chain two Consumer operations together. The first Consumer runs first, followed by the second one.

For example, imagine you have a list of names, and you want to perform two tasks: printing each name in uppercase and then printing the length of that name. By using andThen(), you can combine both operations into a single Consumer that applies them sequentially.

Main


              12345678910111213141516171819202122
            
package com.example;

import java.util.List;
import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
       List<String> names = List.of("Alice", "Bob", "Charlie");

       // First `Consumer` — prints the name in uppercase
       Consumer<String> printUpperCase = name -> System.out.print(name.toUpperCase() + " - ");

       // Second `Consumer` — prints the length of the name
       Consumer<String> printLength = name -> System.out.println(name.length());

       // Combine both `Consumers` using `andThen()`
       Consumer<String> combinedConsumer = printUpperCase.andThen(printLength);

       // Apply the combined `Consumer` to each name
       names.forEach(combinedConsumer);
    }
}

In this example, you first print the name in uppercase, followed by a dash and the name's length. You use andThen() to combine two Consumer operations so that the first prints the name, and the second prints its length.

1. What does the `andThen()` method in the `Consumer` interface do?

2. What type of data does the accept method in the `Consumer` interface take?

Everything was clear?

Thanks for your feedback!

Section 1. Chapter 11

Stream API

Consumer: Processing Data

Consumer Interface

Practical Application

Using Default Method

1. What does the andThen() method in the Consumer interface do?

2. What type of data does the accept method in the Consumer interface take?

1. What does the `andThen()` method in the `Consumer` interface do?

2. What type of data does the accept method in the `Consumer` interface take?