Wyrażenia lambda w Javie: zwięzły kod funkcyjny

Zachowanie, które można przekazywać

Wyrażenie lambda to zwięzły blok kodu, który możesz przekazać metodzie, zapisać w zmiennej albo zwrócić, tak jak liczbę czy napis. Przed lambdami przekazanie zachowania oznaczało napisanie całej klasy (albo rozwlekłej klasy anonimowej) tylko po to, żeby opakować jedną metodę. Lambda sprowadza to do istoty: parametrów i ciała.

Lambda zawsze implementuje interfejs funkcyjny, czyli interfejs z dokładnie jedną metodą abstrakcyjną (pojawiły się na końcu strony o interfejsach). Kompilator z kontekstu ustala, o który interfejs chodzi, i dopasowuje twoją lambdę do tej jedynej metody.

interface Transformer {
    int apply(int x);
}

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

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

x -> x * 2 to cała implementacja apply. Bez new, bez ciała klasy, bez nazwy metody: wszystko to dostarcza interfejs.

Składnia ze strzałką

Każda lambda ma postać parametry -> ciało. Poszczególne części zmieniają się zależnie od potrzeb:

() -> 42                       // bez parametrów
x -> x + 1                     // jeden parametr, nawiasy opcjonalne
(x, y) -> x + y                // dwa lub więcej parametrów wymagają nawiasów
(int x, int y) -> x + y        // typy są opcjonalne: zwykle są wnioskowane
x -> {                          // ciało blokowe wymaga klamer i return
    int doubled = x * 2;
    return doubled + 1;
}

Ciało z jednym wyrażeniem (x -> x + 1) niejawnie zwraca swoją wartość, bez słowa kluczowego return. Gdy tylko użyjesz klamer, piszesz zwykły blok i musisz jawnie użyć return, jeśli metoda coś zwraca. Częsty błąd to mieszanie obu form: x -> { x + 1 } się nie kompiluje, bo blok potrzebuje instrukcji (return x + 1;).

Lambdy zastępują klasy anonimowe

Najlepiej widać, co daje lambda, porównując „przed” i „po”. Sortowanie z własnym Comparator wyglądało kiedyś tak:

// przed: klasa anonimowa
names.sort(new Comparator<String>() {
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
});

To samo jako lambda to jedna czytelna linia:

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());   // po: lambda

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

Comparator to interfejs funkcyjny (jego jedyna metoda abstrakcyjna to compare), więc lambda pasuje od razu. Cała ceremonia (new, klasa, sygnatura metody) znika i zostaje tylko logika porównania.

Skrzynka z narzędziami java.util.function

Rzadko musisz deklarować własny interfejs funkcyjny. Pakiet java.util.function zawiera najczęstsze kształty, a prawie wszystkie API biblioteki Javy je przyjmują:

• Function<T, R>: przyjmuje T, zwraca R (apply)
• Predicate<T>: przyjmuje T, zwraca boolean (test)
• Supplier<T>: niczego nie przyjmuje, zwraca T (get)
• Consumer<T>: przyjmuje T, niczego nie zwraca (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
    }
}

To interfejsy generyczne: Function<String, Integer> wykorzystuje generyki z poprzedniej strony, żeby zachować bezpieczeństwo typów. Wybierz ten, którego kształt pasuje do tego, co twój kod ma przyjmować i zwracać.

Referencje do metod

Gdy lambda jedynie wywołuje jedną istniejącą metodę, możesz zastąpić ją referencją do metody z użyciem ::. To ta sama wartość, zapisana bardziej bezpośrednio:

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()
        // referencja do metody: String::toUpperCase
        words.replaceAll(String::toUpperCase);
        System.out.println(words);   // [PEAR, FIG, APPLE, KIWI]

        // sortowanie po długości z pomocniczą metodą statyczną jako Comparator
        words.sort((a, b) -> Integer.compare(a.length(), b.length()));
        System.out.println(words);   // [FIG, PEAR, KIWI, APPLE]
    }
}

Referencje do metod występują w kilku odmianach: String::toUpperCase (metoda instancji wywoływana na każdym argumencie), Math::max (metoda statyczna), System.out::println (metoda konkretnego obiektu) i ArrayList::new (konstruktor). Sięgaj po nie tylko wtedy, gdy czytają się jasno. Jeśli musisz się zastanawiać, która forma pasuje, zwykła lambda też jest w porządku.

Przechwytywanie zmiennych

Lambda może używać zmiennych lokalnych z otaczającej ją metody, ale tylko wtedy, gdy są final lub effectively final: przypisane raz i nigdy niezmieniane. Java przechwytuje wartość w chwili tworzenia lambdy, więc zmienna, która mogłaby się później zmienić, byłaby niejednoznaczna.

import java.util.function.Function;

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

        System.out.println(scale.apply(10));     // 30
        // factor = 4;   // <- odkomentowanie tego psuje lambdę powyżej
    }
}

Jeśli gdziekolwiek ponownie przypiszesz factor, kompilator odrzuci lambdę z komunikatem „variable used in lambda expression should be final or effectively final”. Gdy naprawdę potrzebujesz modyfikowalnego wspólnego stanu, przechwyć zamiast tego obiekt: pole, element tablicy albo AtomicInteger, bo referencja pozostaje stała, nawet gdy zmienia się zawartość. Pamiętaj, że lambdy, w odróżnieniu od klas anonimowych, nie tworzą własnego zasięgu: this wewnątrz lambdy odnosi się do otaczającej instancji, a nie do samej lambdy.

Dalej: strumienie

Lambdy to budulec, a nie cel sam w sobie. Prawdziwą korzyść przynoszą w Streams API, gdzie łączysz w łańcuch operacje takie jak filter, map i reduce (każda przyjmuje lambdę), żeby wyrazić przekształcenia danych jako czytelny potok zamiast plątaniny pętli. O tym jest następna strona.