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

Bi-versions of Functional Interfaces

In Java, there are several bi-versions of functional interfaces that work with two arguments. These interfaces provide convenient templates for performing various operations with a pair of input data, whether it's computing a result, performing an action, or checking a condition.

They simplify handling complex scenarios where you need to work with two parameters at once.

For example, instead of writing bulky code with multiple nested calls, you can take advantage of concise interfaces that provide ready-made methods for implementing key functionalities.

BiFunction<T, U, R>

BiFunction is a functional interface that takes two input arguments of types T and U, and returns a result of type R.

BiFunction is ideal for tasks where two values need to be processed and a derived result is returned, such as computation, transformation, or data combination.

For example, if you need to calculate the total cost of items in stock by multiplying the quantity by the price per unit:

Main


              1234567891011121314151617
            
package com.example;

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
       // `BiFunction` to calculate total cost
       BiFunction<Integer, Double, Double> calculateTotalCost = (quantity, pricePerUnit) -> quantity * pricePerUnit;

       // Example usage
       int quantity = 50;
       double pricePerUnit = 19.99;
       double totalCost = calculateTotalCost.apply(quantity, pricePerUnit);

       System.out.println("Total cost: $" + totalCost);
    }
}

In this example, BiFunction<Integer, Double, Double> accepts two arguments: quantity and pricePerUnit (price per unit), and returns the result — the total cost as a Double value. The apply() method performs the specified operation, linking the functional interface with the multiplication logic.

BiConsumer<T, U>

BiConsumer is a functional interface that takes two arguments of types T and U, but does not return a result.

It is used for performing actions on two objects, such as logging, displaying information, or saving data.

For example, let's create a functional interface that accepts an employee's name and salary, formats the data, and prints it to the console:

Main


              1234567891011121314151617181920212223242526
            
package com.example;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class Main {
    public static void main(String[] args) {
        // `BiConsumer` for formatted output of employee details
        BiConsumer<String, Double> printEmployeeDetails = (name, salary) -> {
            System.out.printf("Employee: %-15s | Salary: $%.2f%n", name, salary);
        };

        // Collection of employees with their salaries
        Map<String, Double> employeeData = new HashMap<>();
        employeeData.put("John Smith", 75000.0);
        employeeData.put("Mary Johnson", 82000.0);
        employeeData.put("Robert Brown", 64000.0);
        employeeData.put("Emily Davis", 91000.0);

        // Print details of each employee
        System.out.println("Employee Salary Report:");
        System.out.println("-----------------------------------");
        employeeData.forEach(printEmployeeDetails);
    }
}

In this example, BiConsumer<String, Double> is used to process the employee's name and salary, printing the data to the console in a formatted way.

The forEach() method of the Map collection passes each key-value pair to the BiConsumer, which performs the specified action for all employees.

BiPredicate<T, U>

BiPredicate is a functional interface that takes two arguments of types T and U and returns a boolean result.

It is used for checking conditions where the result is a boolean value (true or false), based on the analysis of two input values.

For example, let's check whether the length of a string is greater than a given number:

Main


              1234567891011121314151617
            
package com.example;

import java.util.function.BiPredicate;

public class Main {
    public static void main(String[] args) {
        // `BiPredicate` to check if string length is greater than given number
        BiPredicate<String, Integer> isStringLongerThan = (str, length) -> str.length() > length;

        // Example usage
        String text = "Sample string";
        int minLength = 10;
        boolean result = isStringLongerThan.test(text, minLength);

        System.out.println("String is longer than " + minLength + " characters: " + result);
    }
}

In this example, BiPredicate<String, Integer> accepts two arguments: the string str and the number length, representing the minimum length. The test() method checks the condition, returning true if the string's length is greater than the specified number, or false otherwise.