Stream trong Java: giải thích filter, map, collect và reduce

Pipeline thay cho vòng lặp

Stream là một pipeline để xử lý một dãy giá trị. Bạn bắt đầu từ một nguồn, thường là một collection, nối các thao tác như "chỉ giữ những phần tử này", "biến đổi từng phần tử", "sắp xếp chúng", rồi kết thúc bằng việc gom kết quả lại. Thay vì viết một vòng lặp với một list tạm và một câu lệnh if bên trong, bạn mô tả điều mình muốn và để stream tự duyệt.

Khi đã có lambda, stream trở nên dễ hiểu: mọi thao tác đều nhận một lambda (hoặc method reference) mô tả việc cần làm với một phần tử.

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

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("Ada", "Boris", "Chen", "Dmitri");

        List<String> result = names.stream()
            .filter(name -> name.length() > 3)   // keep names longer than 3
            .map(String::toUpperCase)            // transform each one
            .collect(Collectors.toList());       // gather into a new list

        System.out.println(result);
    }
}

Hãy đọc từ trên xuống: lấy các tên, giữ những tên dài, viết hoa chúng, gom vào một list. List names ban đầu không hề bị sửa: stream tạo ra một kết quả mới và để nguyên nguồn.

Cấu tạo của một stream

Mỗi pipeline có ba phần:

• Một nguồn: list.stream(), Arrays.stream(array) hoặc Stream.of(a, b, c).
• Không hoặc nhiều thao tác trung gian: filter, map, sorted, distinct, limit. Mỗi thao tác trả về một stream khác, nên bạn có thể nối chúng lại.
• Đúng một thao tác cuối: collect, count, forEach, reduce, findFirst. Thao tác này khởi động công việc và tạo ra một kết quả (hoặc một tác dụng phụ).

Việc phân chia này quan trọng vì một quy tắc lúc đầu khiến ai cũng bất ngờ.

Thao tác trung gian là lười

Thao tác trung gian tự nó không làm gì cả. Chúng chỉ ghi lại những gì sẽ xảy ra. Pipeline chỉ chạy khi một thao tác cuối yêu cầu kết quả.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            });
        // No terminal operation -> nothing prints.

        System.out.println("Done, but nothing was mapped.");
    }
}

Chạy thử: lambda của map không bao giờ được thực thi. Thêm một thao tác cuối và cả chuỗi bừng tỉnh:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        List<Integer> doubled = nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            })
            .collect(Collectors.toList());   // terminal -> now it runs

        System.out.println(doubled);
    }
}

Tính lười này không phải điểm kỳ quặc cần chống lại: nó cho phép stream gộp các thao tác và bỏ qua việc không cần thiết. Nhưng nó có nghĩa là một pipeline không có thao tác cuối thì chẳng làm gì, và đây là một bug "sao chẳng có gì xảy ra?" rất phổ biến.

filter và map: giữ lại và biến đổi

Hai thao tác này gánh phần lớn công việc. filter nhận một Predicate (một lambda trả về boolean) và giữ lại các phần tử thỏa mãn. map nhận một Function và thay mỗi phần tử bằng kết quả khi áp dụng hàm đó.

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

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "fig", "banana", "kiwi", "cherry");

        List<Integer> lengths = words.stream()
            .filter(w -> w.length() > 3)   // drop "fig" and "kiwi"
            .map(String::length)           // turn each word into its length
            .collect(Collectors.toList());

        System.out.println(lengths);   // [5, 6, 6]
    }
}

Lưu ý rằng map có thể đổi kiểu phần tử: ở đây một stream String trở thành một stream Integer. String::length là một method reference, cách viết tắt của lambda w -> w.length().

Thao tác cuối tạo ra kết quả

Khi đã định hình xong stream, một thao tác cuối biến nó thành thứ cụ thể:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(3, 1, 4, 1, 5, 9, 2, 6);

        long bigCount = nums.stream()
            .filter(n -> n > 3)
            .count();                       // how many passed?

        boolean anyEven = nums.stream()
            .anyMatch(n -> n % 2 == 0);     // is at least one even?

        System.out.println("Big numbers: " + bigCount);
        System.out.println("Any even? " + anyEven);
    }
}

Các thao tác cuối thường gặp: collect (gom vào list/set/map), count, forEach, anyMatch / allMatch / noneMatch, findFirst, min / max và reduce. Sau khi một thao tác cuối chạy, stream đã bị tiêu thụ: bạn không thể dùng lại nó. Gọi lại list.stream() để có một pipeline mới.

Gom kết quả

collect cùng với Collectors là công cụ chủ lực để tạo kết quả. Phổ biến nhất là Collectors.toList():

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

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("ada", "boris", "chen");

        // Join into one string
        String joined = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.joining(", "));

        System.out.println(joined);   // ADA, BORIS, CHEN
    }
}

Collectors còn cung cấp toSet(), joining(...), groupingBy(...) và counting(). Từ Java 16 trở đi, bạn có thể thay collect(Collectors.toList()) bằng .toList() ngắn hơn (nó trả về một list không sửa được):

List<String> result = names.stream().map(String::toUpperCase).toList();

sorted, distinct và limit

Các thao tác trung gian này định hình lại stream trước khi bạn gom kết quả:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(5, 3, 8, 3, 1, 9, 5, 2);

        List<Integer> top3 = nums.stream()
            .distinct()                 // drop duplicates
            .sorted((a, b) -> b - a)    // descending
            .limit(3)                   // take the first three
            .collect(Collectors.toList());

        System.out.println(top3);   // [9, 8, 5]
    }
}

sorted() không đối số dùng thứ tự tự nhiên; truyền vào một Comparator (ở đây là một lambda) để có thứ tự tùy chỉnh. Comparator.reverseOrder() là cách gọn hơn để sắp xếp giảm dần.

reduce: gộp stream thành một giá trị

Khi bạn cần kết hợp mọi phần tử thành một kết quả duy nhất, như tổng, tích, chuỗi dài nhất, reduce là công cụ tổng quát. Bạn đưa cho nó một giá trị khởi đầu và một hàm gộp hai giá trị:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(2, 4, 6, 8);

        int sum = nums.stream()
            .reduce(0, (a, b) -> a + b);   // start at 0, keep adding

        int product = nums.stream()
            .reduce(1, (a, b) -> a * b);   // start at 1, keep multiplying

        System.out.println("Sum: " + sum);
        System.out.println("Product: " + product);
    }
}

Với tổng và trung bình đơn giản, các stream chuyên biệt rõ ràng hơn: nums.stream().mapToInt(Integer::intValue).sum(). Hãy dùng reduce khi không có sẵn bộ tổng hợp nào phù hợp.

Stream không thay thế mọi vòng lặp

Stream phát huy sức mạnh khi bạn biến đổi một collection thành một kết quả. Chúng không tự động nhanh hơn vòng lặp, và khá vụng về khi bạn cần thay đổi trạng thái bên ngoài hoặc thoát sớm theo những cách rắc rối. Một quy tắc hay: nếu pipeline đọc lên như một câu rõ ràng, hãy dùng stream; nếu bạn đang cần một biến đếm dùng chung hay một index, một vòng lặp for thông thường là thẳng thắn và hoàn toàn ổn.

Cũng nhớ rằng stream chỉ dùng được một lần. Thao tác trên nó hai lần sẽ ném ra ngoại lệ:

Stream<String> s = names.stream();
s.forEach(System.out::println);
s.count();   // IllegalStateException: stream has already been operated upon

Tiếp theo: Optional

Một số thao tác cuối của stream, như findFirst, min, max, reduce không có giá trị khởi đầu, có thể không tìm thấy gì, nên chúng không trả về một giá trị trần. Chúng trả về một Optional, kiểu chứa của Java cho "có thể có giá trị, có thể không có gì", cuối cùng cho bạn một lựa chọn gọn gàng thay cho việc trả về null. Đó là nội dung của trang tiếp theo.