A estrutura do padrão do iterador:
O sub-padrão iterativo pode acessar um elemento agregado sequencialmente sem expor a representação interna agregada.
Iterativos podem ser divididos em iterativos externos e iterativos internos .
Iterador externo: Adequado para a agregação de caixas brancas (a agregação de caixas brancas é fornecer ao mundo exterior uma agregação que acessa sua interface de elemento interno). Como a lógica iterativa é fornecida pelo próprio objeto de agregação, esse sub-suporte de iterador externo geralmente mantém apenas a posição do cursor da iterativa. Portanto, o sub-role iterativo específico é uma classe externa e seu construtor aceita um objeto agregado específico, para que possa chamar a lógica iterativa desse objeto agregado.
Iterador interno: Adequado para agregação de caixas pretas (a agregação da caixa preta não fornece uma interface para o exterior para atravessar seus próprios objetos de elemento). Como os objetos de elemento coletados pela Black Box só podem ser acessados pelos membros internos agregados, o iterador interno pode ser apenas uma subclasse do membro dentro do agregado.
Demonstração simples:
pacote test.edu.inter; interface pública iteratorObj { / *** mova -se para o primeiro elemento* / public void primeiro (); / *** mova -se para o próximo elemento*/ público boolean hasNextItem (); / *** Retorne o elemento atual*/ public Object currentItem (); } pacote test.edu.inter; DataSet de interface pública {public iteratorObj getIterator (); } pacote test.edu.inter; classe pública iterator1 implementa o iteratorObj {private DATABJ Set; Tamanho privado int; private int index = 0; public iterator1 (conjunto de dados) {this.set = set; this.size = set.getSize (); } @Override public void First () {// TODO Método Gerado Automotor Stub this.index = 0; } @Override public boolean hasNextItem () {if (index <size) {return true; } retornar false; } @Override public Object currentItem () {objeto ob = set.getItem (index); if (índice <tamanho) {index ++; } retornar ob; }} pacote test.edu.inter; classe pública DataOBJ implementa o conjunto de dados {objeto privado [] objarray = null; / *** Objeto agregado recebido*/ public DATOBJ (objeto [] objarray) {this.objarray = objarray; } @Override public iteratorObj getIterator () {return new iterator1 (this); } public objeto getItem (int index) {return objarray [index]; } public int getSize () {return objarray.length; }} pacote test.edu.inter; public class Client { / ** * @param args * / public static void main (string [] args) {// TODO Method Auto-Gerated Stub String [] str = {"12312", "DASDA", "DASD", "12D", "ASD"}; DATABJ AO = novo DATABJ (STR); IteratorObj io = ao.getIterator (); while (io.hasnextItem ()) {System.out.println (io.currentItem ()); }}} Resultados em execução:
12312 DASDA DASD 12D ASD
Expansão de conteúdo: aplicativos na agregação de Java
O método de fábrica iterator () é fornecido na interface java.util.Collection para retornar um objeto do tipo iterador. O subtipo da interface de coleção, a classe de membro interna ITR implementa a interface do iterador. Portanto, o ITR é uma subclasse iterativa intrínseca, mas a AbstractList também fornece seu próprio método de travessia, por isso não é uma agregação de caixas pretas, mas uma agregação de caixas brancas. O código é o seguinte:
importar java.util.iterator; interface pública ITR estende o iterador {// indicador usado ao chamar o método a seguir () novamente int cursor = 0; // indicador usado na última chamada lastret = -1; int esperamodCount = modCount; public boolean hasNext () {return cursor! = size (); } public objeto a seguir () {tente {objeto a seguir = get (cursor); checkForComodification (); lastret = cursor ++; retornar a seguir; } catch (indexOutOfBoundSexception e) {checkForComodification (); lançar novos nosuchElementException (); }} // Excluir o último elemento atravessado, o método remover () pode excluir apenas o último elemento atravessado public void remover () {if (lastret ==-1) lançar novo ilegalStateException (); checkForComodification (); tente {abstractList.this.remove (lastret); if (lastret <cursor) cursor--; lastret = -1; esperadomodCount = modCount; } catch (indexOutOfBoundSexception e) {tiro novo concurrentModificationException (); }} public void checkForComodification () {if (modCount! = esperadoModCount) lança novo concurrentModificationException (); }} As variáveis e métodos como o ModCount, GET (Cursor) são de propriedade da classe abstractList, e o ITR pode ser usado diretamente. O método checkForComOdification () verificará se o conteúdo agregado acabou de ser modificado diretamente pelo mundo exterior (não modificado através do método Remow () fornecido pelo iterador). Se o conteúdo coletado for ignorado pelo subobjeto iterativo e modificado diretamente o ano novo após o subobjeto iterativo, esse método lançará imediatamente uma exceção.
Além disso: a classe AbstractList também fornece o método listiterator (), retornando uma instância de classe listitr que implementa a interface do listiterator. A interface do Listiterator implementa a iteração a termo e a iteração reversa e também fornece um método para modificar com segurança o conteúdo da coluna durante o processo de iteração.
A diferença entre enumeração e iterador: (1) A enumeração não possui um método de remoção (2) a enumeração é implementada como uma classe sem nome no método elemento () no vetor. Ele não paga rapidamente, ou seja, durante o processo de iteração, o objeto agregado é inesperadamente modificado pelo mundo exterior, e esse processo de iteração captará imediatamente qualquer exceção.
O exposto acima é tudo sobre este artigo, espero que seja útil para o aprendizado de todos.