Lambda Expression Java: Kode Fungsional yang Ringkas

Perilaku yang Bisa Dioper

Lambda expression adalah blok kode ringkas yang bisa kamu berikan ke sebuah method, simpan di variabel, atau kembalikan, sama seperti angka atau string. Sebelum ada lambda, mengoper perilaku berarti menulis class utuh (atau anonymous class yang bertele-tele) hanya untuk membungkus satu method. Lambda memeras semua itu sampai ke intinya: parameter dan body-nya.

Lambda selalu mengimplementasikan functional interface, yaitu interface yang punya tepat satu abstract method (kamu sudah mengenalnya di akhir halaman interface). Compiler mengetahui interface mana yang kamu maksud dari konteksnya, lalu mencocokkan lambda-mu dengan satu method itu.

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;       // implements apply(int)
        Transformer square  = x -> x * x;

        System.out.println(doubler.apply(21));  // 42
        System.out.println(square.apply(9));     // 81
    }
}

x -> x * 2 adalah seluruh implementasi apply. Tidak ada new, tidak ada body class, tidak ada nama method: semua itu sudah disediakan oleh interface-nya.

Sintaks Panah

Setiap lambda berbentuk parameters -> body. Bagian-bagiannya bisa menyesuaikan dengan kebutuhanmu:

() -> 42                       // no parameters
x -> x + 1                     // one parameter, parentheses optional
(x, y) -> x + y                // two or more parameters need parentheses
(int x, int y) -> x + y        // types are optional - usually inferred
x -> {                          // a block body needs braces and return
    int doubled = x * 2;
    return doubled + 1;
}

Body berupa satu ekspresi (x -> x + 1) secara implisit mengembalikan nilainya, tanpa kata kunci return. Begitu kamu memakai kurung kurawal, kamu sedang menulis blok biasa dan harus menulis return secara eksplisit kalau method-nya mengembalikan sesuatu. Kesalahan yang umum adalah mencampur keduanya: x -> { x + 1 } tidak bisa dikompilasi, karena blok butuh sebuah pernyataan (return x + 1;).

Lambda Menggantikan Anonymous Class

Cara paling jelas untuk melihat manfaat lambda adalah membandingkan sebelum dan sesudahnya. Dulu, mengurutkan dengan Comparator khusus terlihat seperti ini:

// before - anonymous class
names.sort(new Comparator<String>() {
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
});

Hal yang sama dalam bentuk lambda hanyalah satu baris yang mudah dibaca:

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

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Charlie", "Bo", "Alex"));

        names.sort((a, b) -> a.length() - b.length());   // after - lambda

        System.out.println(names);   // [Bo, Alex, Charlie]
    }
}

Comparator adalah functional interface (satu-satunya abstract method-nya adalah compare), jadi lambda bisa langsung dipasang. Semua formalitasnya, yaitu new, class, dan signature method, hilang, dan yang tersisa hanya logika perbandingannya.

Kotak Peralatan java.util.function

Kamu jarang perlu mendeklarasikan functional interface sendiri. Package java.util.function sudah menyediakan bentuk-bentuk yang umum, dan hampir semua API library Java menerimanya:

• Function<T, R>: menerima T, mengembalikan R (apply)
• Predicate<T>: menerima T, mengembalikan boolean (test)
• Supplier<T>: tidak menerima apa-apa, mengembalikan T (get)
• Consumer<T>: menerima T, tidak mengembalikan apa-apa (accept)

import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Function<String, Integer> length = s -> s.length();
        Predicate<Integer> isEven        = n -> n % 2 == 0;
        Supplier<String> greeting        = () -> "hello";

        System.out.println(length.apply("lambda"));   // 6
        System.out.println(isEven.test(10));           // true
        System.out.println(greeting.get());            // hello
    }
}

Semuanya interface generic: Function<String, Integer> memakai ulang generics yang kamu lihat di halaman sebelumnya agar tetap type-safe. Pilih yang bentuknya cocok dengan apa yang perlu diterima dan dihasilkan oleh kodemu.

Method Reference

Saat sebuah lambda tidak melakukan apa-apa selain memanggil satu method yang sudah ada, kamu bisa menggantinya dengan method reference memakai ::. Nilainya sama, hanya ditulis lebih langsung:

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

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

        // lambda:           s -> s.toUpperCase()
        // method reference: String::toUpperCase
        words.replaceAll(String::toUpperCase);
        System.out.println(words);   // [PEAR, FIG, APPLE, KIWI]

        // sort by length using a static helper as a Comparator
        words.sort((a, b) -> Integer.compare(a.length(), b.length()));
        System.out.println(words);   // [FIG, PEAR, KIWI, APPLE]
    }
}

Method reference punya beberapa bentuk: String::toUpperCase (method instance yang dipanggil pada setiap argumen), Math::max (method static), System.out::println (method milik objek tertentu), dan ArrayList::new (constructor). Pakai method reference hanya kalau hasilnya jelas dibaca. Kalau kamu harus berpikir dulu bentuk mana yang berlaku, lambda biasa juga tidak masalah.

Menangkap Variabel

Lambda bisa memakai variabel lokal dari method di sekitarnya, tetapi hanya kalau variabel itu final atau effectively final, yaitu diberi nilai sekali dan tidak pernah diubah. Java menangkap nilainya pada saat lambda dibuat, jadi variabel yang nantinya bisa berubah akan menimbulkan ambiguitas.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        int factor = 3;                          // never reassigned -> effectively final
        Function<Integer, Integer> scale = n -> n * factor;

        System.out.println(scale.apply(10));     // 30
        // factor = 4;   // <- uncommenting this breaks the lambda above
    }
}

Kalau kamu memberi nilai baru ke factor di mana pun, compiler menolak lambda itu dengan pesan "variable used in lambda expression should be final or effectively final." Saat kamu benar-benar butuh state bersama yang bisa berubah, tangkap sebuah objek, misalnya field, elemen array, atau AtomicInteger, karena referensinya tetap sama meskipun isinya berubah. Perhatikan bahwa lambda, berbeda dengan anonymous class, tidak membuat scope sendiri: this di dalam lambda merujuk ke instance yang membungkusnya, bukan ke lambda itu sendiri.

Berikutnya: Stream

Lambda adalah blok bangunannya, bukan tujuannya. Manfaat sebenarnya muncul bersama Streams API, tempat kamu merangkai operasi seperti filter, map, dan reduce, yang masing-masing menerima lambda, untuk menyatakan transformasi data sebagai pipeline yang mudah dibaca, bukan tumpukan loop yang kusut. Itu topik halaman berikutnya.