Em Java, o “ Consumidor ” representa uma operação que recebe uma única entrada e executa alguma ação nela sem retornar um resultado. Ele também oferece uma maneira flexível de definir operações personalizadas que podem ser utilizadas na programação funcional, como expressões lambda. Este blog ilustra a implementação de uma interface Consumer em Java.
Como usar a interface do consumidor em Java?
O ' Consumidor ” oferece o encapsulamento ou comportamento que pode ser transmitido e executado em diferentes locais do programa. Ele promove um comportamento reutilizável que pode ser aplicado a diferentes entradas sem duplicar o código. A interface do consumidor consiste em dois métodos, a saber “ e então() ' e ' aceitar() ”.
Visite os exemplos abaixo para entender ambas as funções junto com exemplos de codec:
Exemplo 1: Uso do método “andThen()”
O desenvolvedor pode encadear vários “ Consumidor ” operações completamente usando o “ e então() ” método. Ele retorna um novo “ Consumidor ” que executa a operação do atual “ Consumidor ' instância. Depois disso, cumpre as operações do próximo/depois “ Consumidor ' instância. É o método padrão amplamente utilizado para o processo de “ Composição ”.
A sintaxe para o “ e então() ” é inserido abaixo:
e então ( Consumidor < ? super T > depois )
O ' e então() ” método combina o consumidor atual “ super ” com outro consumidor “ depois ”. E executa primeiro a operação do consumidor atual, seguida pela operação do consumidor fornecido.
Vamos percorrer um programa para uma melhor compreensão:
importar java.util.ArrayList;importar java.util.LinkedList;
importar java.util.List;
import java.util.function.Consumer;
raiz de classe pública {
public static void principal ( Argumentos de string [ ] )
{
// criação do método principal
Consumidor < Lista < inteiro > > multiplicar = dataEle - >
{
para ( int j = 0 ; j < dataEle.size ( ) ; j++ ) {
dataEle.set ( j, 5 * dataEle.get ( j ) ) ;
}
} ;
// Consumidor para exibir uma lista de números inteiros
Consumidor < Lista < inteiro > >
prints = dataEle - > dataEle.stream ( ) .para cada ( k- > System.out.print ( k + ' ' ) ) ;
Lista < inteiro > dataEle = new ArrayList < inteiro > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
multiplique.eDepois ( estampas ) .aceitar ( dataEle ) ;
}
}
Explicação do código acima:
- Primeiro, o “ Consumidor ”, “ LinkedList ” e utilitários relacionados são importados para o arquivo Java. Depois disso, a classe principal com o nome “ Raiz ' é criado.
- Em seguida, crie uma interface “Consumer” do tipo List chamada “ multiplicar ” e defini-lo igual ao “ ArrayList ” que será criado abaixo.
- Ele utiliza um “ para ” loop que itera até o comprimento de “ ArrayList 'chamado' dataEle ”, e multiplica cada elemento de dados do “ dataEle ' com ' 5 ”.
- Depois disso, um segundo “ Consumidor ” é criada a interface que imprime cada elemento no console que é recuperado após o processo de multiplicação de um fluxo.
- Agora, crie e adicione elementos de dados fictícios no “ dataEle ” ArrayList.
- No final, o “ e então() ” é chamado com o método “ aceitar() ” método que aceita “ dataEle ” ArrayList e retorna o resultado de “ multiplicar ' em sequência.
Após o término da fase de execução:
O instantâneo mostra que a tarefa de multiplicação foi concluída utilizando o botão “ e então() ” método do “ Consumidor ”interface.
Exemplo 2: Uso do método “accept()”
O ' aceitar() ” é um método funcional do método “ Consumidor ”interface. Ele aceita um único argumento do tipo “ T ” e executa as operações especificadas/necessárias nele. O valor de ' Nulo ” não deve ser fornecido a ele, pois não aceita “ Nulo ” valores e gerar uma exceção.
Sua sintaxe é dada a seguir:
anular aceitar ( < forte > T forte > t )
Na sintaxe acima, o “ t ” é o único argumento no qual certas operações são operadas.
Vamos visitar o bloco de código abaixo para um melhor entendimento:
importar java.util.ArrayList;importar java.util.LinkedList;
importar java.util.List;
import java.util.function.Consumer;
// utilitários de importação em Java arquivo
raiz de classe pública {
public static void principal ( Argumentos de string [ ] ) // criação do método principal
{
Consumidor < inteiro > disp = k - > System.out.println ( k ) ;
disp.accept ( 255 ) ;
Consumidor < Lista < inteiro > > multiplicar = dataEle - >
{
para ( int k = 0 ; k < dataEle.size ( ) ; k++ )
dataEle.set ( k, 5 * dataEle.get ( k ) ) ;
} ;
Consumidor < Lista < inteiro > >
prints = dataEle - > dataEle.stream ( ) .para cada ( j- > System.out.print ( j + '
' ) ) ;
Lista < inteiro > dataEle = new ArrayList < inteiro > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
// Implementar modificar usando aceitar ( )
multiplicar.aceitar ( dataEle ) ;
// Implementar dispList usando aceitar ( )
imprime.aceita ( dataEle ) ;
}
}
Explicação do código acima:
- Primeiro, o “ Consumidor ” interface chamada “ disp ” é criado, exibindo os parâmetros fornecidos no console, sem executar nenhuma operação.
- Agora o ' aceitar() ” método é chamado pelo método “ disp 'Consumidor, e o valor de' 255 ” é passado para este método.
- A seguir, outro “ Consumidor ” interface é criada que utiliza o “ para ” loop para aplicar a multiplicação em cada elemento residente do ArrayList chamado “ dataEle ”.
- Depois disso, crie mais um “ Consumidor ” para exibir o “ dataEle ” os elementos resultam após a aplicação da multiplicação que vem do fluxo.
- Em seguida, inicialize ArrayList “ dataEle ” com elementos de dados fictícios e utilizar o “ aceitar() ” método com o “ multiplicar ”interface.
- No final, ligue para o “ aceitar() ” usando o método “ estampas ” para exibir o resultado após aplicar a multiplicação no log do console.
Após o término da execução:
O instantâneo acima mostra que várias interfaces de consumidor foram chamadas uma de cada vez usando o comando “ aceitar() ” método.
Exemplo 3: Manipulando Exceção para After Function
A Exceção surge quando o “ depois ” função do “ e então() ” método contém um “ aceitar() ” método. Isso cria uma interface que contém dados a serem processados por interfaces usando métodos de interface Consumer, conforme mostrado abaixo:
importar java.util.ArrayList;importar java.util.LinkedList;
importar java.util.List;
import java.util.function.Consumer;
raiz de classe pública {
public static void principal ( Argumentos de string [ ] )
{
Consumidor < Lista < inteiro > > multiplicar = dadosEle - >
{
para ( int j = 0 ; j < = dataEle.size ( ) ; j++ )
dataEle.set ( j, 5 * dataEle.get ( j ) ) ;
} ;
// Consumidor para exibir uma lista de números inteiros
Consumidor < Lista < inteiro > >
imprimir = dadosEle - > dataEle.stream ( ) .para cada ( eu - > System.out.print ( eu + ' ' ) ) ;
Lista < inteiro > dataEle = new ArrayList < inteiro > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
tentar {
imprimir.eDepois ( multiplicar ) .aceitar ( dataEle ) ;
}
pegar ( Exceção e ) {
System.out.println ( 'Exceção: ' + e ) ;
}
}
}
Explicação do bloco de código acima:
- Primeiro, o “ Consumidor ” interface é criada que simplesmente múltipla “ 5 ” inteiros com os elementos de dados que residem no ArrayList fornecido.
- Em seguida, o segundo “ Consumidor ” é criada para exibir cada elemento de dados do ArrayList que é recebido pelo fluxo.
- Depois disso, o ArrayList é criado e inicializado com valores fictícios do tipo inteiro.
- Então o ' tentar ” bloco é utilizado em que o “ e então() ” método é chamado pelo método “ imprimir ”interface.
- Isso causa o “ IndexOutOfBoundsException ' porque o ' para ” o limite de iteração do loop é excedido, o que é resolvido por “ pegar ' bloquear.
Após o término da fase de execução:
O instantâneo mostra que IndexOutOfBoundsException foi gerado pelo compilador.
Conclusão
O ' Consumidor ” fornece uma maneira de definir o comportamento reutilizável e executar ações nos dados de entrada sem retornar um resultado. Isso consiste de ' aceitar() ' e ' e então() ' métodos. Geralmente é utilizado para tarefas de processamento de dados, onde os usuários precisam executar uma ação em cada elemento de uma coleção ou fluxo. Isso é tudo sobre o uso e implementação da interface Consumer em Java.