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

Comparable: Natural Ordering of Data

In Java, it's common to need to sort objects. For example, in a list of books, you might want to sort them by title, author, or publication year.

To handle such tasks, Java provides the Comparable and Comparator interfaces. Both achieve the same goal (sorting objects) but they do so in different ways. Let's break them down one by one.

What Is Comparable?

For example, Java strings are sorted alphabetically by default because the String class implements Comparable.

The key method in the Comparable functional interface is:

This method returns:

A negative number if the current object is less than the given object;
Zero if the objects are equal;
A positive number if the current object is greater than the given object.

Example: Sorting Books by Year

Let's say you want to compare Book objects based on their publication year.

To achieve this, the Book class can implement Comparable and override the compareTo method. By overriding this method, you define how Book objects should be compared, which directly affects the sorting behavior in methods like Collections.sort().

This allows us to control the order in which books are sorted—whether ascending or descending—based on the logic you implement in compareTo.

Main


              1234567891011121314151617181920212223242526272829303132333435363738394041424344
            
package com.example;

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        List<Book> books = new ArrayList<>();
        books.add(new Book("Book A", "Author X", 2020));
        books.add(new Book("Book B", "Author Y", 2018));
        books.add(new Book("Book C", "Author Z", 2021));

        Collections.sort(books); // Uses `compareTo`

        System.out.println(books);
    }
}

class Book implements Comparable<Book> {
    private String title;
    private String author;
    private int year;

    public Book(String title, String author, int year) {
        this.title = title;
        this.author = author;
        this.year = year;
    }

    public int getYear() {
        return year;
    }

    @Override
    public int compareTo(Book other) {
        return Integer.compare(this.year, other.year); // Compare by publication year
    }

    @Override
    public String toString() {
        return title + " (" + year + ")";
    }
}

When Collections.sort(books) is called, Java iterates through the list, comparing elements using the compareTo method defined in the Book class.

For each comparison, compareTo returns a numeric value that determines the order of two books. Based on these values, the sorting algorithm rearranges the elements so they are ordered by ascending publication year.

Everything was clear?

Thanks for your feedback!

Section 1. Chapter 8