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

Retrieving Stream Summary Metrics with summaryStatistics() Method

When processing data, it's often necessary to calculate statistical metrics such as sum, average, minimum, maximum, and element count.

You've already learned how to find the minimum and maximum values in a stream, but there's a method that gathers all these statistics at once. The Java Stream API provides a dedicated method called summaryStatistics(), which simplifies retrieving overall statistics from numeric streams.

Method summaryStatistics()

Stream API also provides specialized numeric streams: IntStream, LongStream, and DoubleStream. These work just like regular streams but are optimized for specific primitive types.

Each of these numeric streams includes a summaryStatistics() method, which returns an instance of IntSummaryStatistics, LongSummaryStatistics, or DoubleSummaryStatistics, respectively. These objects contain key statistical metrics, such as count, sum, min, max, and average.

By calling summaryStatistics() on a numeric stream, you can quickly gather and analyze statistical data about its values.

Key Methods

In Java, the IntSummaryStatistics, LongSummaryStatistics, and DoubleSummaryStatistics classes are used to collect statistics on numeric data. They provide a set of methods for extracting key statistical metrics.

Practical Example

In an online store, you need to analyze product prices to determine the minimum and maximum prices, the average price, and the total number of items.

Main


              1234567891011121314151617181920
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<Integer> prices = List.of(1500, 2000, 3500, 1200, 4000, 2500);

        IntSummaryStatistics stats = prices.stream()
                .collect(Collectors.summarizingInt(Integer::intValue));

        System.out.println("Minimum price: " + stats.getMin());
        System.out.println("Maximum price: " + stats.getMax());
        System.out.println("Average price: " + stats.getAverage());
        System.out.println("Total number of items: " + stats.getCount());
        System.out.println("Total sum: " + stats.getSum());
    }
}

In this code, you create a list of product prices and convert it into a numeric stream. The Collectors.summarizingInt(Integer::intValue) method gathers statistical data and stores it in an IntSummaryStatistics object. You then use the methods getMin(), getMax(), getAverage(), getCount(), and getSum() to extract the necessary values.

Additional Methods

The combine() method merges two statistics objects. This is useful when processing data in multiple threads or when consolidating statistics from different sources.

The accept() method manually adds values to a statistics object, which is helpful for dynamically updating data.

Main


              1234567891011121314151617181920212223
            
package com.example;

import java.util.IntSummaryStatistics;

public class Main {
    public static void main(String[] args) {
        IntSummaryStatistics stats1 = new IntSummaryStatistics();
        stats1.accept(1500);
        stats1.accept(2500);

        IntSummaryStatistics stats2 = new IntSummaryStatistics();
        stats2.accept(3500);
        stats2.accept(4500);

        stats1.combine(stats2);

        System.out.println("Minimum price: " + stats1.getMin());
        System.out.println("Maximum price: " + stats1.getMax());
        System.out.println("Average price: " + stats1.getAverage());
        System.out.println("Total number of items: " + stats1.getCount());
        System.out.println("Total sum: " + stats1.getSum());
    }
}

In this example, you create two IntSummaryStatistics objects, each containing values added using the accept() method. The combine() method then merges the statistics from both objects, updating the total count, sum, and min/max values.