La estructura del patrón de iterador:
El subtoterio iterativo puede acceder a un elemento agregado secuencialmente sin exponer la representación interna agregada.
Los iterativos se pueden dividir en iterativos externos y iterativos internos .
Iterador externo: adecuado para la agregación de cajas blancas (la agregación de caja blanca es proporcionar al mundo exterior una agregación que acceda a su interfaz de elementos internos). Dado que la lógica iterativa es proporcionada por el objeto de agregación en sí, dicho sub-rol de iterador externo a menudo solo mantiene la posición del cursor de la iterativa. Por lo tanto, el sub-rol iterativo específico es una clase externa, y su constructor acepta un objeto agregado específico, para que pueda llamar a la lógica iterativa de este objeto agregado.
Iterador interno: adecuado para la agregación de caja negra (la agregación de cajas negras no proporciona una interfaz al exterior para atravesar sus propios objetos de elementos). Dado que los objetos de elementos reunidos por Black Box solo pueden acceder a los miembros internos agregados, el iterador interno solo puede ser una subclase del miembro dentro del agregado.
Demostración simple:
paquete test.edu.inter; interfaz pública iteratorObj { / *** mudarse al primer elemento* / public void primero (); / *** Muévase al siguiente elemento*/ public boolean Hasnextitem (); / *** devuelve el elemento actual*/ public object currentItem (); } paquete test.edu.inter; DataSet de interfaz pública {public IteratorObj getIterator (); } paquete test.edu.inter; public class Iterator1 implementa iteratorObj {private dataObj set; tamaño privado int; Private int index = 0; public ITerator1 (set de dataBj) {this.set = set; this.size = set.getSize (); } @Override public void First () {// método generado automático TODO esto.index = 0; } @Override public boolean Hasnextitem () {if (index <size) {return true; } return false; } @Override Public Object CurrentItem () {Object ob = set.getItem (index); if (index <size) {index ++; } return OB; }} paquete test.edu.inter; clase pública dataBj implementa datos de datos {objeto privado [] objArray = null; / *** Objeto agregado entrante*/ public dataObj (objeto [] objarray) {this.objarray = objarray; } @Override public IteratorObj getIterator () {return new Iterator1 (this); } Public Object getItem (int index) {return objArray [index]; } public int getsize () {return objArray.length; }} paquete test.edu.inter; Cliente de clase pública { / ** * @param args * / public static void main (string [] args) {// tODO Auto Generado STUB String [] str = {"12312", "dasda", "dasd", "12d", "asd"}; DataObj ao = new dataObj (str); IteratorObj io = ao.getIterator (); while (io.hasnextitem ()) {system.out.println (io.currentitem ()); }}} Resultados de ejecución:
12312 Dasda Dasd 12d ASD
Expansión del contenido: aplicaciones en la agregación de Java
El método de fábrica Iterator () se proporciona en la interfaz java.util.collection para devolver un objeto de tipo iterador. El subtipo de la interfaz de colección, la clase de miembro interno ITR implementa la interfaz Iterator. Por lo tanto, ITR es una subclase iterativa intrínseca, pero AbstractList también proporciona su propio método transversal, por lo que no es una agregación de caja negra, sino una agregación de caja blanca. El código es el siguiente:
import java.util.iterator; la interfaz pública ITR extiende iterator {// indicador utilizado al llamar al método siguiente () nuevamente int cursor = 0; // Indicador utilizado en la última llamada lastret = -1; int esperadoModCount = modCount; public boolean Hasnext () {return cursor! = size (); } Public Object Next () {try {object next = get (cursor); checkforcomodification (); Lastret = cursor ++; regresar a continuación; } Catch (indexOuTOfBoundsexception e) {checkforcomodification (); tirar nueva nosuchelementException (); }} // Elimine el último elemento atravesado, el método RemoLE () solo puede eliminar el último elemento atravesado public Void Remout () {if (LASTRET ==-1) Lanzar nueva IllegalStateException (); checkforcomodification (); intente {abstractList.this.remove (Latret); if (lastret <cursor) cursor--; Lastret = -1; esperadoModCount = modCount; } Catch (indexOuTOfBoundSException e) {tirar nueva concurrenteModificationException (); }} public void checkforComOdification () {if (modCount! = esperadoModCount) tire nuevo concurrentModificationException (); }} Las variables y métodos como ModCount, GET (cursor) son propiedad de la clase AbstractList, e ITR se puede usar directamente. El método checkforcomodification () verificará si el contenido agregado acaba de ser modificado directamente por el mundo exterior (no modificado a través del método remove () proporcionado por el iterador). Si el contenido recopilado es omitido por el subobjeto iterativo y modifica directamente el nuevo año después del subobjeto iterativo, este método lanzará inmediatamente una excepción.
Además: la clase AbstractList también proporciona el método listIterator (), devolviendo una instancia de Listitr de clases que implementa la interfaz ListIterator. La interfaz ListIterator implementa la iteración y la iteración inversa, y también proporciona un método para modificar de forma segura el contenido de la columna durante el proceso de iteración.
La diferencia entre la enumeración y el iterador: (1) la enumeración no tiene un método eliminado (2) La enumeración se implementa como una clase sin nombre en el método Element () en el vector. No paga por fallas rápidamente, es decir, durante el proceso de iteración, el objeto agregado es modificado inesperadamente por el mundo exterior, y este proceso de iteración captará inmediatamente cualquier excepción.
Lo anterior se trata de este artículo, espero que sea útil para el aprendizaje de todos.