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

Eliminating Duplicates with the distinct() Method

In real-world development, you often encounter situations where data contains duplicates that need to be removed. For example, imagine you're compiling a list of conference attendees, but due to system errors, some names have been recorded twice.

The distinct() method helps solve this problem by eliminating duplicate elements from a stream.

This method returns a stream containing only unique elements, filtering out any duplicates.

How It Works

The distinct() method relies on hashCode() to quickly detect potential duplicates and equals() to confirm whether they are truly identical. If two objects have different hash codes, they are considered unique. If the hash codes match, equals() is called to verify their equality based on specific criteria.

Together, these methods form the hashCode() and equals() contract, ensuring proper comparison and duplicate removal.

Instead of writing them manually, IntelliJ IDEA allows us to generate them automatically.

In IntelliJ IDEA, you opened the code generation menu (Alt + Insert on Windows/Linux, Cmd + N on Mac) and selected equals() and hashCode(). After choosing the fields to include in the comparison, IDEA automatically generated the necessary methods.

Practical Example

A factory keeps track of produced parts, but the report contains duplicates as well as defective parts labeled DEFECT. The goal is to clean the list, keeping only unique, non-defective parts, sort them by name, and display them in the format: Name - Serial Number.

Main


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<Part> parts = List.of(
                new Part("SN001", "Gear"),
                new Part("SN002", "Bolt"),
                new Part("SN003", "Nut"),
                new Part("SN001", "Gear"),
                new Part("SN004", "DEFECT Shaft"),
                new Part("SN005", "Screw"),
                new Part("SN002", "Bolt"),
                new Part("SN006", "DEFECT Washer")
        );

        List<String> processedParts = parts.stream()
                .distinct()
                .filter(part -> !part.getName().contains("DEFECT"))
                .sorted((p1, p2) -> p1.getName().compareToIgnoreCase(p2.getName()))
                .map(part -> part.getName() + " - " + part.getSerialNumber())
                .toList();

        System.out.println(processedParts);
    }
}

class Part {
    private String serialNumber;
    private String name;

    public Part(String serialNumber, String name) {
        this.serialNumber = serialNumber;
        this.name = name;
    }

    public String getSerialNumber() {
        return serialNumber;
    }

    public String getName() {
        return name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Part)) return false;
        Part part = (Part) o;
        return serialNumber.equals(part.serialNumber);
    }

    @Override
    public int hashCode() {
        return serialNumber.hashCode();
    }

    @Override
    public String toString() {
        return name + " - " + serialNumber;
    }
}

To remove duplicates and filter out defective parts, the equals() and hashCode() methods must be correctly implemented to compare parts by serial number.

After that, you use distinct() to eliminate duplicates, filter() to remove defective parts containing DEFECT in their name, sorted() to order the remaining parts, and map() to format them as strings.

1. What is used to compare elements in the `distinct()` method?

2. If two objects have the same `hashCode()`, but their `equals()` method returns false, will they be considered the same in the `distinct()` method?

Everything was clear?

Thanks for your feedback!

Section 2. Chapter 7