Lambda expression ile Java8 sayesinde tanıştık. Lambda expressions, Java’nın ifade gücünü artıran syntax öğeleri ekledi. Bu yazıda, kodunuza lambda ifadeleri eklemeye başlayabilmeniz için aşina olmanız gereken temel kavramları anlatmaya çalışacağım.
Lambda ifadeleri, Stream API‘sindeki verilerdeki pipeline işlemlerinin desteğiyle, çok çekirdekli ortamların paralel işlem özelliklerinden yararlanır. Functional interface tarafından tanımlanan bir methodun implementasyonu için kullanılan anonim methodlardır (isimsiz methodlar). Lambda ifadelerine girmeden önce functional interface’in ne olduğunu bilmek önemlidir.
Functional interface nedir?
Functional bir interface, yalnızca bir soyut method içeren bir interface’dir.
Java standart Runnable interface’inin tanımına bakarsanız, functional arayüz tanımına nasıl düştüğünü fark edeceksiniz, çünkü sadece bir methodu tanımlar: run();
Ayrıca bir functional interface tanımlarken @FunctionalInterface anotasyonu da kullanılabilir. Bu anotasyonu kullanmak zorunlu değildir, validasyon yapmak amacıyla kullanılır. Eğer anotasyon eklenirse ve birden fazla soyut method eklenmeye çalışılırsa, compile error alınır.
Aşağıdaki kod örneğinde, computeName methodu dolaylı olarak soyuttur ve MyName’i işlevsel bir interface haline getiren tek methoddur.
|
1 2 3 |
interface MyName{ String computeName(String str); } |
-> Operatörü
n -> n*n
Sol taraf, ifade için gerekli olan parametreleri belirtir ve parametre gerekmediğinde de boş olabilir. Sağ taraf, lambda ifadesinin eylemlerini belirten lambda gövdesidir. Bu operatör hakkında “olur” diye düşünmek faydalı olabilir. Örneğin, “n, n * n olur” ve ya “n, n kare olur”.
Functional interface ve -> operatörü kavramlarını akılda tutarak, basit bir lambda ifadesini bir araya getirebilirsiniz:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
interface NumericTest { boolean computeTest(int n); } public static void main(String args[]) { NumericTest isEven = (n) -> (n % 2) == 0; NumericTest isPositive = (n) -> (n < 0); // Output: true System.out.println(isEven.computeTest(4)); // Output: false System.out.println(isPositive.computeTest(-3)); } |
Blok Lambda Expression
Şimdiye kadar, tek ifadeli lambda örnekleri ele aldık. -> operatörünün sağ tarafındaki kod, blok lambdas olarak bilinen birden fazla ifade içerdiğinde kullanılan başka bir ifade türü vardır:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
interface MyString { String myStringFunction(String str); } public static void main (String args[]) { // Block lambda to reverse string MyString reverseStr = (str) -> { String result = ""; for(int i = str.length()-1; i >= 0; i--) result += str.charAt(i); return result; }; // Output: omeD adbmaL System.out.println(reverseStr.myStringFunction("Lambda Demo")); } |
Generic functional interfaceler
Bir lambda ifadesi generic olamaz. Ancak lambda ifadesi ile ilişkili functional interface olabilir. Bir generic interface yazmak ve bunun gibi farklı dönüş türlerini işlemek mümkündür:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
interface MyGeneric<T> { T compute(T t); } public static void main(String args[]){ // String version of MyGenericInteface MyGeneric<String> reverse = (str) -> { String result = ""; for(int i = str.length()-1; i >= 0; i--) result += str.charAt(i); return result; }; // Integer version of MyGeneric MyGeneric<Integer> factorial = (Integer n) -> { int result = 1; for(int i=1; i <= n; i++) result = i * result; return result; }; // Output: omeD adbmaL System.out.println(reverse.compute("Lambda Demo")); // Output: 120 System.out.println(factorial.compute(5)); } |
Arguman olarak Lambda expressions
Lambdaların yaygın bir kullanımı onları argüman olarak aktarmaktır.
Hedef türü sağlayan herhangi bir kod parçasında kullanılabilirler.
Lambda ifadelerini parametre olarak iletmek için functional interface’in türünün gerekli parametreyle uyumlu olduğundan emin olun.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
interface MyString { String myStringFunction(String str); } public static String reverseStr(MyString reverse, String str){ return reverse.myStringFunction(str); } public static void main (String args[]) { // Block lambda to reverse string MyString reverse = (str) -> { String result = ""; for(int i = str.length()-1; i >= 0; i--) result += str.charAt(i); return result; }; // Output: omeD adbmaL System.out.println(reverseStr(reverse, "Lambda Demo")); |
Bu kavramlar lambda expressionlarla çalışmaya başlamak için bir temel oluşturacaktır.
