chapter-05.asc

Lambda örnekleri

java.util.function paketi altında bir çok fonksiyonel arayüz bulunmaktadır. Bu arayüzlerin temel amacı, farklı tipteki Lambda ifadelerine temel oluşturmaktır.

Consumer Arayüzü

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t); // t-> {}

}

T tipindeki parametreyi alır ve tüketir/işler. Geriye değer döndürmez (void). T burada herhangi bir sınıf tipi olabilir.

Consumer Arayüzü Örnek

Consumer<String> consumer = word -> {
            System.out.println(word); // Merhaba Dünya
        };

consumer.accept("Merhaba Dünya");

---

BiConsumer Arayüzü

@FunctionalInterface
public interface BiConsumer<T, U> {

    void accept(T t, U u); // (t,u) -> {}
}

T ve U tiplerinde iki parametre alır ve bu parametreleri tüketir. Geriye değer döndürmez.

BiConsumer Arayüzü Örnek

BiConsumer<String, Integer> biConsumer = (name, age) -> {
            System.out.println(name+":"+age); // Alinin yaşı:25
        };
biConsumer.accept("Ali'nin yaşı",25);

---

Function Arayüzü

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t); // t-> r

}

T tipinde bir parametre alır, işler ve R tipinde bir değer döndürür.

Function Arayüzü Örnek

Function<Integer, Integer> function = t -> Math.pow(t,2);
Integer result = function.apply(5);
System.out.println(result); // 25

---

UnaryOperator Arayüzü

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

}

Function türündendir. Eğer T ve R tipleri aynı türden ise, ismi UnaryOperator olur.

UnaryOperator Arayüzü Örnek

UnaryOperator<Integer> unaryOperator = a -> Math.pow(a,5);
Integer result = unaryOperator.apply(2);
System.out.println(result); // 32

---

BiFunction Arayüzü

@FunctionalInterface
public interface BiFunction<T, U, R> {

    R apply(T t, U u); // (t,u) -> r
}

T ve U tiplerinde iki parametre alır, R tipinde değer döndürür. T, U ve R herhangi bir sınıf tipi olabilir. Function#apply tek parametre alırken Bi* iki parametre alır.

BiFunction Arayüzü Örnek

BiFunction<Integer, Integer, String> biFunction = (a, b) -> "Sonuç:" + (a + b);
String result = biFunction.apply(3,5);
System.out.println(result); // Sonuç: 8

---

BinaryOperator Arayüzü

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {

}

BiFunction türündendir. T, U ve R aynı tipte ise BinaryOperator kullanılabilir.

BinaryOperator Arayüzü Örnek

BinaryOperator<Integer> binaryOperator = (a, b) -> a + b;
Integer result = binaryOperator.apply(3,5);
System.out.println(result); // 8

---

Predicate Arayüzü

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t); // t-> true/false
}

T tipimde bir parametre alır, şarta bağlı olarak true/false değer döndürür.

Predicate Arayüzü Örnek

Predicate<Integer> predicate = a -> (a > 0);

boolean pos = predicate.test(5); // true
boolean neg = predicate.test(-5); // false

---

BiPredicate Arayüzü

@FunctionalInterface
public interface BiPredicate<T, U> {

    boolean test(T t, U u); // (t,u) -> true/false
}

T ve U tiplerinde iki parametre alır, şarta bağlı olarak true/false döndürür.

BiPredicate Arayüzü Örnek

BiPredicate<Integer, Integer> biPredicate = (a, b) -> (a > b);

boolean bigger = biPredicate.test(5,4); // true
boolean lower = biPredicate.test(5,7); // false

---

Supplier Arayüzü

@FunctionalInterface
public interface Supplier<T> {

    T get(); // () -> t
}

Hiç parametre almaz, T tipinde bir değer döndürür. Factory pattern için uygundur.

Supplier Arayüzü Örnek

Supplier<List> supplier = () -> new ArrayList<>();
List<String> liste = supplier.get();
liste.add("Ali");
liste.add("Veli");
liste.add("Selami");

Tekrar görüşmek dileğiyle…​