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

Restricting and Skipping Elements with the limit() and skip() Methods

The Java Stream API provides convenient methods for working with collections of data. Two useful methods, limit() and skip(), allow you to control how many elements are processed in a stream or skip a certain number of elements, which can be helpful for optimizing performance when dealing with large datasets.

What Are These Methods?

Main


              1234567891011121314151617181920
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> products = Arrays.asList(
                "Item 1", "Item 2", "Item 3", "Item 4", "Item 5",
                "Item 6", "Item 7", "Item 8", "Item 9", "Item 10",
                "Item 11", "Item 12"
        );

        // Limit processing to the first 10 items
        products.stream()
                .limit(10)
                .forEach(System.out::println); // Output: Item 1, Item 2, ..., Item 10
    }
}

In this example, you use limit(10) to restrict the stream to the first 10 elements, ensuring that only those items are processed.

Main


              1234567891011121314151617181920
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> products = Arrays.asList(
                "Item 1", "Item 2", "Item 3", "Item 4", "Item 5",
                "Item 6", "Item 7", "Item 8", "Item 9", "Item 10",
                "Item 11", "Item 12"
        );

        // Skip the first 5 items and process the rest
        products.stream()
                .skip(5)  // Skips the first 5 items
                .forEach(System.out::println); // Output: Item 6, Item 7, ..., Item 12
    }
}

Here, you use skip(5) to ignore the first five items and start processing from the sixth item onward.

Real-World Example

Imagine you work at a factory with a list of 50 parts that need inspection. You only need to check the first 10 parts while another specialist handles the rest. In this case, you can use limit(10).

If the first 20 parts have already been inspected and you need to start from part 21, you can use skip(20).

Now, let's implement this scenario in code.

Practical Application

At a factory, you need to process parts. You have a list of 50 parts and need to skip the first 20, then process the next 10.

Main


              12345678910111213141516171819202122232425262728293031323334353637
            
package com.example;

import java.util.UUID;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // Supplier for generating parts
        Supplier<Part> partSupplier = () -> new Part(
                (int) (Math.random() * 1000),
                "Part-" + UUID.randomUUID()
        );

        // Create a stream of 50 parts, skip the first 20, and process the next 10
        Stream.generate(partSupplier)
                .limit(50)  // Limit the stream to 50 parts
                .skip(20)   // Skip the first 20
                .limit(10)  // Process the next 10
                .forEach(System.out::println);  // Print the parts
    }
}

class Part {
    private int id;
    private String name;

    Part(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Part{id=" + id + ", name='" + name + "'}";
    }
}

In this code, you use a Supplier to dynamically create Part objects. The UUID library helps generate unique identifiers for each part.

Using Stream.generate(partSupplier), which takes our Supplier, you create a stream of parts that keeps generating elements until you limit it with limit(50).

Next, skip(20) ensures the first 20 parts are ignored, while limit(10) processes only the next 10 parts.

This approach allows efficient data generation and processing without needing to store the entire list in memory.

1. What does the `limit(n)` method do in a stream?

2. Which interface is used to generate elements in a stream with `Stream.generate()`?

3. Which method skips the first `n` elements in a stream?

Everything was clear?

Thanks for your feedback!

Section 2. Chapter 9

Stream API

Restricting and Skipping Elements with the limit() and skip() Methods

What Are These Methods?

Real-World Example

Practical Application

1. What does the limit(n) method do in a stream?

2. Which interface is used to generate elements in a stream with Stream.generate()?

3. Which method skips the first n elements in a stream?

1. What does the `limit(n)` method do in a stream?

2. Which interface is used to generate elements in a stream with `Stream.generate()`?

3. Which method skips the first `n` elements in a stream?