1. Aprimorado para visão geral
Apertado para o loop, também conhecido como loop foreach, é usado para atravessar matrizes e contêineres (aulas de coleta). Ao usar o forach para fazer um loop através de matrizes e elementos de coleta, não há necessidade de obter a matriz e o comprimento da coleta, não há necessidade de acessar elementos da matriz e elementos de coleta com base no índice, o que melhora bastante a eficiência e o código é muito mais simples.
2. A explicação do site oficial do Oracle
Então, quando você deve usar o loop for-Each? Qualquer vez que puder. É realmente bonito seu código. Infelizmente, você não pode usá -lo em todos os lugares. Considere, por exemplo, o método expurgate. O programa precisa de acesso ao iterador para remover o elemento atual. O loop for-cada esconde o iterador, para que você não possa chamar remoção. Portanto, o loop for-Eacha não é utilizável para filtragem. Da mesma forma, não é utilizável para loops, onde você precisa substituir elementos em uma lista ou matriz à medida que a percorre. Finalmente, não é utilizável para loops que devem iterar em várias coleções em paralelo. Essas deficiências eram conhecidas pelos designers, que tomaram uma decisão de consciência de seguir uma construção limpa e simples que cobriria a grande maioria dos casos.
Então, quando você deve usar o loop for-Each? Tudo bem a qualquer momento. Isso realmente embeleza seu código. Infelizmente, você não pode usá -lo em nenhum lugar. Considere essas situações, por exemplo, o método de exclusão. Para remover o elemento atual, o programa precisa acessar o iterador. O loop for-Each oculta o iterador, para que você não possa chamar a função de exclusão. Portanto, os loops para cada um não são adequados para elementos de filtragem. Além disso, os loops que precisam substituir os elementos ao iterar por meio de uma coleção ou matriz não são aplicáveis. Finalmente, não é adequado para o uso de loop paralelo em várias iterações de coleta. Os designers devem entender essas falhas e projetar conscientemente uma estrutura simples e limpa para evitar essas situações. Se você estiver interessado, pode visualizar a API do site oficial. Se você não sabe como encontrar a API no site oficial, clique para abrir o site oficial para visualizar o método da API.
3. Aprimore o formato para
para (digite Nome variável da coleção ou elemento da matriz: objeto de coleta ou objeto de matriz) {declaração java que referencia o nome da variável;}Site oficial Explicação:
para (TimerTask t: C)
T.Cancel ();
Quando você vê o cólon (:) Leia -o como "In". O loop acima parece como "para cada TimerTask t em c". Como você pode ver, o construto for-cada se combina lindamente com os genéricos. Preserva toda a segurança do tipo, enquanto remove a bagunça restante. Como você não precisa declarar o iterador, não precisa fornecer uma declaração genérica para isso. (O compilador faz isso por você nas suas costas, mas você não precisa se preocupar com ele.)
O significado geral é:
Quando você vê o cólon (:), ele diz "Entre". O loop acima diz "Viajando todos os elementos Timertosk em C". Como você pode ver, a estrutura for-ECH é perfeitamente combinada com genéricos. Ele mantém todos os tipos de segurança enquanto remove a confusão restante. Como você não precisa declarar o iterador, não precisa fornecer uma declaração genérica. (O compilador fez isso atrás de você, você não precisa se preocupar com isso.)
Uma experiência simples:
1. Aprimorado para matrizes de travessia
pacote cn.jason01; // aprimorado para traversal matric public class fortest01 {public static void main (string [] args) {int [] array = {1,2,3}; para (int elemento: Array) {System.out.println (elemento); }}}2. Apertado para coleções de travessia
pacote cn.jason01; importar java.util.arraylist; public class fortest {public static void main (string [] args) {// inferência genérica, você pode escrever ou não escrever string ArrayList <string> Array = new ArrayList (); Array.add ("A"); Array.add ("B"); Array.add ("C"); para (String String: Array) {System.out.println (String); }}}4. Aumente o princípio subjacente de
Veja o código primeiro
pacote cn.jason01; importar java.util.ArrayList; importar java.util.iterator;/** * aprimorado para o princípio subjacente * * @author Cassandra * @version 1.1 */public class, você não pode escrever o fortest {public static maid main (string [] args) {// genérico. Algumas especificações precisam ser escritas. ArrayList <String> Array = new ArrayList (); // Adicione o elemento Array.add ("A"); Array.add ("B"); Array.add ("C"); // aprimoramento para implementação System.out.println ("--- EIFIDADE para --- ---"); para (string: array). isto é, a implementação subjacente System.out.println ("--- compilação reversa ----"); string string; para (iterator iterator = array.iterator (); iterator.hasnext (); system.out.println (string)) {string = (string) iterator.next ();} // iterator implementa System.out.println ("---------"); for (iterator <string> i = array.iterator (); i.hasnext (); system.out.println (i.next ())))) {} // comum para implementar o sistema.out.println ("-----------"); for (int x = 0; x <array.size (); x ++) {System.out.println (Array.get (x));}}}A partir do código acima, podemos ver que a camada subjacente é implementada pelos iteradores e o aprimoramento para realmente oculta o iterador; portanto, o código natural é muito mais simples sem criar iteradores. Essa também é a razão pela qual o aprimoramento será lançado, que é reduzir o código, facilitar a travessia de coleções e matrizes e melhorar a eficiência.
NOTA: Como o aprimoramento para os iteadores de couros, ao usar o aprimoramento para atravessar coleções e matrizes, você deve primeiro determinar se é nulo; caso contrário, uma exceção de ponteiro nulo será lançado. O motivo é muito simples. A camada subjacente precisa usar um objeto de matriz ou coleta para chamar o método iterator () para criar um iterador (o iterador é uma interface, por isso precisa ser implementado com uma subclasse). Se for nulo, uma exceção será definitivamente lançada.
5. Aumente a aplicabilidade e as limitações de para
1. Aplicabilidade
Adequado para travessia de coleções e matrizes.
2. Limitações:
① O conjunto não pode ser nulo porque a camada subjacente é um iterador.
② O iterador está oculto, para que a coleção não possa ser modificada (adicionada e excluída) ao atravessar a coleção.
③ Cannot Marcas de ângulo de conjunto.
6. Explicação detalhada do uso de aprimoramento para
1. Uso aprimorado para em matrizes
pacote cn.jason05; importar java.util.ArrayList; importar java.util.list;/** * aprimorado para uso * * @author Cassandra */public class Fordemo {public static void main (string [] args) {// travesseiro {]; for (int x: arr) {System.out.println (x); }}}2. Aumente o uso de para as coleções
pacote cn.jason05; importar java.util.ArrayList; importar java.util.list;/** * aprimorado para uso * * @author Cassandra */public class fordemo {public static void main (string [] args) {// traver a coleção ArayList <Strack> Array.add ("Hello"); Array.add ("mundo"); Array.add ("Java"); para (String S: Array) {System.out.println (S); } // O conjunto é nulo, jogue uma lista de exceção do ponteiro nulo nullPointerException <Sling> List = null; if (list! = null) {for (string s: list) {system.out.println (s); }} // Aprimore a adição ou modificação de elementos para, lança uma exceção simultaneamente modificada de forma simulta }}3. A combinação perfeita de genéricos e aprimoramento para
Nota: Ele deve ser perfeitamente combinado com genéricos, caso contrário, você deve se transformar manualmente para baixo.
1. Nenhum efeito genérico, não pode usar o aprimoramento para
Aula de estudante
pacote cn.jason01; public class Student {private string name1; Nome de String Private2; public student () {super (); } public Student (Nome da String1, Nome da String2) {super (); this.name1 = name1; this.name2 = name2; } public string getName1 () {return name1; } public void setName1 (Nome da String1) {this.name1 = name1; } public string getName2 () {return name2; } public void setName2 (Nome da String2) {this.name2 = name2; }}Código de teste
pacote cn.jason01; importar java.util.ArrayList; importar java.util.iterator; importar java.util.list; public class Test02 {public static void main (string [] args) {// Create Set 1 List List1 = new Arraylist (); list1.add ("A"); list1.add ("b"); list1.add ("c"); // Criar set 2 List List2 = new ArrayList (); list2.add ("d"); list2.add ("e"); list2.add ("f"); // Crie Set três listas LIST3 = new ArrayList (); // atravessa os primeiros e os segundos conjuntos e adicione elementos para definir três para (iterator i = list1.iterator (); i.hasnext ();) {// System.out.println (i.next ()); String s = (string) i.Next (); for (iterador j = list2.iterator (); j.hasnext ();) {// list2.add (novo aluno (s, j.next ())); String ss = (string) j.Next (); list3.Add (novo aluno (S, SS)); }} // atravessa o conjunto três e produz o elemento Student st; para (iterador k = list3.Iterator (); k.hasnext (); system.out .println (new StringBuilder (). Append (St.getName1 ()). Append (St.getName2 ()))) {st = (Student) k.next (); }}}Se o código acima remover as duas linhas do comentário, o programa reportará um erro, porque a coleção não declarar que tipo é o elemento e o iterador naturalmente não sabe que tipo é. Portanto, se não houver genéricos, você precisará se transformar para baixo, só poderá usar iteradores, não aprimoramentos.
2. Genéricos e aprimoramentos para
Modifique o código acima
pacote cn.jason01; importar java.util.ArrayList; importar java.util.iterator; importar java.util.list;/** * aprimore a combinação perfeita de para e genéricos * * @author Cassandra */public class Test03 {public listat anul main (string [] args) {/10 strate skines 1 // cassandra */public list1.add ("A"); list1.add ("b"); list1.add ("c"); // Criar set 2 List <String> list2 = new ArrayList <String> (); list2.add ("d"); list2.add ("e"); list2.add ("f"); // Crie Set Set Three List <Ardencie> list3 = new ArrayList <ver -se> (); //// atravesse os primeiros e os segundos conjuntos e adicionam elementos para definir três para (String S1: List1) {for (String S2: List2) {list3.add (novo aluno (S1, S2)); }} // atravessa o conjunto três e os elementos de saída para (Student st: list3) {System.out.println (new StringBuilder (). Append (St.getName1 ()). Append (St.getName2 ())); }}}4. Quatro métodos de travessia de coleta de listas
Existe o método iterator () na interface de coleta, que retorna o tipo de iterador e possui um iterador como iterador. Existe um método listiterator () na lista, portanto, existe um listiterador de coleção adicional. Suas subclasses LinkedList, ArrayList e Vector implementam interfaces e interfaces de coleta, para que todos possam usar dois iteradores para atravessar.
Teste de código
pacote cn.jason05; importar java.util.ArrayList; importar java.util.iterator; importar java.util.list; importar java.util.Listiterator;/** ** esses são quatro métodos da lista de travessia. * @Author Cassandra */public class fordemo01 {public static void main (string [] args) {// crie uma lista de coleções <String> list = new ArrayList <String> (); list.add ("Hello"); list.add ("mundo"); list.add ("java"); // Método 1, iterador de iterador iterador <tring> i = list.iterator (); while (i.hasnext ()) {string s = i.next (); System.out.println (s); } // Método 2, listiterator iterator Traversal Collection Listiterator <String> lt = list.ListIterator (); while (lt.hasnext ()) {string ss = lt.next (); System.out.println (SS); } // Método 3, Ordinary for Traversal Collection for (int x = 0; x <list.size (); x ++) {string sss = list.get (x); System.out.println (SSS); } // Método 4, aprimore a coleção Traversal para (String SSSS: List) {System.out.println (SSS); }}}5.Set Método Traversal da Coleção em 2
Como a coleção de conjuntos não possui um método GET (INT INDEX), não há um método comum para o loop, não existe o método listiterator () no conjunto; portanto, não há iterador do Listiterator. Portanto, existem apenas duas maneiras de atravessar.
Teste de código
pacote cn.jason05; importar java.util.hashset; importar java.util.iterator; importar java.util.set; public class fortest03 {public static void main (string [] args) {set <tring> set = new Hashset <string> (); set.add ("hello"); set.add ("mundo"); set.add ("java"); // Método 1, iterador iterador iterador it = set.iterator (); while (it.hasnext ()) {System.out.println (it.Next ()); } // Método 2, aprimore a coleção Traversal para (String S: Set) {System.out.println (S); }}}7. Resumo
1. Aumente a aplicabilidade e as limitações de para
Aplicabilidade: aplicável a travessias de coleções e matrizes.
limitação:
① O conjunto não pode ser nulo porque a camada subjacente é um iterador.
② A marca do ângulo não pode ser definida.
③O iterador está oculto, para que a coleção não possa ser modificada (adicionada e excluída) ao atravessar a coleção.
2. Somente aprimorando a combinação de para e genéricos na coleção pode ser desempenhado o papel dos novos recursos.
3. É muito importante visualizar os novos recursos do site oficial. Você deve saber o motivo e o motivo. Somente sabendo disso em seu coração você pode usá -lo livremente.
O resumo mais completo do uso do loop for no artigo acima "Java New Recursos" é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.