Java 8 - Interfaces funcionales

Las interfaces funcionales tienen una sola funcionalidad para exhibir. Por ejemplo, una interfaz Comparable con un solo método 'compareTo' se utiliza para fines de comparación. Java 8 ha definido una gran cantidad de interfaces funcionales para su uso extensivo en expresiones lambda. A continuación se muestra la lista de interfaces funcionales definidas en el paquete java.util.Function.

A continuación se muestra la lista de interfaces en Java8.

No Señor.	Interfaz y descripción
1	BiConsumer<T,U> Representa una operación que acepta dos argumentos de entrada y no devuelve ningún resultado.
2	BiFunction<T,U,R> Representa una función que acepta dos argumentos y produce un resultado.
3	BinaryOperator<T> Representa una operación sobre dos operandos del mismo tipo, produciendo un resultado del mismo tipo que los operandos.
4	BiPredicate<T,U> Representa un predicado (función con valor booleano) de dos argumentos.
5	BooleanSupplier Representa un proveedor de resultados con valores booleanos.
6	Consumer<T> Representa una operación que acepta un único argumento de entrada y no devuelve ningún resultado.
7	DoubleBinaryOperator Representa una operación sobre dos operandos de valor doble y produce un resultado de valor doble.
8	DoubleConsumer Representa una operación que acepta un único argumento de doble valor y no devuelve ningún resultado.
9	DoubleFunction<R> Representa una función que acepta un argumento de doble valor y produce un resultado.
10	DoublePredicate Representa un predicado (función de valor booleano) de un argumento de valor doble.
11	DoubleSupplier Representa un proveedor de resultados de doble valor.
12	DoubleToIntFunction Representa una función que acepta un argumento de valor doble y produce un resultado de valor int.
13	DoubleToLongFunction Representa una función que acepta un argumento de valor doble y produce un resultado de valor largo.
14	DoubleUnaryOperator Representa una operación en un solo operando de doble valor que produce un resultado de doble valor.
15	Function<T,R> Representa una función que acepta un argumento y produce un resultado.
dieciséis	IntBinaryOperator Representa una operación sobre dos operandos con valor int y produce un resultado con valor int.
17	IntConsumer Representa una operación que acepta un único argumento con valor de int y no devuelve ningún resultado.
18	IntFunction<R> Representa una función que acepta un argumento con valor int y produce un resultado.
19	IntPredicate Representa un predicado (función con valor booleano) de un argumento con valor int.
20	IntSupplier Representa un proveedor de resultados con valor internacional.
21	IntToDoubleFunction Representa una función que acepta un argumento de valor int y produce un resultado de valor doble.
22	IntToLongFunction Representa una función que acepta un argumento de valor int y produce un resultado de valor largo.
23	IntUnaryOperator Representa una operación en un solo operando con valor int que produce un resultado con valor int.
24	LongBinaryOperator Representa una operación sobre dos operandos de valor largo y produce un resultado de valor largo.
25	LongConsumer Representa una operación que acepta un único argumento de valor largo y no devuelve ningún resultado.
26	LongFunction<R> Representa una función que acepta un argumento de valor largo y produce un resultado.
27	LongPredicate Representa un predicado (función de valor booleano) de un argumento de valor largo.
28	LongSupplier Representa un proveedor de resultados valiosos.
29	LongToDoubleFunction Representa una función que acepta un argumento de valor largo y produce un resultado de valor doble.
30	LongToIntFunction Representa una función que acepta un argumento de valor largo y produce un resultado de valor int.
31	LongUnaryOperator Representa una operación en un solo operando de valor largo que produce un resultado de valor largo.
32	ObjDoubleConsumer<T> Representa una operación que acepta un argumento con valor de objeto y con valor doble, y no devuelve ningún resultado.
33	ObjIntConsumer<T> Representa una operación que acepta un argumento con valor de objeto y un argumento con valor de int, y no devuelve ningún resultado.
34	ObjLongConsumer<T> Representa una operación que acepta un argumento con valor de objeto y un argumento de valor largo, y no devuelve ningún resultado.
35	Predicate<T> Representa un predicado (función con valor booleano) de un argumento.
36	Supplier<T> Representa un proveedor de resultados.
37	ToDoubleBiFunction<T,U> Representa una función que acepta dos argumentos y produce un resultado de doble valor.
38	ToDoubleFunction<T> Representa una función que produce un resultado de doble valor.
39	ToIntBiFunction<T,U> Representa una función que acepta dos argumentos y produce un resultado con valor int.
40	ToIntFunction<T> Representa una función que produce un resultado con valor de int.
41	ToLongBiFunction<T,U> Representa una función que acepta dos argumentos y produce un resultado de valor largo.
42	ToLongFunction<T> Representa una función que produce un resultado de valor largo.
43	UnaryOperator<T> Representa una operación en un solo operando que produce un resultado del mismo tipo que su operando.

Ejemplo de interfaz funcional

La interfaz Predicate <T> es una interfaz funcional con un método de prueba (Objeto) para devolver un valor booleano. Esta interfaz significa que se prueba que un objeto es verdadero o falso.

Cree el siguiente programa Java utilizando cualquier editor de su elección en, digamos, C: \> JAVA.

Java8Tester.java

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Java8Tester {

   public static void main(String args[]) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
		
      // Predicate<Integer> predicate = n -> true
      // n is passed as parameter to test method of Predicate interface
      // test method will always return true no matter what value n has.
		
      System.out.println("Print all numbers:");
		
      //pass n as parameter
      eval(list, n->true);
		
      // Predicate<Integer> predicate1 = n -> n%2 == 0
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n%2 comes to be zero
		
      System.out.println("Print even numbers:");
      eval(list, n-> n%2 == 0 );
		
      // Predicate<Integer> predicate2 = n -> n > 3
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n is greater than 3.
		
      System.out.println("Print numbers greater than 3:");
      eval(list, n-> n > 3 );
   }
	
   public static void eval(List<Integer> list, Predicate<Integer> predicate) {

      for(Integer n: list) {

         if(predicate.test(n)) {
            System.out.println(n + " ");
         }
      }
   }
}

Aquí hemos pasado la interfaz Predicate, que toma una sola entrada y devuelve booleano.

Verificar el resultado

Compila la clase usando javac compilador de la siguiente manera:

C:\JAVA>javac Java8Tester.java

Ahora ejecute Java8Tester de la siguiente manera:

C:\JAVA>java Java8Tester

Debería producir el siguiente resultado:

Print all numbers:
1
2
3
4
5
6
7
8
9
Print even numbers:
2
4
6
8
Print numbers greater than 3:
4
5
6
7
8
9