La interfaz DoubleConsumer es parte del paquete java.util.function que se introdujo desde Java 8 para implementar la programación funcional en Java. Representa una función que toma un argumento de doble valor pero no devuelve ningún valor.
La expresión lambda asignada a un objeto de tipo DoubleConsumer se usa para definir su accept() que eventualmente aplica la operación dada en su único argumento. Es similar a usar un objeto de tipo Consumer <Double>
La interfaz DoubleConsumer consta de las siguientes dos funciones:
aceptar()
Este método acepta un valor y realiza la operación en su único argumento.
Sintaxis:
void accept(double value)
Parámetros: Este método toma solo un parámetro:
- valor – el argumento de entrada
Devoluciones: este método no devuelve ningún valor.
A continuación se muestra el código para ilustrar el método accept():
import java.util.function.DoubleConsumer;
public class GFG {
public static void main(String args[])
{
// Create a DoubleConsimer Instance
DoubleConsumer
display
= a -> System.out.println(a * 10);
// using accept() method
display.accept(3);
}
}
30.0
y entonces()
Devuelve un DoubleConsumer compuesto en el que el DoubleConsumer parametrizado se ejecutará después del primero. Si la evaluación de cualquiera de las operaciones arroja un error, se transmite al llamador de la operación compuesta.
Nota: La operación que se pasa como argumento debe ser del tipo DoubleConsumer .
Sintaxis:
default DoubleConsumer andThen(DoubleConsumer after)
Parámetros: este método acepta un parámetro después del cual se aplica el DoubleConsumer después del actual.
Valor de retorno: este método devuelve un DoubleConsumer compuesto que primero aplica la operación actual primero y luego la operación posterior.
Excepción: este método arroja NullPointerException si la operación posterior es nula.
A continuación se muestra el código para ilustrar el método andThen():
Programa 1:
import java.util.function.DoubleConsumer;
public class GFG {
public static void main(String args[])
{
// Create a DoubleConsimer Instance
DoubleConsumer display = a -> System.out.println(a * 10);
DoubleConsumer mul = a -> a /= 2;
// using addThen() method
DoubleConsumer composite = mul.andThen(display);
composite.accept(3);
}
}
30.0
Programa 2: para demostrar cuándo se devuelve NullPointerException .
import java.util.function.DoubleConsumer;
public class GFG {
public static void main(String args[])
{
// Create a DoubleConsimer Instance
DoubleConsumer mul = a -> a /= 10;
try {
// using addThen() method
DoubleConsumer composite = mul.andThen(null);
composite.accept(3);
}
catch (Exception e) {
System.out.println("Exception : " + e);
}
}
}
Exception : java.lang.NullPointerException
Programa 3: para demostrar cómo se devuelve y se maneja una excepción en la función posterior.
import java.util.function.DoubleConsumer;
public class GFG {
public static void main(String args[])
{
try {
DoubleConsumer
conv
= a
-> System.out.println(
Integer
.parseInt(
Double
.toString(a)));
DoubleConsumer mul = a -> a /= 10;
// using addThen() method
DoubleConsumer composite = mul.andThen(conv);
composite.accept(3);
}
catch (Exception e) {
System.out.println("Exception : " + e);
}
}
}
Exception : java.lang.NumberFormatException: For input string: "3.0"