Stream Java: Penjelasan filter, map, collect, dan reduce

Pipeline Sebagai Pengganti Loop

Stream adalah pipeline untuk mengolah urutan nilai. Kamu mulai dari sebuah sumber, biasanya collection, merangkai operasi seperti "simpan yang ini saja", "ubah masing-masing", "urutkan", lalu mengakhirinya dengan mengumpulkan hasilnya. Daripada menulis loop dengan list sementara dan if di dalamnya, kamu menjelaskan apa yang kamu mau, lalu stream yang menelusuri elemennya.

Setelah kamu mengenal lambda, stream jadi mudah dipahami: setiap operasi menerima lambda (atau method reference) yang menjelaskan pekerjaan untuk satu elemen.

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);
    }
}

Baca dari atas ke bawah: ambil nama-namanya, simpan yang panjang, jadikan huruf besar, kumpulkan ke list. List names yang asli tidak pernah diubah; stream menghasilkan hasil baru dan membiarkan sumbernya apa adanya.

Anatomi Stream

Setiap pipeline punya tiga bagian:

• Sumber: list.stream(), Arrays.stream(array), atau Stream.of(a, b, c).
• Nol atau lebih operasi intermediate: filter, map, sorted, distinct, limit. Masing-masing mengembalikan stream lain, jadi kamu bisa merangkainya.
• Tepat satu operasi terminal: collect, count, forEach, reduce, findFirst. Operasi ini memulai pekerjaannya dan menghasilkan sebuah hasil (atau efek samping).

Pembagian ini penting karena ada satu aturan yang awalnya mengejutkan semua orang.

Operasi Intermediate Bersifat Lazy

Operasi intermediate tidak melakukan apa pun dengan sendirinya. Operasi itu hanya mencatat apa yang seharusnya terjadi. Pipeline baru berjalan saat operasi terminal meminta hasil.

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.");
    }
}

Jalankan kodenya: lambda map tidak pernah dieksekusi. Tambahkan operasi terminal, dan seluruh rangkaian langsung hidup:

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);
    }
}

Sifat lazy ini bukan keanehan yang perlu dilawan. Justru sifat ini membuat stream bisa menggabungkan operasi dan melewati pekerjaan yang tidak dibutuhkan. Tapi artinya, pipeline tanpa operasi terminal tidak melakukan apa-apa, dan itu bug "kenapa tidak terjadi apa-apa?" yang sering muncul.

filter dan map: Menyimpan dan Mengubah

Dua operasi ini memikul sebagian besar pekerjaan. filter menerima Predicate (lambda yang mengembalikan boolean) dan menyimpan elemen yang lolos. map menerima Function dan mengganti setiap elemen dengan hasil penerapan fungsi itu.

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]
    }
}

Perhatikan bahwa map bisa mengubah tipe elemen: di sini stream berisi String menjadi stream berisi Integer. String::length adalah method reference, bentuk singkat dari lambda w -> w.length().

Operasi Terminal Menghasilkan Hasil

Setelah stream dibentuk, operasi terminal mengubahnya menjadi sesuatu yang konkret:

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);
    }
}

Operasi terminal yang umum: collect (mengumpulkan ke list/set/map), count, forEach, anyMatch / allMatch / noneMatch, findFirst, min / max, dan reduce. Setelah operasi terminal berjalan, stream itu sudah terpakai, jadi kamu tidak bisa memakainya ulang. Panggil list.stream() lagi untuk pipeline yang baru.

Mengumpulkan Hasil

collect dengan Collectors adalah andalan untuk membangun hasil. Yang paling umum adalah 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 juga menyediakan toSet(), joining(...), groupingBy(...), dan counting(). Di Java 16 ke atas, kamu bisa mengganti collect(Collectors.toList()) dengan .toList() yang lebih pendek (hasilnya list yang tidak bisa diubah):

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

sorted, distinct, dan limit

Operasi intermediate ini membentuk ulang stream sebelum kamu mengumpulkannya:

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() tanpa argumen memakai urutan alami; berikan Comparator (di sini sebuah lambda) untuk urutan kustom. Comparator.reverseOrder() adalah cara yang lebih rapi untuk mengurutkan secara menurun.

reduce: Melipat Stream Menjadi Satu Nilai

Kalau kamu perlu menggabungkan semua elemen menjadi satu hasil, misalnya jumlah, hasil kali, atau string terpanjang, reduce adalah alat umumnya. Kamu memberinya nilai awal dan fungsi yang menggabungkan dua nilai:

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);
    }
}

Untuk penjumlahan dan rata-rata biasa, stream khusus lebih jelas: nums.stream().mapToInt(Integer::intValue).sum(). Pakai reduce kalau tidak ada fungsi agregasi yang sudah tersedia.

Stream Tidak Menggantikan Setiap Loop

Stream unggul saat kamu mengubah collection menjadi sebuah hasil. Stream tidak otomatis lebih cepat daripada loop, dan terasa canggung kalau kamu perlu mengubah state di luar atau keluar lebih awal dengan cara yang rumit. Pedoman yang baik: kalau pipeline-nya terbaca sebagai satu kalimat yang jelas, pakai stream; kalau kamu butuh counter bersama atau index, for loop biasa itu jujur dan tidak masalah.

Ingat juga bahwa stream hanya bisa dipakai sekali. Mengoperasikannya dua kali akan melempar exception:

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

Berikutnya: Optional

Beberapa operasi terminal stream, seperti findFirst, min, max, dan reduce tanpa nilai identitas, mungkin tidak menemukan apa-apa, jadi operasi itu tidak mengembalikan nilai mentah. Hasilnya adalah Optional, wadah Java untuk "mungkin ada nilai, mungkin tidak ada", yang akhirnya memberimu alternatif yang rapi selain mengembalikan null. Itu topik halaman berikutnya.