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

Supplier: Data Generation

Here's how the Supplier functional interface is implemented:

The key responsibility of the get() method is to return an object of type T without taking any parameters.

Practical Use of Supplier

Supplier is often used in situations where data needs to be generated on demand. This can be useful for lazy initialization, generating random values, or retrieving values from an external source.

Let's create a system that generates random passwords. Using the Supplier functional interface, you can easily organize password generation on request.

Main


              123456789101112131415161718192021222324
            
package com.example;

import java.util.Random;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
       // Supplier for generating random passwords
       Supplier<String> passwordSupplier = () -> {
          String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()";
          StringBuilder password = new StringBuilder();
          Random random = new Random();
          for (int i = 0; i < 12; i++) {
             int index = random.nextInt(characters.length());
             password.append(characters.charAt(index));
          }
          return password.toString();
       };

       // Generate and print the random password
       String generatedPassword = passwordSupplier.get();
       System.out.println("Generated password: " + generatedPassword);
    }
}

You create a Supplier that generates a random password of 12 characters. The lambda expression inside the Supplier uses the Random class to select random characters from a string.

The get() method triggers this password generation logic only when needed, enabling lazy generation of values.

Lazy Generation

Initially, you create the Supplier, but the code inside it doesn't execute immediately. This is an important feature. Instead of executing some logic right away (e.g., generating a password), you simply record it inside the Supplier as an instruction to be executed later when required.

Here, the code inside the Supplier (password generation) doesn't execute immediately. Instead, you're saying, "When someone asks, this is how you'll generate the password." Now, when you call get() on this Supplier:

Only then does the code inside the Supplier execute, and the password is generated. This is lazy execution.