Taşınabilir Davranış Kalıpları
Lambda ifadeleri; tıpkı bir sayı veya metin gibi metotlara parametre olarak gönderilebilen, değişkenlerde tutulabilen ya da sonuç olarak döndürülebilen kompakt kod parçalarıdır. Lambdalar öncesinde bir davranışı aktarmak için, tek bir işlevi yerine getirecek koca bir sınıf veya karmaşık bir anonim sınıf oluşturmak zorundaydınız. Lambda bu süreci sadeleştirerek sadece parametreleri ve iş mantığını içeren bir yapıya indirger.
Her lambda ifadesi mutlaka bir fonksiyonel arayüzü temel alır. Fonksiyonel arayüz, bünyesinde yalnızca bir tane soyut metot barındıran yapıdır. Kodu çalıştırdığınızda Java derleyicisi, mevcut bağlamdan hangi arayüzün kullanıldığını anlar ve yazdığınız lambdayı o tek metotla otomatik olarak eşleştirir.
Java:
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
}
}
Buradaki
x -> x * 2 ifadesi, apply metodunun tam karşılığıdır. Ne new anahtar kelimesine, ne sınıf gövdesine ne de metot ismine ihtiyaç vardır; bu detayların tamamı zaten arayüz tarafından tanımlanmıştır.Ok Operatörü ve Yazım Kuralları
Lambdaların genel yazım formatı
parametreler -> gövde şeklindedir. İhtiyaca göre bu yapı farklı şekillerde esneyebilir:
Java:
() -> 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;
}
Eğer gövde kısmı tek bir ifadeden oluşuyorsa (
x -> x + 1 gibi), bu değer otomatik olarak döndürülür ve return yazılması gerekmez. Ancak süslü parantez kullandığınızda standart bir kod bloğu yazmış olursunuz; bu durumda metot bir değer döndürüyorsa return ifadesini açıkça belirtmelisiniz. Sık yapılan hatalardan biri bu iki yapıyı karıştırmaktır: Örneğin x -> { x + 1 } kullanımı, blok içerisinde bir deyim eksik olduğu için (return x + 1; yazılmadığı sürece) derleme hatası verecektir.Anonim Sınıfların Modern Alternatifi
Lambdaların sağladığı kolaylığı anlamak için klasik yöntemle arasındaki farka bakmak yeterlidir. Örneğin, özel bir
Comparator ile sıralama işlemi eskiden şu şekilde yapılırdı:
Java:
// öncesi - anonim sınıf
names.sort(new Comparator<String>() {
public int compare(String a, String b) {
return a.length() - b.length();
}
});
Aynı işlem lambda kullanılarak tek bir satırda, çok daha okunabilir hale getirilebilir:
Java:
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 arayüzü yalnızca compare adında tek bir soyut metoda sahip olduğu için lambda doğrudan bu yapının yerine geçer. Gereksiz sınıf tanımlamaları ve metot imzaları ortadan kalkar; geriye sadece asıl işi yapan mantık kalır.java.util.function Kütüphanesi
Çoğu zaman kendi fonksiyonel arayüzünüzü oluşturmanıza gerek kalmaz. Java'daki pek çok API,
java.util.function paketindeki standart arayüzleri kullanır:•
Function<T, R> - Bir T tipi girdi alır ve R tipi sonuç üretir (apply).•
Predicate<T> - Bir T tipi girdi alır ve boolean sonuç döndürür (test).•
Supplier<T> - Girdi almaz, sadece bir T tipi çıktı üretir (get).•
Consumer<T> - Bir T tipi girdi alır fakat bir sonuç döndürmez (accept).
Java:
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
}
}
Jenerik yapıdaki bu arayüzler (örneğin
Function<String, Integer>), tip güvenliğini üst seviyede tutar. İhtiyacınız olan veri akışına göre bunlardan uygun olanını seçebilirsiniz.Metot Referansları
Bir lambda ifadesi sadece mevcut olan bir metodu çağırıyorsa, yazımı daha da kısaltmak için
:: operatörü ile metot referansı kullanılabilir. Bu yöntem kodun daha doğrudan okunmasını sağlar:
Java:
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ı farklı kullanım biçimlerine sahiptir:
String::toUpperCase (nesne üzerinden örnek metot), Math::max (statik metot), System.out::println (belirli bir nesne metodu) veya ArrayList::new (yapıcı metot). Eğer metot referansı okumayı zorlaştırıyorsa, standart lambda yazımı her zaman güvenli bir tercihtir.Kapsam ve Değişken Kullanımı
Lambdalar, tanımlandıkları metot içerisindeki yerel değişkenlere erişebilirler. Ancak bu değişkenlerin ya
final olarak işaretlenmiş olması ya da değerinin atandıktan sonra hiç değiştirilmemiş (effectively final) olması şarttır. Java, değişkenin değerini lambda oluşturulduğu anda kilitlediği için, sonradan değişebilecek değişkenlerin kullanılmasına izin vermez.
Java:
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
}
}
Eğer
factor değişkenine başka bir yerde yeni bir değer atarsanız, derleyici hata verecektir. Eğer mutlaka değişebilen bir değer paylaşmanız gerekiyorsa; bir nesne referansı, dizi elemanı ya da AtomicInteger gibi yapılar kullanabilirsiniz; çünkü bu durumda referans sabit kalırken içerik değişebilir. Ayrıca lambdaların anonim sınıflardan farkı, kendi kapsamlarına sahip olmamalarıdır: Lambda içindeki this anahtar kelimesi, lambdanın kendisine değil, içinde bulunduğu sınıfa işaret eder.Sonraki Adım: Streams API
Lambdalar aslında daha büyük bir yapının temel taşlarıdır. Esas güçlerini, karmaşık döngüler yerine veriyi bir boru hattı gibi işleyen Streams API'si ile gösterirler.
filter, map ve reduce gibi her biri birer lambda alan bu metotlarla veri dönüşümlerini çok daha zarif bir şekilde gerçekleştirebilirsiniz. Bir sonraki bölümde bu konuyu inceleyeceğiz.