¿Para qué sirven las interfaces funcionales Consumer<T>, DoubleConsumer, IntConsumer y LongConsumer?

Las interfaces funcionales Consumer<T>, DoubleConsumer, IntConsumer y LongConsumer se utilizan para representar operaciones que aceptan un argumento de entrada y no devuelven resultado. Forman parte del paquete java.util.function.

• Consumer<T>: Acepta un argumento de cualquier tipo T.
• DoubleConsumer: Acepta un argumento de tipo double. Es una especialización primitiva de Consumer, lo que permite evitar el autoboxing y funciona de manera más eficiente.
• IntConsumer: Acepta un argumento de tipo int. También es una especialización primitiva para mejorar la eficiencia.
• LongConsumer: Acepta un argumento de tipo long. Otra especialización primitiva.

El uso principal de estas interfaces es en Lambdas y referencias a métodos. Se utilizan frecuentemente en la API de streams de Java para realizar efectos secundarios en los elementos del stream, por ejemplo, para imprimir en la consola o modificar un estado externo.

Ejemplo de uso de Consumer<T>:

// Crear un Consumer que imprime una cadena
Consumer<String> printConsumer = s -> System.out.println(s);

// Usar el Consumer
printConsumer.accept("¡Hola, mundo!");

// Uso en un stream
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream().forEach(n -> System.out.println(n)); // Uso de Consumer (lambda)

Ejemplo de uso de IntConsumer:

// Crear un IntConsumer que imprime un número
IntConsumer printIntConsumer = i -> System.out.println(i);

// Usar el IntConsumer
printIntConsumer.accept(10);

// Uso en un stream de ints primitivos
IntStream.range(1, 5).forEach(printIntConsumer); // Más eficiente para tipos primitivos

Las especializaciones primitivas (DoubleConsumer, IntConsumer, LongConsumer) deben preferirse a sus análogos genéricos Consumer<T> cuando se trabaja con tipos primitivos para mejorar el rendimiento al evitar operaciones de boxing/unboxing.