Le ' itérateur ” offre un moyen sûr et facile de supprimer ou de supprimer des éléments de données spécifiques d'une collection tout en itérant dessus. Il empêche l'apparition de ' ConcurrentModificationExceptionConcurrentModificationException ” qui survient lorsque la boucle for améliorée tente de modifier la collection. Il stocke la trace de la position actuelle et offre aux programmeurs la possibilité d'avancer et de supprimer les éléments sous-jacents si nécessaire.
Ce blog montre le processus de suppression d'un élément d'une collection en utilisant la méthode de l'itérateur.
Comment utiliser la méthode Iterator pour supprimer un élément d'une collection en Java ?
La méthode de l'itérateur est unidirectionnelle et peut être utilisée avec différents types de collections, notamment ' ArrayList', 'LinkedList ', etc. Il offre un moyen uniforme de supprimer des éléments de toute collection qui implémente le ' Itérable ” interface.
Voyons quelques exemples pour mieux comprendre la méthode iterator :
Exemple 1 : Suppression d'éléments spécifiques de la collection à l'aide de la méthode Iterator
La méthode de l'itérateur peut être utilisée avec ' si ” ou des boucles pour sélectionner les éléments spécifiés. Et puis le « retirer ()' est utilisée pour effectuer l'opération de suppression comme indiqué ci-dessous :
importer java.util.* ;
classe Iterexamen
{
public statique annuler principal ( Chaîne [ ] arguments )
{
Liste des tableaux < Entier > démoArrListe = nouveau Liste des tableaux < Entier > ( ) ;
pour ( entier je = 0 ; je <= vingt ; je = je + 2 )
{
demoArrList. ajouter ( je ) ;
}
Itérateur < Entier > itr = demoArrList. itérateur ( ) ;
Système . dehors . println ( 'Liste de tableaux fournie :' ) ;
pour ( entier je = 0 ; je < demoArrList. taille ( ) ; je ++ )
{
Système . dehors . imprimer ( demoArrList. obtenir ( je ) + ' ' ) ;
}
alors que ( itr. aSuivant ( ) )
{
si ( itr. suivant ( ) % 3 == 0 )
itr. retirer ( ) ;
}
Système . dehors . println ( ' \n Après avoir supprimé les éléments Odd ArrayList' ) ;
pour ( entier je = 0 ; je < demoArrList. taille ( ) ; je ++ )
{
Système . dehors . imprimer ( demoArrList. obtenir ( je ) + ' ' ) ;
}
}
}
Description du code ci-dessus :
- Tout d'abord, la ArrayList est créée, puis un multiple de ' 2 ' est inséré jusqu'à la plage de ' vingt ' avec l'aide du ' pour ' boucle.
- Ensuite, déclarez un ' itérateur ” objet de méthode pour afficher les éléments de ArrayList sur la console.
- Ensuite, utilisez le ' aSuivant ()' avec l'objet itérateur pour parcourir tous les éléments ArrayList résidants.
- Après cela, le « si ” est utilisée pour vérifier les éléments entièrement divisibles par “ 3 ' à l'intérieur.
- Puis le ' retirer ()' permet de supprimer les éléments renvoyés par la méthode ' si ' déclaration.
- Au final, la ArrayList mise à jour a été affichée en utilisant le ' pour ' boucle.
Après compilation :
La sortie affiche les éléments spécifiques, qui sont divisibles par trois et supprimés de ArrayList à l'aide d'une méthode d'itération.
Exemple 2 : suppression de tous les éléments de la collection
Pour supprimer tous les éléments résidants de la collection, la méthode iterator peut être utilisée avec son ' retirer ()' comme indiqué ci-dessous :
importer java.util.* ;classe Vide
{
public statique annuler principal ( Chaîne argument [ ] )
{
Vecteur < Entier > testVector = nouveau Vecteur < Entier > ( ) ;
testVector. ajouter ( 18 ) ;
testVector. ajouter ( vingt-et-un ) ;
testVector. ajouter ( 25 ) ;
testVector. ajouter ( 27 ) ;
testVector. ajouter ( 30 ) ;
Itérateur < Entier > traverser = testVector. itérateur ( ) ;
Système . dehors . imprimer ( 'Éléments existants :' ) ;
alors que ( traverser. aSuivant ( ) )
Système . dehors . imprimer ( traverser. suivant ( ) + ' ' ) ;
Système . dehors . imprimer ( ' \n Le testVector contient ' + testVector. taille ( ) + ' éléments ' ) ;
traverser = testVector. itérateur ( ) ;
alors que ( traverser. aSuivant ( ) )
{
Système . dehors . imprimer ( ' \n supprimer ' + traverser. suivant ( ) ) ;
traverser. retirer ( ) ;
}
Système . dehors . println ( ' \n Maintenant, le testVector contient ' + testVector. taille ( ) + ' éléments' ) ;
}
}
Descriptif du code :
- Tout d'abord, déclarez et initialisez ' Vecteur ' avec des valeurs de type entier factices en utilisant le ' ajouter ()' méthode.
- Ensuite, créez une méthode itérative qui utilise le ' aSuivant ()' et ' suivant () ». Il affiche les éléments de données résidants et leur taille correspondante.
- Ensuite, utilisez le ' aSuivant ()' propriété le long de l'objet itérateur à l'intérieur de la ' alors que ' boucle.
- Après cela, utilisez le ' suivant ()' méthode pour sélectionner l'élément à venir, puis, le retirer () est appelée pour supprimer chaque élément récepteur.
- De cette manière, tous les éléments du Vector sont supprimés et la taille du Vector s'affiche sur la console.
Descriptif du code :
Le code ci-dessus confirme que tous les éléments de la collection ont été supprimés.
Exemple 3 : Suppression d'un élément à l'aide de ListIterator
Le ListIterator fonctionne de la même manière que la méthode iterator. Le ListIterator effectue un parcours des deux côtés dans les sens avant et arrière. Pour supprimer des éléments spécifiques de la collection à l'aide de ListIterator en Java, consultez le code ci-dessous :
importer java.util.ArrayList ;importer java.util.ListIterator ;
public classe ListIteratorDemo {
//Initialisation de la méthode main()
public statique annuler principal ( Chaîne [ ] arguments )
{ //Déclaration et initialisation de la ArrayList
Liste des tableaux < Chaîne > grandi = nouveau Liste des tableaux < Chaîne > ( ) ;
grandi ajouter ( 'Sweatshirt à capuche' ) ;
grandi ajouter ( 'Pôle' ) ;
grandi ajouter ( 'Henleys' ) ;
grandi ajouter ( 'Sueur' ) ;
grandi ajouter ( 'Occasionnel' ) ;
grandi ajouter ( 'Luxe' ) ;
grandi ajouter ( 'Dryfit' ) ;
Itérateur de liste < Chaîne > litre = grandi itérateur de liste ( ) ;
Système . dehors . println ( 'Liste avant suppression' ) ;
pour ( entier je = 0 ; je < grandi taille ( ) ; je ++ )
Système . dehors . imprimer ( grandi obtenir ( je ) + ' ' ) ;
alors que ( litre. aSuivant ( ) ) {
si ( litre. suivant ( ) . équivaut à ( 'Sueur' ) ) {
litre. retirer ( ) ;
}
}
Système . dehors . println ( ' \n Liste après suppression' ) ;
pour ( entier je = 0 ; je < grandi taille ( ) ; je ++ )
Système . dehors . imprimer ( grandi obtenir ( je ) + ' ' ) ;
}
}
Description du code ci-dessus :
- Tout d'abord, déclarez et initialisez ArrayList avec les valeurs factices de type String et affichez tous les éléments sur la console à l'aide du ' pour ' boucle.
- Ensuite, créez un objet qui appelle le ' aSuivant ()' méthode à l'intérieur de la ' alors que ' boucle. Il traverse tous les éléments résidants.
- Puis le ' si ' est utilisée pour vérifier chaque élément avec un texte spécifique, lorsque cet élément correspond à la ' retirer ()' est appelée. Il supprime l'élément spécifique du ' aArt ” nommée ArrayList.
- Au final, affichez la ArrayList modifiée sur la console.
Après compilation :
L'instantané confirme que l'élément de données spécifié a été supprimé de la collection à l'aide de ListIterator.
Conclusion
Pour supprimer l'élément d'une collection, le ' retirer ()' de l'itérateur est utilisée. L'itérateur parcourt la ArrayList pour trouver les données ciblées. Une fois trouvé, le ' retirer () » est utilisée pour supprimer cet élément de données spécifique. Il offre une technique standardisée à travers différentes collections et évite les problèmes et l'apparition de plusieurs exceptions telles que ' ConcurrentModificationExceptionConcurrentModificationException ”. Parallèlement, le « Itérateur de liste ' peut également être utile.