En Java, el “ Consumidor La interfaz representa una operación que recibe una sola entrada y realiza alguna acción en ella sin devolver un resultado. También ofrece una forma flexible de definir operaciones personalizadas que se pueden utilizar en programación funcional como expresiones lambda. Este blog ilustra la implementación de una interfaz de consumidor en Java.
¿Cómo usar la interfaz del consumidor en Java?
El ' Consumidor La interfaz ofrece la encapsulación o el comportamiento que se puede transmitir y ejecutar en diferentes ubicaciones del programa. Promueve un comportamiento reutilizable que se puede aplicar a diferentes entradas sin duplicar el código. La interfaz del consumidor consta de dos métodos, a saber, ' y luego() ' y ' aceptar() ”.
Visite los siguientes ejemplos para comprender ambas funciones junto con ejemplos de códecs:
Ejemplo 1: uso del método “andThen()”
El desarrollador puede encadenar múltiples “ Consumidor ” operaciones en conjunto usando el “ y luego() ' método. Devuelve un nuevo “ Consumidor ” que realiza la operación de la corriente “ Consumidor ' instancia. Después de eso, cumple con las operaciones del próximo/después de “ Consumidor ' instancia. Es el método predeterminado que se utiliza ampliamente para el proceso de “ Composición ”.
La sintaxis para el ' y luego() El método ” se inserta a continuación:
y luego ( Consumidor < ? súper T > después )
El ' y luego() ” método combina el consumidor actual “ súper “con otro consumidor” después ”. Y ejecuta primero la operación del consumidor actual, seguida de la operación del consumidor proporcionado.
Veamos un programa para una mejor comprensión:
importar java.util.ArrayList;importar java.util.LinkedList;
importar java.util.List;
importar java.util.function.Consumer;
Raíz de clase pública {
vacío público estático principal ( Argumentos de cadena [ ] )
{
// creación del método principal
Consumidor < Lista < Entero > > multiplicar = dataEle - >
{
para ( int j = 0 ; j < dataEle.tamaño ( ) ; j++ ) {
dataEle.set ( j, 5 * datosEle.get ( j ) ) ;
}
} ;
// Consumidor para mostrar una lista de enteros
Consumidor < Lista < Entero > >
imprime = dataEle - > dataEle.stream ( ) .para cada ( k- > Sistema.fuera.imprimir ( k + ' ' ) ) ;
Lista < Entero > dataEle = nueva lista de matrices < Entero > ( ) ;
dataEle.añadir ( 4 ) ;
dataEle.añadir ( 7 ) ;
dataEle.añadir ( 12 ) ;
dataEle.añadir ( 16 ) ;
multiplicar y luego ( huellas dactilares ) .aceptar ( dataEle ) ;
}
}
Explicación del código anterior:
- Primero el ' Consumidor ”, “ Lista enlazada ” y las utilidades relacionadas se importan al archivo Java. Después de eso, la clase principal con el nombre “ Raíz ' es creado.
- A continuación, cree una interfaz de 'Consumidor' de tipo Lista denominada ' multiplicar ” y configúrelo igual a “ Lista de arreglo ” que se va a crear a continuación.
- Utiliza un “ para ” bucle que itera hasta la longitud de “ Lista de arreglo ' llamado ' dataEle ”, y multiplica cada elemento de datos del “ dataEle ' con ' 5 ”.
- Después de eso, un segundo “ Consumidor Se crea una interfaz que imprime cada elemento en la consola que se recupera después del proceso de multiplicación de un flujo.
- Ahora, cree y agregue elementos de datos ficticios en el ' dataEle ' Lista de arreglo.
- Al final, el “ y luego() El método ” se llama con el “ aceptar() 'método que acepta' dataEle ” ArrayList y devuelve el resultado de “ multiplicar ' en secuencia.
Después del final de la fase de ejecución:
La instantánea muestra que la tarea de multiplicación se ha completado utilizando el ' y luego() ” método de la “ Consumidor ' interfaz.
Ejemplo 2: uso del método 'aceptar ()'
El ' aceptar() El método ” es un método funcional del “ Consumidor ' interfaz. Acepta un solo argumento de tipo “ T ” y realiza las operaciones especificadas/necesarias en él. El valor de ' Nulo 'no se le debe proporcionar ya que no acepta' Nulo ” valores y generar una excepción.
Su sintaxis se da a continuación:
nulo aceptar ( < fuerte > T fuerte > t )
En la sintaxis anterior, el ' t ” es el único argumento sobre el que se operan ciertas operaciones.
Visitemos el siguiente bloque de código para una mejor comprensión:
importar java.util.ArrayList;importar java.util.LinkedList;
importar java.util.List;
importar java.util.function.Consumer;
// utilidades de importación en Java archivo
Raíz de clase pública {
vacío público estático principal ( Argumentos de cadena [ ] ) // creación del método principal
{
Consumidor < Entero > disipar = k - > Sistema.fuera.println ( k ) ;
disp.aceptar ( 255 ) ;
Consumidor < Lista < Entero > > multiplicar = dataEle - >
{
para ( int k = 0 ; k < dataEle.tamaño ( ) ; k ++ )
dataEle.set ( k, 5 * datosEle.get ( k ) ) ;
} ;
Consumidor < Lista < Entero > >
imprime = dataEle - > dataEle.stream ( ) .para cada ( j- > Sistema.fuera.imprimir ( j + '
' ) ) ;
Lista < Entero > dataEle = nueva lista de matrices < Entero > ( ) ;
dataEle.añadir ( 4 ) ;
dataEle.añadir ( 7 ) ;
dataEle.añadir ( 12 ) ;
dataEle.añadir ( 16 ) ;
// Implementar modificar usando aceptar ( )
multiplicar.aceptar ( dataEle ) ;
// Implementar dispList usando accept ( )
impresiones.aceptar ( dataEle ) ;
}
}
Explicación del código anterior:
- Primero el ' Consumidor 'interfaz llamada' disipar se crea ” que muestra los parámetros proporcionados en la consola, sin realizar ninguna operación.
- Ahora el ' aceptar() El método ” es llamado por el “ disipar ” Consumidor, y el valor de “ 255 ” se pasa a este método.
- A continuación, otro “ Consumidor se crea una interfaz que utiliza el para ” bucle para aplicar la multiplicación en cada elemento residente de ArrayList llamado “ dataEle ”.
- Después de eso, crea uno más “ Consumidor ” interfaz para mostrar el “ dataEle ” elementos resultan después de aplicar la multiplicación que viene de la corriente.
- A continuación, inicialice ArrayList “ dataEle ” con elementos de datos ficticios y utilizar el “ aceptar() ” método con el “ multiplicar ' interfaz.
- Al final, llame al “ aceptar() ” método usando el “ huellas dactilares ” interfaz para mostrar el resultado después de aplicar la multiplicación en el registro de la consola.
Después del final de la ejecución:
La instantánea anterior muestra que se han llamado varias interfaces de consumidor una a la vez usando el ' aceptar() ' método.
Ejemplo 3: Excepción de manejo para la función After
La Excepción surge cuando el “ después ” función de la “ y luego() El método ” contiene un “ aceptar() ' método. Esto crea una interfaz que contiene datos para ser procesados por interfaces que utilizan métodos de interfaz de consumidor como se muestra a continuación:
importar java.util.ArrayList;importar java.util.LinkedList;
importar java.util.List;
importar java.util.function.Consumer;
Raíz de clase pública {
vacío público estático principal ( Argumentos de cadena [ ] )
{
Consumidor < Lista < Entero > > multiplicar = datoEle - >
{
para ( int j = 0 ; j < = dataEle.tamaño ( ) ; j++ )
dataEle.set ( j, 5 * datosEle.get ( j ) ) ;
} ;
// Consumidor para mostrar una lista de enteros
Consumidor < Lista < Entero > >
imprimir = datoEle - > dataEle.stream ( ) .para cada ( i - > Sistema.fuera.imprimir ( yo + ' ' ) ) ;
Lista < Entero > dataEle = nueva lista de matrices < Entero > ( ) ;
dataEle.añadir ( 4 ) ;
dataEle.añadir ( 7 ) ;
dataEle.añadir ( 12 ) ;
dataEle.añadir ( 16 ) ;
intentar {
imprimir.yentonces ( multiplicar ) .aceptar ( dataEle ) ;
}
atrapar ( excepción e ) {
Sistema.fuera.println ( 'Excepción: ' + y ) ;
}
}
}
Explicación del bloque de código anterior:
- Primero el ' Consumidor 'Se crea una interfaz que simplemente multiplica' 5 ” enteros con los elementos de datos que residen en el ArrayList proporcionado.
- A continuación, el segundo “ Consumidor Se crea una interfaz para mostrar cada elemento de datos de ArrayList que recibe el flujo.
- Después de eso, ArrayList se crea y se inicializa con valores de tipo entero ficticio.
- Entonces el ' intentar Se utiliza el bloque ” en el que el “ y luego() El método ” es llamado por el “ imprimir ' interfaz.
- Provoca el “ IndexOutOfBoundsExceptionIndexOutOfBoundsException ' porque el ' para Se supera el límite de iteración del bucle, que se resuelve con “ atrapar ' bloquear.
Después del final de la fase de ejecución:
La instantánea muestra que el compilador ha generado IndexOutOfBoundsException.
Conclusión
El ' Consumidor La interfaz proporciona una forma de definir el comportamiento reutilizable y realizar acciones en los datos de entrada sin devolver un resultado. Consiste en ' aceptar() ' y ' y luego() ' métodos. A menudo se utiliza para tareas de procesamiento de datos, donde los usuarios deben realizar una acción en cada elemento de una colección o flujo. Eso es todo sobre el uso y la implementación de la interfaz del Consumidor en Java.