Java Lambda İfadeleri: Özlü Fonksiyonel Kod

Etrafta Dolaştırabileceğin Davranış

Lambda ifadesi, tıpkı bir sayı ya da bir dizgiyi (string) yapacağın gibi bir metoda verebileceğin, bir değişkende saklayabileceğin ya da döndürebileceğin sıkışık bir kod bloğudur. Lambda'lardan önce davranış aktarmak, sadece tek bir metodu sarmalamak için bütün bir sınıf (ya da uzun soluklu bir anonim sınıf) yazmak demekti. Lambda bunu özüne indirger: parametreler ve gövde.

Bir lambda her zaman bir fonksiyonel arayüzü uygular; yani tam olarak bir soyut metoda sahip bir arayüzü (bunlarla arayüzler sayfasının sonunda tanışmıştın). Derleyici hangi arayüzü kastettiğini bağlamdan anlar ve lambda'nı o tek metotla eşleştirir.

interface Transformer {
    int apply(int x);
}

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

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

x -> x * 2, apply metodunun eksiksiz uygulamasıdır. new yok, sınıf gövdesi yok, metot adı yok; bunların hepsini arayüz sağlar.

Ok Söz Dizimi

Her lambda'nın biçimi parametreler -> gövde şeklindedir. Parçalar, ne kadarına ihtiyacın olduğuna göre esner:

() -> 42                       // parametre yok
x -> x + 1                     // tek parametre, parantez isteğe bağlı
(x, y) -> x + y                // iki veya daha fazla parametre parantez gerektirir
(int x, int y) -> x + y        // türler isteğe bağlıdır - genellikle çıkarsanır
x -> {                          // blok gövde, süslü parantez ve return gerektirir
    int doubled = x * 2;
    return doubled + 1;
}

Tek bir ifadeden oluşan gövde (x -> x + 1) değerini örtük olarak döndürür; return anahtar sözcüğü gerekmez. Süslü parantez kullandığın an, normal bir blok yazıyorsundur ve metot bir şey döndürüyorsa açıkça return yazmalısın. Yaygın bir hata ikisini karıştırmaktır: x -> { x + 1 } derlenmez, çünkü bir blok bir deyim gerektirir (return x + 1;).

Lambda'lar Anonim Sınıfların Yerini Alır

Lambda'nın sana ne kazandırdığını görmenin en net yolu öncesi/sonrasıdır. Özel bir Comparator ile sıralamak eskiden şöyle görünürdü:

// öncesi - anonim sınıf
names.sort(new Comparator<String>() {
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
});

Aynı şey lambda olarak okunabilir tek bir satırdır:

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());   // sonrası - lambda

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

Comparator bir fonksiyonel arayüzdür (tek soyut metodu compare'dir), bu yüzden lambda doğrudan yerine oturur. Tüm tören (new, sınıf, metot imzası) ortadan kalkar ve geriye yalnızca karşılaştırma mantığı kalır.

java.util.function Araç Kutusu

Kendi fonksiyonel arayüzünü tanımlamana nadiren ihtiyaç duyarsın. java.util.function paketi yaygın biçimleri içerir ve Java'nın kütüphane API'lerinin neredeyse tamamı bunları kabul eder:

• Function<T, R> - bir T alır, bir R döndürür (apply)
• Predicate<T> - bir T alır, bir boolean döndürür (test)
• Supplier<T> - hiçbir şey almaz, bir T döndürür (get)
• Consumer<T> - bir T alır, hiçbir şey döndürmez (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
    }
}

Bunlar jenerik arayüzlerdir; Function<String, Integer>, tür güvenliğini korumak için önceki sayfada gördüğün jenerikleri yeniden kullanır. Kodunun almaya ve üretmeye ihtiyaç duyduğu şekle uyan biçimi seç.

Metot Referansları

Bir lambda var olan tek bir metodu çağırmaktan başka bir şey yapmadığında, onu :: kullanarak bir metot referansıyla değiştirebilirsin. Aynı değerdir, sadece daha doğrudan yazılmıştır:

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

        // statik bir yardımcıyı Comparator olarak kullanarak uzunluğa göre sırala
        words.sort((a, b) -> Integer.compare(a.length(), b.length()));
        System.out.println(words);   // [FIG, PEAR, KIWI, APPLE]
    }
}

Metot referansları çeşitli biçimlerde gelir: String::toUpperCase (her argüman üzerinde çağrılan bir örnek metodu), Math::max (bir statik metot), System.out::println (belirli bir nesne üzerindeki bir metot) ve ArrayList::new (bir yapıcı). Yalnızca açık biçimde okunduğunda birine başvur; hangi biçimin geçerli olduğunu düşünmek zorunda kalıyorsan sade bir lambda gayet iyidir.

Değişken Yakalama

Bir lambda, kendisini çevreleyen metottan yerel değişkenleri kullanabilir, ama yalnızca final ya da etkin biçimde final iseler; yani bir kez atanmış ve hiç değiştirilmemişlerse. Java değeri lambda oluşturulduğu anda yakalar, bu yüzden sonradan değişebilecek bir değişken belirsiz olurdu.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        int factor = 3;                          // hiç yeniden atanmadı -> etkin biçimde final
        Function<Integer, Integer> scale = n -> n * factor;

        System.out.println(scale.apply(10));     // 30
        // factor = 4;   // <- bunun yorumunu kaldırmak yukarıdaki lambda'yı bozar
    }
}

factor'ü herhangi bir yerde yeniden atarsan, derleyici lambda'yı "variable used in lambda expression should be final or effectively final" diyerek reddeder. Gerçekten paylaşılan değiştirilebilir bir duruma ihtiyacın olduğunda onun yerine bir nesne yakala (bir alan, bir dizi elemanı ya da bir AtomicInteger); çünkü içeriği değişse bile referans sabit kalır. Şunu da unutma: lambda'lar, anonim sınıfların aksine, kendi kapsamlarını oluşturmaz: bir lambda içindeki this, lambda'nın kendisine değil, onu çevreleyen örneğe gönderme yapar.

Sıradaki: Streams

Lambda'lar yapı taşıdır, varış noktası değil. Asıl getirileri Streams API'siyle gelir; burada filter, map ve reduce gibi (her biri bir lambda alan) işlemleri zincirleyerek veri dönüşümlerini, karmakarışık döngüler yerine okunabilir bir boru hattı (pipeline) olarak ifade edersin. Bir sonraki sayfa bu.