1. Mejorado para una visión general
Mejorado para bucle, también conocido como foreach loop, se usa para atravesar matrices y contenedores (clases de recolección). Cuando se usa Foreach para recorrer matrices y elementos de recolección, no es necesario obtener la matriz y la longitud de la colección, no es necesario acceder a elementos de matriz y elementos de recolección en función del índice, lo que mejora enormemente la eficiencia y el código es mucho más simple.
2. La explicación del sitio web oficial de Oracle
Entonces, ¿cuándo debe usar el bucle for-ENTRA? Cada vez que puedas. Es realmente hermoso tu código. Desafortunadamente, no puedes usarlo en todas partes. Considere, por ejemplo, el método expurgado. El programa necesita acceso al iterador para eliminar el elemento actual. El bucle for-ENTRA oculta el iterador, por lo que no puede llamar eliminar. Por lo tanto, el bucle for-ENaleal no se puede utilizar para filtrar. Del mismo modo, no se puede utilizar para bucles donde necesita reemplazar elementos en una lista o matriz a medida que lo atraviesa. Finalmente, no se puede usar para los bucles que deben iterar en múltiples colecciones en paralelo. Estas deficiencias fueron conocidas por los diseñadores, quienes tomaron una decisión de conciencia de ir con una construcción limpia y simple que cubriría la gran mayoría de los casos.
Entonces, ¿cuándo debe usar el bucle for-ENTRA? Está bien en cualquier momento. Esto realmente embellece tu código. Desafortunadamente, no puedes usarlo en ningún lado. Considere estas situaciones, por ejemplo, el método de eliminación. Para eliminar el elemento actual, el programa debe acceder al iterador. El bucle for-ENTRA oculta el iterador, por lo que no puede llamar a la función Eliminar. Por lo tanto, los bucles para cada uno no son adecuados para filtrar elementos. Además, los bucles que necesitan reemplazar elementos al iterar a través de una colección o matriz no son aplicables. Finalmente, no es adecuado para el uso de bucle paralelo en múltiples iteraciones de recolección. Los diseñadores deben comprender estos defectos y diseñar conscientemente una estructura limpia y simple para evitar estas situaciones. Si está interesado, puede ver la API del sitio web oficial. Si no sabe cómo encontrar la API en el sitio web oficial, haga clic para abrir el sitio web oficial para ver el método API.
3. Mejorar el formato para
para (tipo de nombre variable de colección o elemento de matriz: objeto de colección o objeto de matriz) {Declaración Java que hace referencia al nombre de la variable;}Explicación del sitio web oficial:
para (TimeTask T: C)
T.Cancel ();
Cuando ves el colon (:) Léelo como "adentro". El bucle anterior se lee como "para cada TimeTask t en c". Como puede ver, la construcción for-ENRTIGURA se combina maravillosamente con los genéricos. Preserva toda la seguridad del tipo, al tiempo que elimina el desorden restante. Debido a que no tiene que declarar el iterador, no tiene que proporcionar una declaración genérica para ello. (El compilador hace esto por usted a sus espaldas, pero no necesita preocuparse por ello).
El significado general es:
Cuando ves el colon (:), se lee "Entra". El bucle anterior dice "Viajando cada elemento TimerTask en c". Como puede ver, la estructura para cada uno se combina perfectamente con genéricos. Conserva todo tipo de seguridad al tiempo que elimina la confusión restante. Debido a que no tiene que declarar el iterador, no tiene que proporcionarle una declaración genérica. (El compilador lo ha hecho detrás de ti, no necesitas preocuparte por eso).
Una experiencia simple:
1. Mejorado para matrices de transversal
paquete cn.jason01; // mejorado para la matriz transversal clase pública fortest01 {public static void main (string [] args) {int [] array = {1,2,3}; for (int elemento: array) {system.out.println (elemento); }}}2. Mejorado para colecciones de transversal
paquete cn.jason01; import java.util.arrayList; public class fortest {public static void main (string [] args) {// Inferencia genérica, puede escribir o no escribir string arrayList <String> array = new ArrayList (); array.add ("a"); array.add ("b"); array.add ("c"); for (string string: array) {System.out.println (string); }}}4. Mejorar el principio subyacente de para
Mira el código primero
paquete cn.Jason01; import java.util.arrayList; import java.util.iterator;/** * mejorado para el principio subyacente * * @author cassandra * @version 1.1 */public class fortest {public static void main (string [] args) {// Inferencia genérica, puede escribir más tarde o no. Se deben escribir algunas especificaciones. ArrayList <String> array = new ArrayList (); // Agregar elemento Array.Add ("A"); Array.add ("B"); Array.add ("C"); // Mejora para la implementación System.out.println ("-----mejorado para -----"); es decir, el principio de implementación subyacente System.out.println ("--- Compilar inverso ----"); cadena de cadena; for (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 ()))) {} // ordinario para implementar System.out.println ("-----------"); for (int x = 0; x <array.size (); x ++) {system.out.println (array.get (x));}}}En el código anterior, podemos ver que la capa subyacente es implementada por los iteradores, y la mejora para realmente oculta el iterador, por lo que el código natural es mucho más simple sin crear iteradores. Esta es también la razón por la cual se lanza la mejora, que es reducir el código, facilitar el recorrido de las colecciones y las matrices y mejorar la eficiencia.
Nota: Debido a que la mejora para los iteradores de Hides, cuando se utiliza la mejora para atravesar colecciones y matrices, primero debe determinar si es nulo, de lo contrario se lanzará una excepción de puntero nulo. La razón es muy simple. La capa subyacente debe usar una matriz o objeto de recolección para llamar al método Iterator () para crear un iterador (el iterador Iterator es una interfaz, por lo que debe implementarse con una subclase). Si es nulo, definitivamente se lanzará una excepción.
5. Mejorar la aplicabilidad y las limitaciones de
1. Aplicabilidad
Adecuado para el recorrido de colecciones y matrices.
2. Limitaciones:
① El conjunto no puede ser nulo porque la capa subyacente es un iterador.
② El iterador está oculto, por lo que la colección no se puede modificar (agregar y eliminar) al atravesar la colección.
③ Las marcas de ángulo de establecimiento de Cannot.
6. Explicación detallada del uso de la mejora para
1. Uso mejorado para en matrices
paquete cn.jason05; import java.util.arrayList; import java.util.list;/** * mejorado para el uso * * @author cassandra */public class Fordemo {public static void main (String [] args) {// Trainea el array int [] arr = {1, 2, 3, 4, 5}; for (int x: arr) {system.out.println (x); }}}2. Mejorar el uso de para en colecciones
paquete cn.jason05; import java.util.arrayList; import java.util.list;/** * mejorado para el uso * * @author cassandra */public class Fordemo {public static void main (string [] args) {// Traverse la colección arraylist <tring> array = new arraylist <stratic> (); array.add ("hola"); array.add ("mundo"); array.add ("java"); for (String S: Array) {System.out.println (s); } // El conjunto es nulo, tire una lista de excepciones NULLPOInterException NULL Pointer <String> list = null; if (list! = null) {for (string s: list) {system.out.println (s); }} // Mejora la adición o modificación de elementos en para para, arroje una excepción de Modificación concurrente modificada simultáneamente para (String X: Array) {if (Array.Contains ("Java")) Array.Add (1, "Amor"); }}3. La combinación perfecta de genéricos y mejora para
Nota: debe combinarse perfectamente con genéricos, de lo contrario, debe transformarse manualmente hacia abajo.
1. Sin efecto genérico, no puede usar la mejora para
Clase de estudiantes
paquete cn.Jason01; estudiante de clase pública {name de cadena privada1; Nombre de cadena privada2; estudiante público () {super (); } Public Student (String Name1, String Name2) {super (); this.name1 = name1; this.name2 = name2; } public String getName1 () {return name1; } public void setName1 (String name1) {this.name1 = name1; } public String getName2 () {return name2; } public void setName2 (string name2) {this.name2 = name2; }}Código de prueba
paquete cn.Jason01; import java.util.arrayList; import java.util.iterator; import java.util.list; public class test02 {public static void main (string [] args) {// Crea set 1 list list1 = new ArrayList (); list1.add ("a"); list1.add ("b"); list1.add ("c"); // Crear list 2 list2 = new ArrayList (); list2.Add ("d"); list2.Add ("e"); list2.Add ("f"); // Crear establecido tres listas list3 = new ArrayList (); // atraviesa el primer y segundo conjunto y agregue elementos para establecer tres para (iterator i = list1.iterator (); i.hasnext ();) {// system.out.println (i.next ()); Cadena S = (String) I.Next (); for (iterator j = list2.Iterator (); J.HasNext ();) {// list2.Add (nuevo estudiante (s, J.Next ())); Cadena ss = (string) J.Next (); list3.Add (Nuevo estudiante (S, SS)); }} // atraviesa el conjunto tres y emite el elemento estudiante st; for (iterator k = list3.Iterator (); k.hasnext (); system.out .println (new StringBuilder (). Append (St.GetName1 ()). Append (St.GetName2 ())) {St = (Student) K.Next (); }}}Si el código anterior elimina las dos líneas del comentario, el programa informará un error, porque la colección no declara qué tipo es el elemento, y el iterador naturalmente no sabe qué tipo es. Entonces, si no hay genéricos, entonces debe transformarse hacia abajo, solo puede usar iteradores, no mejoras.
2. Genéricos y mejoras para
Modificar el código anterior
paquete cn.jason01; import java.util.arrayList; import java.util.iterator; import java.util.list;/** * Mejore la combinación perfecta de para y genéricas * * @author cassandra */public class test03 {public void main (string [] args) {// create set 1 list <s string> list1 = neoglet03 {public void void main (string [] args) {// create set 1 list <string> list1 = neogleily list1.add ("a"); list1.add ("b"); list1.add ("c"); // crear 2 list 2 list <string> list2 = new ArrayList <String> (); list2.Add ("d"); list2.Add ("e"); list2.Add ("f"); // Crear establecido tres list <estudiante> list3 = new ArrayList <Estudio> (); //// Traverse el primer y segundo conjunto y agregue elementos para establecer tres para (String S1: List1) {for (String S2: List2) {list3.Add (nuevo estudiante (S1, S2)); }} // atraviesa los tres elementos establecidos y de salida para (Student st: list3) {System.out.println (new StringBuilder (). Append (St.GetName1 ()). Append (St.GetName2 ())); }}}4. Cuatro métodos de recorrido de recopilación de listas
Existe el método Iterator () en la interfaz de colección, que devuelve el tipo de iterador y tiene un iterador como iterador. Hay un método listIterator () en la lista, por lo que hay una colección adicional listiterator. Sus subclases LinkedList, ArrayList y Vector sean interfaces de implementación y colección, por lo que todos pueden usar dos iteradores para atravesar.
Prueba de código
paquete cn.Jason05; import java.util.arrayList; import java.util.iterator; import java.util.list; import java.util.listiterator;/*** Estos son cuatro métodos de lista de atravesar la lista. * @author cassandra */public class Fordemo01 {public static void main (string [] args) {// crea una lista de colecciones <String> list = new ArrayList <String> (); list.add ("hola"); list.add ("mundo"); list.add ("java"); // Método 1, iterador iterador 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, ordinario para la colección transversal para (int x = 0; x <list.size (); x ++) {string sss = list.get (x); System.out.println (SSS); } // Método 4, Mejora para la colección transversal para (String ssss: list) {System.out.println (SSS); }}}5. Método de transversal de colección de hilo en 2
Dado que la colección de conjuntos no tiene un método GET (int index), no hay un método ordinario para bucle, no hay listIterator () en el conjunto, por lo que no hay iterador listIterator. Por lo tanto, solo hay dos formas de atravesar.
Prueba de código
paquete cn.jason05; import java.util.hashset; import java.util.iterator; import java.util.set; clase pública fortest03 {public static void main (string [] args) {set <tring> set = new Hashset <string> (); set.add ("hola"); 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, Mejora para la colección de transversal para (String S: Set) {System.out.println (s); }}}7. Resumen
1. Mejorar la aplicabilidad y las limitaciones de
Aplicabilidad: aplicable a los recorridos de colecciones y matrices.
limitación:
① El conjunto no puede ser nulo porque la capa subyacente es un iterador.
② La marca de ángulo no se puede establecer.
③ El iterador está oculto, por lo que la colección no se puede modificar (agregar y eliminar) al atravesar la colección.
2. Solo mejorando la combinación de For and Generics en la colección se puede jugar el papel de las nuevas características.
3. Es muy importante ver las nuevas características del sitio web oficial. Debes saber la razón y la razón. Solo sabiéndolo en tu corazón puedes usarlo libremente.
El resumen más completo del uso del bucle for en el artículo anterior "Java New Features" es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.