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

Function: Data Transformation

While Predicate helps us evaluate boolean expressions, Function allows us to transform data by applying operations that return results based on the input.

Function is commonly used for data transformation, such as type conversion, calculations, or value processing.

The Function<T, R> interface in Java represents a functional interface that takes an argument of type T and returns a result of type R.

The apply(T t) method performs the data transformation by taking the input value and returning the result. This allows for creating flexible functions to process data of various types.

Practical Application

Let's say you have a list of user names, and you need to calculate the length of each name for further analysis or data processing.

Main


              1234567891011121314151617
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

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

        Function<String, Integer> nameLength = name -> name.length();

        users.forEach(user -> {
            System.out.println(user + " has " + nameLength.apply(user) + " characters.");
        });
    }
}

In this example, you have a list of user names. For each name, you use the nameLength function, which calculates the number of characters in the name using the length() method. Using the forEach method, you iterate over each element of the list and print a message showing how many characters each name contains.

Combining Functions

The Function interface provides several methods for combining functions, allowing you to create a chain of operations.

Method andThen()

The andThen() method allows you to combine two functions by applying one function first, then passing the result to the second function. This is useful when you need to perform multiple operations in sequence.

Example

You have a list of user names, and you need to capitalize the first letter of each name and then check if the name has more than 5 characters.

Main


              1234567891011121314151617181920212223
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> usernames = Arrays.asList("john", "alice", "bob", "charlie", "david");

        // Capitalize first letter
        Function<String, String> capitalizeFirstLetter = name -> name.substring(0, 1).toUpperCase() + name.substring(1);
        // Check if the username has more than 5 characters
        Function<String, Boolean> isLongerThanFive = name -> name.length() > 5;

        // Combine functions using `andThen()`
        Function<String, Boolean> formattedNameThenCheckLength = capitalizeFirstLetter.andThen(isLongerThanFive);

        usernames.forEach(user -> {
            System.out.println(user + " -> " + formattedNameThenCheckLength.apply(user));
        });
    }
}

You first capitalize the first letter of each username using capitalizeFirstLetter. Then, you check if the formatted username has more than 5 characters using isLongerThanFive. The two functions are combined using andThen() for sequential processing.

Method compose()

The compose() method allows you to combine functions, but in the reverse order: the second function is applied first, and the result is then passed into the first function.

Example

You have a string, and you want to first calculate its length and then prepend a prefix to the result.

Main


              123456789101112131415161718
            
package com.example;

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        String phrase = "Hello World";

        // First, calculate the length, then add a prefix
        Function<String, Integer> stringLength = String::length;
        Function<Integer, String> addPrefix = length -> "Length: " + length;

        // Combine functions using compose
        Function<String, String> lengthThenPrefix = addPrefix.compose(stringLength);

        System.out.println(lengthThenPrefix.apply(phrase));  // Output: Length: 11
    }
}

In this example, you first calculate the length of the string using stringLength, and then the result is passed to the addPrefix function, which prepends a prefix. You use compose() to apply the functions in the desired order.

Method identity()

The identity() method returns a function that simply returns its argument without any modifications. This is useful when you need to pass a function that doesn't change the input value but is required to comply with the interface.

Example

Imagine you need to process a list of usernames by applying several transformations: one to convert the names to uppercase, another to add the "User" suffix, and a third using the identity() function to leave the name unchanged. The task is to apply these functions to each name in the list while keeping the program's interface consistent for each transformation.

Main


              1234567891011121314151617181920212223242526272829303132
            
package com.example;

import java.util.List;
import java.util.Arrays;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> usernames = Arrays.asList("alice", "bob", "charlie", "david", "eve");

        // `Function` to convert the username to uppercase
        Function<String, String> uppercaseFunction = name -> name.toUpperCase();

        // `Function` to add the "User" suffix
        Function<String, String> suffixFunction = name -> name + "User";

        // Identity `Function`, which does nothing
        Function<String, String> identityFunction = Function.identity();

        // Applying a combination of functions
        List<Function<String, ?>> transformations = Arrays.asList(uppercaseFunction, suffixFunction, identityFunction);

        // Applying each `Function` from the list
        for (Function<String, ?> transformation : transformations) {
            System.out.println("--------------------");

            usernames.stream()
                .map(name -> transformation.apply(name))
                .forEach(System.out::println);
        }
    }
}

As you can see, the output consists of three formatted lists of usernames. The last list contains the original names, which is where the identity() method comes in handy, as it allows us to return the names without adding extra logic for handling the unchanged values. This makes the code cleaner and more efficient by directly using identity() when no transformation is needed.