W poście tym przybliżam interfejsy funkcyjne wprowadzone w bibliotece Java 8. Istnieje sześć głównych typów interfejsów funkcyjnych. Wszystkich interfejsów funkcyjnych jest 43.
Lista dostępnych intefejsów funkcyjnych:
Interface | Function Signature | Example |
|---|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
1. Operator
Jest to interfejs reprezentujący funkcję gdzie typ wyniku i argumentu jest taki sam.
2. Predykat (Predicate)
Jest to interfejs reprezentujący funkcję, która przyjmuje argument i zwraca boolean.
Jest to funkcja, która przyjmuje jakiś argument i odpowiada: „tak" lub „nie", w zależności od podanego jej elementu. Przykład predykatu jedno argumentowego gdzie sprawdzamy czy zmienna jest parzysta lub nie:
Predicate<Integer> p = i-> i%2==0;
Predicate<Integer> p = i-> i%2==0;
W przypadku gdy predykat zwróci „tak", to metoda umieści ten element w kolekcji wynikowej. W przeciwnym razie, ten element się tam nie znajdzie.
BiPredicate daje nam możliwość sprawdzenia warunków dla 2 argumentów. Poniżej przykład użycia:
BiPredicate daje nam możliwość sprawdzenia warunków dla 2 argumentów. Poniżej przykład użycia:
import java.util.function.*
class Test {
public static void main(String [] args){
BiPredicate<Integer, Integer> p = (a,b) -> (a+b) % 2 == 0;
log.debug(p.test(10,20); // true
log.debug(p.test(15); // false
}
}
3. Funkcja (Function)
Jest to interfejs reprezentujący funkcję gdzie typ wyniku i argumentu jest różny.
function <Integer, Integer> f = i -> i*i
BiFunkcja w odróżnieniu od funkcji przedstawionej powyżej może na wejściu przyjąć 2 wartości i je przetworzyć. Poniżej przykład użycia:
import java.util.function.*
class Test {
public static void main(String [] args){
BiFunction<Integer, Integer, Integer> f = (a,b) -> a*b
log.debug(p.apply(10,20); // 200
log.debug(p.apply(1, 10); // 10
}
}
4. Konsument (Consumer)
Jest to interfejs reprezentujący funkcję, która przyjmuje argument i nie zwraca nic.
Consumer<String> c = a -> sopen(a)
BiKonsument może przetworzyć na wejściu 2 argumenty.
Przykład użycia BiFunction oraz BiConsumer:
import java.util.function.*;
import java.util.*
class Employee {
String name;
double salary;
Employee(String name, double salary){
this.name = name;
this.salary = salary;
}
class Test {
public static void main(String[] args){
ArrayList<Employee> list = new ArrayList<Employee>();
BiFunction<String, double, Employee> f = (name,salary) -> new Employee(name, salary);
list.add(f.accept("Adam", 1000000000));
list.add(f.accept("Ada", 1000));
list.add(f.accept("Anna", 1000));
BiConsumer<Employee, Double> c = (e,d) -> e.salary = e.salary + d;
for (Employee e: list){
c.accept(e, 600);
}
for (Employee e :l){
log.debug(e.salary);
log.debug(e.name);
}
}
}
5. Dostawca (Supplier)
Jest to interfejs reprezentujący funkcję, która nie przyjmuje argumentu i zwraca wartość.
Supplier<Date> s = () -> new Date();
Porównanie jedno i dwu argumentowego predykatu i funkcji:
Jedno argumentowy interfejs funkcjonalny.
interface Predicate<T> {
public boolean test(T t);
default Predicate and(Predicate p);
default Predicate or(Predicate p);
default Predicate negate();
static Predicate isEqual(Object o);
}
Zawiera jedna metodę abstrakcyjna (test) oraz 4 domyśle metody i jedna metodę statyczna.
Dwu argumentowy interfejs funkcjonalny:
interface BiPredicate<T, U> {
public boolean test(T t, U u);
default BiPredicate and(BiPredicate p);
default BiPredicate or(BiPredicate p);
default BiPredicate negate();
}
Nie posiada metody statycznej. Przyjmuje 2 argumenty w metodzie abstrakcyjnej.
Interfejs Funkcji:
interface Function<T,R> {
public R apply(T t);
default Function andThen(Function f);
default Function compose(Function f);
static Function identity();
}
Posiada jedne argument na wejściu (T) oraz zwraca jeden argument (R). Jedna metode abstrakcyjna oraz 2 domyślne i jedna statyczna.
Interfejs BiFunkcji:
interface BiFunction<T, U, R> {
public R apply(T t, U u);
default BiFunction andThen(Function f);
}
Posiada 2 argumenty na wejściu (T,U) oraz zwraca jeden argument (R). Warto zauważyć że domyślna metoda andThen przyjmuje na wejściu Funkcję f a nie BiFunckję.
Jednoargumentowy interfejs Konsument:
interface Consumer<T> {
public void accept(T t);
default Consumer andThen(Consumer c);
}
Przyjmuje jeden argument i nic nie zwraca.
Dwuargumentowy interfejs Konsument:
interface Consumer<T> {
public void accept(T t);
default BiConsumer andThen(Consumer c);
}
Przyjmuje dwa argumenty ale nic nie zwraca. Metoda andThen używamy do łaczenia większej ilości Konsumentów.
src: https://devcave.pl/effective-java/interfejsy-funkcyjne-w-javie
Brak komentarzy:
Prześlij komentarz