Java 8 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<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<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<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<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<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<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<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<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<List> supplier = () -> new ArrayList<>();
List<String> liste = supplier.get();
liste.add("Ali");
liste.add("Veli");
liste.add("Selami");
Arşiv
https://kodedu.com/2014/01/video-java-8-nashorn-ile-javascript-webineri/
https://kodedu.com/2014/03/java-8-project-lambda-yenilikleri-webineri/
https://kodedu.com/2014/03/java-8-lambda-expressions-and-functional-interfaces/
https://kodedu.com/2014/03/java-8-lambda-expression-nedir-nasil-kullanirim/
https://kodedu.com/2014/07/java-8-consumer-arayuzu/
Tekrar görüşmek dileğiyle…
1 Comment