Manufactura industrial
Internet industrial de las cosas | Materiales industriales | Mantenimiento y reparación de equipos | Programación industrial |
home  MfgRobots >> Manufactura industrial >  >> Industrial programming >> Java

Dominar Interfaces Funcionales en Java 8: Guía Completa

Las interfaces funcionales tienen una única funcionalidad que exhibir. Por ejemplo, una interfaz Comparable con un solo método compareTo se usa para propósitos de comparación. Java 8 ha definido muchas interfaces funcionales para usarse extensivamente en expresiones lambda. A continuación se muestra la lista de interfaces funcionales definidas en el paquete java.util.function.

Nº Interfaz y Descripción
1 BiConsumer<T,U>
Representa una operación que acepta dos argumentos de entrada y no devuelve 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 valor booleano.
6 Consumer<T>
Representa una operación que acepta un solo argumento de entrada y no devuelve resultado.
7 DoubleBinaryOperator
Representa una operación sobre dos operandos con valor double y produciendo un resultado con valor double.
8 DoubleConsumer
Representa una operación que acepta un solo argumento con valor double y no devuelve resultado.
9 DoubleFunction<R>
Representa una función que acepta un argumento con valor double y produce un resultado.
10 DoublePredicate
Representa un predicado (función con valor booleano) de un argumento con valor double.
11 DoubleSupplier
Representa un proveedor de resultados con valor double.
12 DoubleToIntFunction
Representa una función que acepta un argumento con valor double y produce un resultado con valor int.
13 DoubleToLongFunction
Representa una función que acepta un argumento con valor double y produce un resultado con valor long.
14 DoubleUnaryOperator
Representa una operación sobre un solo operando con valor double que produce un resultado con valor double.
15 Function<T,R>
Representa una función que acepta un argumento y produce un resultado.
16 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 solo argumento con valor int y no devuelve 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 int.
21 IntToDoubleFunction
Representa una función que acepta un argumento con valor int y produce un resultado con valor double.
22 IntToLongFunction
Representa una función que acepta un argumento con valor int y produce un resultado con valor long.
23 IntUnaryOperator
Representa una operación sobre un solo operando con valor int que produce un resultado con valor int.
24 LongBinaryOperator
Representa una operación sobre dos operandos con valor long y produce un resultado con valor long.
25 LongConsumer
Representa una operación que acepta un solo argumento con valor long y no devuelve resultado.
26 LongFunction<R>
Representa una función que acepta un argumento con valor long y produce un resultado.
27 LongPredicate
Representa un predicado (función con valor booleano) de un argumento con valor long.
28 LongSupplier
Representa un proveedor de resultados con valor long.
29 LongToDoubleFunction
Representa una función que acepta un argumento con valor long y produce un resultado con valor double.
30 LongToIntFunction
Representa una función que acepta un argumento con valor long y produce un resultado con valor int.
31 LongUnaryOperator
Representa una operación sobre un solo operando con valor long que produce un resultado con valor long.
32 ObjDoubleConsumer<T>
Representa una operación que acepta un argumento con valor objeto y uno con valor double, y no devuelve resultado.
33 ObjIntConsumer<T>
Representa una operación que acepta un argumento con valor objeto y uno con valor int, y no devuelve resultado.
34 ObjLongConsumer<T>
Representa una operación que acepta un argumento con valor objeto y uno con valor long, y no devuelve 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 con valor double.
38 ToDoubleFunction<T>
Representa una función que produce un resultado con valor double.
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 int.
41 ToLongBiFunction<T,U>
Representa una función que acepta dos argumentos y produce un resultado con valor long.
42 ToLongFunction<T>
Representa una función que produce un resultado con valor long.
43 UnaryOperator<T>
Representa una operación sobre 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 test(Object) para devolver un valor booleano. Esta interfaz significa que un objeto es probado para ser verdadero o falso.

Crea el siguiente programa Java usando cualquier editor de tu 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 se pasa como parámetro al método test de la interfaz Predicate
        // el método test siempre devolverá true sin importar qué valor tenga n.
        System.out.println("Imprimir todos los números:");
        eval(list, n -> true);

        // Predicate<Integer> predicate1 = n -> n%2 == 0
        // n se pasa como parámetro al método test de la interfaz Predicate
        // el método test devolverá true si n%2 resulta ser cero
        System.out.println("Imprimir números pares:");
        eval(list, n -> n % 2 == 0);

        // Predicate<Integer> predicate2 = n -> n > 3
        // n se pasa como parámetro al método test de la interfaz Predicate
        // el método test devolverá true si n es mayor que 3.
        System.out.println("Imprimir números mayores que 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 el compilador javac de la siguiente manera:

C:\JAVA>javac Java8Tester.java

Ahora ejecuta Java8Tester de la siguiente manera:

C:\JAVA>java Java8Tester

Debería producir la siguiente salida:

Imprimir todos los números:
1 2 3 4 5 6 7 8 9
Imprimir números pares:
2 4 6 8
Imprimir números mayores que 3:
4 5 6 7 8 9

Java

  1. Dominar Operadores en Java: Tipos, Sintaxis y Ejemplos Prácticos
  2. Comentarios en Java: Tipos, Uso y Mejores Prácticas
  3. Dominar el Bucle for Mejorado en Java: Sintaxis, Ejemplos y Mejores Prácticas
  4. Dominar Strings en Java: Creación, Métodos y Mejores Prácticas
  5. Dominando interfaces en Java: Conceptos, implementación y mejores prácticas
  6. Dominando las clases internas anónimas en Java: Definición, sintaxis y ejemplos prácticos
  7. Dominando Try‑with‑Resources en Java: Gestión automática de recursos explicada
  8. Anotaciones en Java explicadas: Tipos, ubicación y ejemplos prácticos
  9. Aserciones en Java: Guía práctica para detectar bugs y asegurar fiabilidad del código
  10. Entendiendo Java Vector: Uso, Características y Comparación con ArrayList
  11. Entendiendo las Interfaces en Java: Definiciones, Usos y Buenas Prácticas