En Java, le ' Consommateur ” L'interface représente une opération qui reçoit une seule entrée et exécute une action dessus sans renvoyer de résultat. Il offre également un moyen flexible de définir des opérations personnalisées qui peuvent être utilisées dans la programmation fonctionnelle comme les expressions lambda. Ce blog illustre l'implémentation d'une interface Consumer en Java.
Comment utiliser l'interface consommateur en Java ?
Le ' Consommateur ” offre l'encapsulation ou le comportement qui peut être transmis et exécuté à différents endroits du programme. Il favorise un comportement réutilisable qui peut être appliqué à différentes entrées sans dupliquer le code. L'interface consommateur se compose de deux méthodes à savoir ' et puis() ' et ' accepter() ”.
Consultez les exemples ci-dessous pour comprendre les deux fonctions ainsi que des exemples de codec :
Exemple 1 : Utilisation de la méthode 'andThen()'
Le développeur peut enchaîner plusieurs « Consommateur ” opérations en utilisant le “ et puis() ' méthode. Il renvoie un nouveau ' Consommateur ' qui effectue l'opération du courant ' Consommateur ' exemple. Après cela, accomplit les opérations du prochain/après ' Consommateur ' exemple. C'est la méthode par défaut qui est largement utilisée pour le processus de ' Composition ”.
La syntaxe du ' et puis() ” méthode est insérée ci-dessous :
et puis ( Consommateur < ? super T > après )
Le ' et puis() « La méthode combine le consommateur actuel » super ' avec un autre consommateur ' après ”. Et il exécute d'abord l'opération du consommateur actuel, suivie de l'opération du consommateur fourni.
Passons en revue un programme pour une meilleure compréhension :
importer java.util.ArrayList ;importer java.util.LinkedList ;
importer java.util.List ;
import java.util.function.Consumer ;
Racine de la classe publique {
public statique vide principal ( Arguments de chaîne [ ] )
{
// création de la méthode principale
Consommateur < Liste < Entier > > multiplier = dataEle - >
{
pour ( entier j = 0 ; j < dataEle.size ( ) ; j++ ) {
dataEle.set ( j, 5 * dataEle.get ( j ) ) ;
}
} ;
// Consommateur pour afficher une liste d'entiers
Consommateur < Liste < Entier > >
imprime = dataEle - > dataEle.stream ( ) .pour chaque ( k- > System.out.print ( k + ' ' ) ) ;
Liste < Entier > dataEle = nouvelle ArrayList < Entier > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
multiplier.etpuis ( impressions ) .accepter ( dataEle ) ;
}
}
Explication du code ci-dessus :
- Premièrement la ' Consommateur ”, “ Liste liée ” et les utilitaires associés sont importés dans le fichier Java. Après cela, la classe principale avec le nom ' Racine ' est créé.
- Ensuite, créez une interface 'Consumer' de type List nommée ' multiplier ' et mettez-le égal à ' Liste des tableaux ” qui va être créé ci-dessous.
- Il utilise un ' pour ' boucle qui itère jusqu'à la longueur de ' Liste des tableaux ' nommé ' dataEle », et multiplie chaque élément de données du « dataEle ' avec ' 5 ”.
- Après cela, une seconde ' Consommateur ” Une interface est créée qui imprime chaque élément sur la console qui est récupéré après le processus de multiplication à partir d'un flux.
- Maintenant, créez et ajoutez des éléments de données factices dans le ' dataEle ' Liste des tableaux.
- Au final, le « et puis() ' la méthode est appelée avec le ' accepter() « méthode qui accepte » dataEle ' ArrayList et renvoie le résultat de ' multiplier ' en séquence.
Après la fin de la phase d'exécution :
L'instantané montre que la tâche de multiplication a été complétée en utilisant le ' et puis() 'méthode de la' Consommateur ” interface.
Exemple 2 : Utilisation de la méthode « accept() »
Le ' accepter() ” méthode est une méthode fonctionnelle de la “ Consommateur ” interface. Il accepte un seul argument de type ' J ” et effectue les opérations spécifiées/nécessaires dessus. La valeur de ' Nul ' ne doit pas lui être fourni car il n'accepte pas ' Nul ” valeurs et générer une exception.
Sa syntaxe est donnée ci-dessous :
annuler accepter ( < fort > J fort > t )
Dans la syntaxe ci-dessus, le ' t » est l'unique argument sur lequel s'opèrent certaines opérations.
Visitons ci-dessous le bloc de code pour une meilleure compréhension :
importer java.util.ArrayList ;importer java.util.LinkedList ;
importer java.util.List ;
import java.util.function.Consumer ;
// importation d'utilitaires dans Java déposer
Racine de la classe publique {
public statique vide principal ( Arguments de chaîne [ ] ) // création de la méthode principale
{
Consommateur < Entier > affichage = k - > System.out.println ( k ) ;
affichage. accepter ( 255 ) ;
Consommateur < Liste < Entier > > multiplier = dataEle - >
{
pour ( entier k = 0 ; k < dataEle.size ( ) ; k++ )
dataEle.set ( k, 5 * dataEle.get ( k ) ) ;
} ;
Consommateur < Liste < Entier > >
imprime = dataEle - > dataEle.stream ( ) .pour chaque ( j- > System.out.print ( j + '
' ) ) ;
Liste < Entier > dataEle = nouvelle ArrayList < Entier > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
// Implémenter modifier en utilisant accepter ( )
multiplier.accepter ( dataEle ) ;
// Implémenter dispList en utilisant accept ( )
impressions.accepter ( dataEle ) ;
}
}
Explication du code ci-dessus :
- Premièrement la ' Consommateur 'interface nommée' afficher ” est créé qui affiche les paramètres fournis sur la console, sans effectuer aucune opération.
- Maintenant le ' accepter() ” méthode est appelée par le “ afficher « Consommateur, et la valeur de » 255 ” est passé à cette méthode.
- Ensuite, un autre ' Consommateur ” interface est créée qui utilise le “ pour ' boucle pour appliquer la multiplication sur chaque élément résidant de la ArrayList nommé ' dataEle ”.
- Après cela, créez-en un de plus ' Consommateur ” interface pour afficher le “ dataEle ” Les éléments résultent après l'application de la multiplication provenant du flux.
- Ensuite, initialisez ArrayList ' dataEle ' avec des éléments de données factices et utilisez le ' accepter() ' méthode avec le ' multiplier ” interface.
- À la fin, appelez le ' accepter() ' méthode en utilisant le ' impressions ” pour afficher le résultat après application de la multiplication sur le journal de la console.
Après la fin de l'exécution :
L'instantané ci-dessus montre que plusieurs interfaces consommateur ont été appelées une à la fois à l'aide de la commande ' accepter() ' méthode.
Exemple 3 : Gestion des exceptions pour la fonction After
L'exception survient lorsque le ' après ' fonction du ' et puis() ” méthode contient un “ accepter() ' méthode. Cela crée une interface qui contient les données à traiter par les interfaces à l'aide des méthodes d'interface consommateur comme indiqué ci-dessous :
importer java.util.ArrayList ;importer java.util.LinkedList ;
importer java.util.List ;
import java.util.function.Consumer ;
Racine de la classe publique {
public statique vide principal ( Arguments de chaîne [ ] )
{
Consommateur < Liste < Entier > > multiplier = dataEle - >
{
pour ( entier j = 0 ; j < = dataEle.taille ( ) ; j++ )
dataEle.set ( j, 5 * dataEle.get ( j ) ) ;
} ;
// Consommateur pour afficher une liste d'entiers
Consommateur < Liste < Entier > >
imprimer = dataEle - > dataEle.stream ( ) .pour chaque ( je - > System.out.print ( je + ' ' ) ) ;
Liste < Entier > dataEle = nouvelle ArrayList < Entier > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
essayer {
print.andThen ( multiplier ) .accepter ( dataEle ) ;
}
attraper ( Exception e ) {
System.out.println ( 'Exception: ' + et ) ;
}
}
}
Explication du bloc de code ci-dessus :
- Premièrement la ' Consommateur ' l'interface est créée qui simplement multiple ' 5 ” entiers avec les éléments de données résidant dans la ArrayList fournie.
- Ensuite, le deuxième ' Consommateur ” est créée pour afficher chaque élément de données de la ArrayList reçu par le flux.
- Après cela, la ArrayList est créée et initialisée avec des valeurs de type entier factices.
- Puis le ' essayer ” bloc est utilisé dans lequel le “ et puis() ” méthode est appelée par le “ imprimer ” interface.
- Il provoque le « IndexOutOfBoundsExceptionIndexOutOfBoundsException ' parce que le ' pour ' la limite d'itération de la boucle est dépassée, ce qui est résolu par ' attraper ' bloc.
Après la fin de la phase d'exécution :
L'instantané montre que IndexOutOfBoundsException a été généré par le compilateur.
Conclusion
Le ' Consommateur ” fournit un moyen de définir un comportement réutilisable et d'effectuer des actions sur les données d'entrée sans renvoyer de résultat. Cela consiste en ' accepter() ' et ' et puis() ” méthodes. Il est souvent utilisé pour les tâches de traitement de données, où les utilisateurs doivent effectuer une action sur chaque élément d'une collection ou d'un flux. Il s'agit de l'utilisation et de l'implémentation de l'interface consommateur en Java.