La structure du motif d'itérateur:
Le sous-motif itératif peut accéder à un élément agrégé séquentiellement sans exposer la représentation interne agrégée.
Les itératifs peuvent être divisés en itératifs externes et en itératifs internes .
Iterateur externe: adapté à l'agrégation de boîtes blanches (l'agrégation de boîtes blanches consiste à fournir au monde extérieur une agrégation qui accède à son interface d'élément interne). Étant donné que la logique itérative est fournie par l'objet d'agrégation lui-même, un tel sous-role itérateur externe ne maintient souvent que la position du curseur de l'itérative. Par conséquent, le sous-rôle itératif spécifique est une classe externe, et son constructeur accepte un objet agrégé spécifique, afin qu'il puisse appeler la logique itérative de l'objet agrégé.
Iterator intérieur: adapté à l'agrégation de boîtes noires (l'agrégation de boîtes noires ne fournit pas d'interface à l'extérieur pour traverser ses propres objets d'élément). Étant donné que les objets d'élément recueillis par Black Box ne peuvent être accessibles que par les membres internes agrégés, l'itérateur intérieur ne peut être qu'une sous-classe du membre à l'intérieur de l'agrégat.
Démonstration simple:
package test.edu.inter; Interface publique iteratorobj {/ ** * Déménager au premier élément * / public void first (); / ** * Passez à l'élément suivant * / public booléen hasnextItem (); / ** * Renvoie l'élément actuel * / objet public currentItem (); } package test.edu.inter; ensemble de données d'interface publique {public iteratorobj getIterator (); } package test.edu.inter; public class iterator1 implémente iteratorobj {private dataObj set; Taille INT privée; Index int privé = 0; public iterator1 (dataoBj set) {this.set = set; this.size = set.getSize (); } @Override public void first () {// TODO Méthode générée automatique Stub this.index = 0; } @Override public boolean hasnextItem () {if (index <size) {return true; } return false; } @Override public objet CurrentItem () {objet ob = set.getItem (index); if (index <size) {index ++; } return ob; }} package test.edu.inter; classe publique DataObj implémente le jeu de données {objet privé [] objArray = null; / ** * Objet agrégé entrant * / public dataObj (objet [] objArray) {this.objarray = objarray; } @Override public iteratorobj getIterator () {return new iterator1 (this); } Objet public getItem (int index) {return objArray [index]; } public int getSize () {return objArray.length; }} package test.edu.inter; Client de classe publique {/ ** * @param args * / public static void main (String [] args) {// TODO Méthode générée automatique Stub String [] str = {"12312", "dasda", "dasd", "12d", "asd"}; DataObj ao = new DataObj (str); IteratorObj io = ao.getIterator (); while (io.hasnextItem ()) {System.out.println (io.currentem ()); }}} Résultats en cours:
12312 DASDA DASD 12D ASD
Extension du contenu: applications dans l'agrégation Java
La méthode d'usine Iterator () est fournie dans l'interface java.util.collection pour renvoyer un objet de type itérateur. Le sous-type de l'interface de collection, la classe de membres interne ITR implémente l'interface itérateur. ITR est donc une sous-classe itérative intrinsèque, mais AbstractList fournit également sa propre méthode de traversée, ce n'est donc pas une agrégation de boîtes noires, mais une agrégation de boîtes blanches. Le code est le suivant:
Importer java.util.iterator; Interface publique ITR étend Iterator {// indicateur utilisé lors de l'appel à nouveau la méthode suivante () int cursor = 0; // indicateur utilisé dans le dernier appel lastret = -1; int attendModCount = modCount; public boolean hasnext () {return Cursor! = size (); } objet public next () {try {object next = get (cursor); checkForComodification (); lastret = cursor ++; retour ensuite; } catch (indexoutofboundSexception e) {checkForComodification (); lancer un nouveau nosuchementElementException (); }} // Supprimer le dernier élément traversé, la méthode supprime () ne peut supprimer que le dernier élément traversé public void retira () {if (lastret == - 1) lancez new illégalstateException (); checkForComodification (); try {abstractList.this.remove (lastret); if (lastet <curseur) curseur--; lastret = -1; attendModCount = modCount; } catch (indexOutofBoundSexception e) {Throw New ConcurrentModificationException (); }} public void checkForComodification () {if (modCount! = attendModCount) New concurrentModificationException (); }} Les variables et les méthodes telles que ModCount, GET (Cursor) appartiennent toutes à la classe AbstractList, et ITR peut être utilisée directement. La méthode CheckForComodification () vérifiera si le contenu agrégé vient d'être directement modifié par le monde extérieur (non modifié via la méthode supprimée () fournie par l'itérateur). Si le contenu rassemblé est contourné par le sous-objet itératif et modifié directement la nouvelle année après le sous-objet itératif, cette méthode lancera immédiatement une exception.
En outre: la classe AbstractList fournit également la méthode ListeTiterator (), renvoyant une instance de classe ListeTR qui implémente l'interface ListIterator. L'interface de ListIterator met en œuvre l'itération et l'itération inverse, et fournit également une méthode pour modifier en toute sécurité le contenu de la colonne pendant le processus d'itération.
La différence entre l'énumération et l'itérateur: (1) l'énumération n'a pas de méthode supprimée (2) l'énumération est implémentée en tant que classe sans nom dans la méthode élément () dans le vecteur. Il ne paie pas rapidement l'échec, c'est-à-dire pendant le processus d'itération, l'objet agrégé est modifié de manière inattendue par le monde extérieur, et ce processus d'itération fera immédiatement des exceptions.
Ce qui précède concerne cet article, j'espère qu'il sera utile à l'apprentissage de tout le monde.