Para que servem as interfaces funcionais Consumer<T>, DoubleConsumer, IntConsumer e LongConsumer?

As interfaces funcionais Consumer<T>, DoubleConsumer, IntConsumer e LongConsumer são usadas para representar operações que aceitam um argumento de entrada e não retornam resultado. Elas fazem parte do pacote java.util.function.

• Consumer<T>: Aceita um argumento de qualquer tipo T.
• DoubleConsumer: Aceita um argumento do tipo double. É uma especialização primitiva de Consumer, o que permite evitar o autoboxing e funciona de forma mais eficiente.
• IntConsumer: Aceita um argumento do tipo int. Também é uma especialização primitiva para eficiência.
• LongConsumer: Aceita um argumento do tipo long. Outra especialização primitiva.

O uso principal dessas interfaces é em Lambdas e referências a métodos. Elas são frequentemente usadas na API de streams do Java para realizar efeitos colaterais nos elementos do stream, por exemplo, para imprimir na consola ou modificar um estado externo.

Exemplo de uso de Consumer<T>:

// Criar um Consumer que imprime uma string
Consumer<String> printConsumer = s -> System.out.println(s);

// Usar o Consumer
printConsumer.accept("Olá, mundo!");

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

Exemplo de uso de IntConsumer:

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

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

// Uso em um stream de ints primitivos
IntStream.range(1, 5).forEach(printIntConsumer); // Mais eficiente para tipos primitivos

As especializações primitivas (DoubleConsumer, IntConsumer, LongConsumer) devem ser preferidas aos seus análogos genéricos Consumer<T> ao trabalhar com tipos primitivos para melhorar o desempenho ao evitar operações de boxing/unboxing.