que - recorrer linkedlist java
Diferencia entre mover un iterador hacia delante con una instrucción for y una instrucción while (5)
El propósito de declarar el Iterator dentro del ciclo for es minimizar el alcance de sus variables , lo cual es una buena práctica.
Cuando declara el Iterator fuera del ciclo, la referencia sigue siendo válida / viva después de que finaliza el ciclo. 99,99% de las veces, no es necesario que continúe utilizando el Iterator una vez que se complete el bucle, por lo que dicho estilo puede generar errores como este:
//iterate over first collection
Iterator it1 = collection1.iterator();
while(it1.hasNext()) {
//blah blah
}
//iterate over second collection
Iterator it2 = collection2.iterator();
while(it1.hasNext()) {
//oops copy and paste error! it1 has no more elements at this point
}
Cuando uso un iterador de objeto, uso un ciclo while (como está escrito en cada libro que aprende Java, como Thinking in Java de Bruce Eckel):
Iterator it=...
while(it.hasNext()){
//...
}
pero en algún momento vi que en cambio alguien usa el ciclo for :
Iterator it=...
for (Iterator it=...; it.hasNext();){
//...
}
No entiendo esta opción:
- Utilizo el bucle for cuando tengo una colección con secuencia ordinal (como matriz) o con una regla especial para el paso (generalmente declarada como un simple
counter++incrementocounter++). - Uso el ciclo while cuando el ciclo termina con I have''nt this constraints pero solo una condición lógica para salir.
Es una cuestión de codificación de estilo sin otra causa o existe alguna otra lógica (rendimiento, por ejemplo) que no ''conozco''.
Gracias por cada comentario
Es solo una cuestión de estilo y, como tú, prefiero el bucle for al usar algo con un índice. Si está utilizando Java 5, por supuesto, debe usar un bucle Foreach sobre la colección de todas formas:
Collection<String> someCollection = someCollectionOfString();
for (String element : someCollection) {
....
}
Las personas pueden usar el bucle for explícito (''estilo antiguo'') simplemente porque les parece más limpio, tal vez aún no se hayan adaptado a la nueva sintaxis (que personalmente considero que es mucho más limpio).
Una ventaja específica real de la construcción de bucle for más larga es que tiene una referencia al iterador y, por lo tanto, puede invocar métodos sobre ella y luego next() . En particular, hasNext() menudo puede ser útil para llamar; imagine si desea imprimir una lista de cadenas separadas por comas:
StringBuilder sb = new StringBuilder();
for (Iterator it=...; it.hasNext();){
sb.append(it.next());
if (it.hasNext())
sb.append(", ");
}
Es solo para distinguir el caso "este es el último" como este si usa el bucle más detallado para.
No hay mucha diferencia entre esos dos métodos, salvo que el primero recuerda el valor del it después del ciclo. El segundo enfoque probablemente arroje un error, porque redeclaras la variable dentro del ciclo.
En realidad, hay un tercer método para esto. En lugar de escribir, por ejemplo
for (Iterator<SomeObject> it = foo.iterator(); it.hasNext();) {
SomeObject so = foo.next();
}
usted puede escribir con mayor frecuencia
for (SomeObject so: foo) {...}
Estos dos son iguales a lo mismo ...
La sintaxis correcta para el bucle for es:
for (Iterator it = ...; it.hasNext(); ){
//...
}
(La declaración anterior en su código es superflua, así como el punto y coma adicional en el encabezado for loop).
Si utilizas esta sintaxis o el ciclo while es cuestión de gustos, ambos se traducen exactamente de la misma manera. La sintaxis genérica del bucle for es:
for (<init stmt>; <loop cond>; <iterate stmt>) { <body>; }
que es equivalente a:
<init stmt>;
while (<loop cond>) { <body>; <iterate stmt>; }
Editar: En realidad, las dos formas anteriores no son totalmente equivalentes, si (como en la pregunta) la variable se declara con la instrucción init. En este caso, habrá una diferencia en el alcance de la variable del iterador. Con el bucle for, el alcance se limita al bucle en sí, en el caso del bucle while, sin embargo, el alcance se extiende hasta el final del bloque envolvente (no es de extrañar, ya que la declaración está fuera del bucle).
Además, como han señalado otros, en las versiones más nuevas de Java, hay una notación abreviada para el ciclo for:
for (Iterator<Foo> it = myIterable.iterator(); it.hasNext(); ) {
Foo foo = it.next();
//...
}
Se puede escribir como:
for (Foo foo : myIterable) {
//...
}
Con este formulario, por supuesto, perderá la referencia directa al iterador, que es necesario, por ejemplo, si desea eliminar elementos de la colección mientras itera.