Interfețe funcționale încorporate

În JDK 8, odată cu introducerea expresiilor lambda, au fost adăugate și un număr de interfețe funcționale încorporate, pe care le putem utiliza în diverse situații și în diferite API-uri din cadrul JDK 8. În special, unele dintre aceste interfețe sunt larg utilizate în Stream API – noul API pentru lucrul cu datele. Să analizăm principalele dintre aceste interfețe:

Predicate<T>
Consumer<T>
Function<T,R>
Supplier<T>
UnaryOperator<T>
BinaryOperator<T>

Predicate

Interfața funcțională Predicate<T> verifică dacă o anumită condiție este îndeplinită. Dacă aceasta este îndeplinită, se returnează valoarea true. Parametrul expresiei lambda este un obiect de tip T:

public interface Predicate<T> {
   boolean test(T t);
}

Exemplu:

import java.util.function.Predicate;

public class LambdaApp {

   public static void main(String[] args) {
       Predicate<Integer> isPositive = x -> x > 0;

       System.out.println(isPositive.test(5));  // true
       System.out.println(isPositive.test(-7)); // false
   }
}

BinaryOperator

BinaryOperator<T> primește ca parametri două obiecte de tip T, efectuează o operație binară asupra lor și returnează rezultatul sub forma unui obiect de tip T:

public interface BinaryOperator<T> {
   T apply(T t1, T t2);
}

Exemplu:

import java.util.function.BinaryOperator;

public class LambdaApp {

   public static void main(String[] args) {
       BinaryOperator<Integer> multiply = (x, y) -> x * y;

       System.out.println(multiply.apply(3, 5));  // 15
       System.out.println(multiply.apply(10, -2)); // -20
   }
}

UnaryOperator

UnaryOperator<T> primește ca parametru un obiect de tip T, efectuează operații asupra acestuia și returnează rezultatul sub formă de obiect de același tip T:

public interface UnaryOperator<T> {
   T apply(T t);
}

Exemplu:

import java.util.function.UnaryOperator;

public class LambdaApp {

   public static void main(String[] args) {
       UnaryOperator<Integer> square = x -> x * x;
       System.out.println(square.apply(5));  // 25
   }
}

Function

Interfața funcțională Function<T, R> reprezintă o funcție care transformă un obiect de tip T într-un obiect de tip R:

public interface Function<T, R> {
   R apply(T t);
}

Exemplu:

import java.util.function.Function;

public class LambdaApp {

   public static void main(String[] args) {
       Function<Integer, String> convert = x -> String.valueOf(x) + " dolari";
       System.out.println(convert.apply(5));  // 5 dolari
   }
}

Consumer

Consumer<T> efectuează o acțiune asupra unui obiect de tip T, fără a returna vreo valoare:

public interface Consumer<T> {
   void accept(T t);
}

Exemplu:

import java.util.function.Consumer;

public class LambdaApp {

   public static void main(String[] args) {
       Consumer<Integer> printer = x -> System.out.printf("%d dolari \n", x);
       printer.accept(600);  // 600 dolari
   }
}

Supplier

Supplier<T> nu primește niciun argument, dar trebuie să returneze un obiect de tip T:

public interface Supplier<T> {
   T get();
}

Exemplu:

import java.util.Scanner;
import java.util.function.Supplier;

public class LambdaApp {

   public static void main(String[] args) {
       Supplier<User> userFactory = () -> {
           Scanner in = new Scanner(System.in);
           System.out.println("Introduceți numele: ");
           String name = in.nextLine();
           return new User(name);
       };

       User user1 = userFactory.get();
       User user2 = userFactory.get();

       System.out.println("Numele user1: " + user1.getName());
       System.out.println("Numele user2: " + user2.getName());
   }
}

class User {
   private String name;

   String getName() {
       return name;
   }

   User(String n) {
       this.name = n;
   }
}

Ieșire în consolă:

Introduceți numele:
Tom
Introduceți numele:
Sam
Numele user1: Tom
Numele user2: Sam