Lors de l'apprentissage de la collection en Java, il est à noter que la collection d'interface racine de la hiérarchie de collection implémente l'interface ITable <T> (située dans le package java.lang), qui permet aux objets de devenir la cible de l'instruction "Foreach". La seule façon de cette interface est de renvoyer un itérateur qui itère sur un ensemble d'éléments de type T.
1. Iterator
Interface: iterator <T>
Interface publique Iterator <E> {Boolean Hasnext (); E suivant (); void retire (); }En regardant l'API de l'interface Iterator, vous pouvez savoir qu'il s'agit d'un itérateur qui itère sur la collection. L'itérateur permet à l'appelant de supprimer les éléments de la collection pointé par l'itérateur pendant l'itération en utilisant une sémantique bien définie.
Il est particulièrement remarquable que cette méthode de suppression () itératrice est utilisée: supprimez le dernier élément renvoyé par l'itérateur de la collection pointé par l'itérateur (opération facultative). Cette méthode ne peut être appelée qu'une seule fois par appel. Si la collection pointée par l'itérateur est modifiée par d'autres moyens que d'appeler cette méthode (supprimer la méthode) lors de l'itération, le comportement de l'itérateur est incertain. Lors de la conception de l'interface Iterator <T>, le concepteur d'interface a souligné que lors de l'itération, si la méthode Suppor () sauf l'itérateur est appelée et que la collection pointée par l'itérateur est modifiée, elle entraînera des conséquences incertaines. Quelles sont les conséquences en fonction de la mise en œuvre spécifique de l'itérateur. En réponse aux situations possibles de cette conséquence incertaine, l'une d'elles a été rencontrée lors de l'apprentissage de l'arraylist: l'itérateur lance une exception de laModification ConcurrentModification. Les exceptions spécifiques sont affichées dans le code suivant:
import java.util.arraylist; import java.util.collection; import java.util.iterator; public class itarAtOrest {public static void main (string [] args) {collection <string> list = new ArrayList <string> (); list.add ("Android"); list.add ("iOS"); list.add ("Windows Mobile"); Iterator <string> iterator = list.iterator (); while (iterator.hasnext ()) {String Lang = iterator.next (); list.remove (lang); // lancera concurrentModificationException}}} Ce code lancera une exception ConcurrentModificationException lors de l'exécution, car nous n'utiliserons pas la méthode Suppor () de l'itérateur pour supprimer l'élément lors de l'exécution de l'itérateur, mais utilisez plutôt la méthode Suppor () de ArrayList pour modifier la collection pointée par l'itérateur. Cela viole les principes de conception de l'itérateur, donc une exception se produit.
L'anomalie signalée est la suivante:
Exception dans Thread "Main" java.util.concurrentModificationException
sur java.util.arraylist $ ittr.checkforomodification (arraylist.java:859)
sur java.util.arraylist $ ittr.next (arrayList.java:831)
sur text.itaratortest.main (itaratortest.java:17)
2. Loop For-each et iterator Iterator <T>
À partir de Java 5, il y a une boucle for-out à Java, qui peut être utilisée pour faire une boucle dans la collection et le tableau. Les boucles ForEach vous permettent de traverser la collection sans appeler la méthode Hasnext () dans la boucle while sans maintenir l'index dans la boucle traditionnelle ou à utiliser Iterator / ListIterator (une implémentation d'Iterator dans ArrayList). La boucle For-out simplifie le processus de traversée de toute collection ou tableau. Cependant, il y a deux points auxquels faire attention lors de l'utilisation de boucles Foreach.
Les objets qui utilisent des boucles ForEach doivent implémenter l'interface itérable <T>
Veuillez consulter l'exemple suivant:
import java.util.arrayList; classe publique foreachTest1 {public static void main (String args []) {customCollection <string> myCollection = new CustomCollection <string> (); myCollection.add ("java"); myCollection.add ("scala"); myCollection.add ("groovy"); // Que fera ce code, imprimera le langage, lancez une exception ou // une erreur de temps de compilation pour (Langage String: MyCollection) {System.out.println (langue); }} classe privée CustomCollection <T> {Bucket Private ArrayList <T>; public CustomCollection () {Bucket = new ArrayList (); } public int size () {return Backet.size (); } public boolean isEmpty () {return Bucket.iSempty (); } public boolean contient (t o) {return Bucket.Contains (o); } public boolean add (t e) {return Backet.add (e); } public booléen retire (t o) {return Bucket.Remove (o); }}} Le code ci-dessus ne sera pas compilé, car la classe CustomCollection dans le code n'implémente pas l'interface itérable <T>, et l'erreur signalée pendant la période de compilation est la suivante:
Exception dans Thread "Main" Java.lang.Error: Problème de compilation non résolu:
Ne peut que parcourir un tableau ou une instance de java.lang.iterable
à text.ForEachTest1.main (foreachtest1.java:15)
En fait, il n'est pas nécessaire d'attendre la compilation pour trouver une erreur. Eclipse affichera une erreur dans la boucle foreach une fois le code terminé: ne peut quinter que sur un tableau ou une instance de java.lang.iterable
Il peut être confirmé à nouveau à partir de l'exemple ci-dessus que la boucle FOREACH ne s'applique qu'aux objets qui implémentent l'interface ITable <T>. Étant donné que toutes les classes de collecte intégrées implémentent l'interface java.util.collection et ont hérité itérable, afin de résoudre le problème ci-dessus, vous pouvez choisir de simplement permettre à CustomCollection de mettre en œuvre l'interface de collection ou d'Hériter AbstractCollection. La solution est la suivante:
import java.util.abstractCollection; import java.util.arraylist; import java.util.iterator; public class foreachTest {public static void main (String args []) {customCollection <string> myCollection = new CustomCollection <string> (); myCollection.add ("java"); myCollection.add ("scala"); myCollection.add ("groovy"); for (String Language: myCollection) {System.out.println (langue); }} classe statique privée CustomCollection <T> étend AbstractCollection <T> {Bucket Private ArrayList <T>; public CustomCollection () {Bucket = new ArrayList (); } public int size () {return Backet.size (); } public boolean isEmpty () {return Bucket.iSempty (); } public boolean contient (objet o) {return Bucket.Contains (o); } public boolean add (t e) {return Backet.add (e); } public boolean re Support (objet o) {return Bucket.Remove (o); } @Override public iterator <T> iterator () {// TODO Méthode générée automatique Stub Bucket.iterator (); }}}2. La mise en œuvre interne de la boucle Foreach est également mise en œuvre par itérateur.
Pour vérifier le fait que la boucle Foreach utilise Iterator comme implémentation interne, nous utilisons toujours l'exemple initial de cet article pour vérifier:
classe publique itaratorTest {public static void main (string [] args) {collection <string> list = new ArrayList <string> (); list.add ("Android"); list.add ("iOS"); list.add ("Windows Mobile"); // example1 // iterator <string> iterator = list.iterator (); // while (iterator.hasnext ()) {// String Lang = iterator.next (); // list.remove (Lang); //} // Exemple 2 pour (Langue String: List) {list.Remove (langue); }}} Exception signalée lorsque le programme s'exécute:
Exception dans Thread "Main" java.util.concurrentModificationException
sur java.util.arraylist $ ittr.checkforomodification (arraylist.java:859)
sur java.util.arraylist $ ittr.next (arrayList.java:831)
sur text.itaratortest.main (itaratortest.java:22)
Cette exception montre simplement que la boucle For-Een utilise Iterator pour itérer dans la collection, qui appelle également iterator.next (), qui vérifie (élément) modifie et lève une conception concurrentModificationException.
Résumer:
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.