java - tecla - eventos de botones en netbeans

¿Por qué el bucle mejorado para bucle es más eficiente que el bucle normal?

Question

Leí que el bucle for mejorado es más eficiente que el bucle for normal aquí:

http://developer.android.com/guide/practices/performance.html#foreach

Cuando busqué la diferencia entre su eficiencia, todo lo que encontré es: en el caso de un bucle normal, necesitamos un paso adicional para averiguar la longitud de la matriz o el tamaño, etc.

for(Integer i : list){
....
}
int n = list.size();
for(int i=0; i < n; ++i){
....
}

Pero, ¿es esta la única razón por la que el bucle for mejorado es mejor que el bucle normal? En ese caso, utilice mejor el bucle normal para debido a la ligera complejidad en la comprensión del bucle mejorado para .

Compruebe esto para un tema interesante: http://www.coderanch.com/t/258147/java-programmer-SCJP/certification/Enhanced-Loop-Vs-Loop

¿Puede alguien explicar la implementación interna de estos dos tipos de bucles for, o explicar otras razones para usar el bucle for for mejorado?

Answer 1

Leí que mejorado para bucle es eficiente de lo normal para bucle.

En realidad, a veces es menos eficiente para el programa, pero la mayoría de las veces es exactamente igual.

Es más eficiente para el desarrollador, que a menudo es mucho más importante.

Un bucle para cada bucle es particularmente útil cuando se itera sobre una colección.

List<String> list =
for(Iterator<String> iter = list.iterator(); list.hasNext(); ) {
String s = list.next();

se escribe más fácilmente como (pero hace lo mismo que, por lo que no es más eficiente para el programa)

List<String> list =
for(String s: list) {

El uso del bucle "antiguo" es ligeramente más eficiente cuando se accede a una colección de acceso aleatorio por índice.

List<String> list = new ArrayList<String>(); // implements RandomAccess
for(int i=0, len = list.size(); i < len; i++) // doesn''t use an Iterator!

El uso de un bucle for-each en una colección siempre usa un iterador que es ligeramente menos eficiente para las listas de acceso aleatorio.

AFAIK, usar un bucle para cada uno nunca es más eficiente para el programa, pero como dije, la eficiencia del desarrollador es a menudo mucho más importante .

Answer 2

De Java eficaz:

El idioma estándar para hacer un bucle a través de una matriz no resulta necesariamente en verificaciones redundantes. Las implementaciones modernas de JVM las optimizan.

Pero Josh Bloch no describe cómo JVM los optimiza.

Answer 3

El bucle foreach es tan eficiente como este tipo de bucle:

for (Iterator<Foo> it = list.iterator(); it.hasNext(); ) {
Foo foo = it.next();
...
}

porque es estrictamente equivalente.

Si recorres una lista usando

int size = list.size();
for (int i = 0; i < size; i++) {
Foo foo = list.get(i);
...
}

Entonces, el bucle foreach tendrá un rendimiento equivalente a su bucle, pero solo para ArrayList . En el caso de una lista enlazada, su bucle tendrá un rendimiento abismal, ya que en cada iteración, tendrá que atravesar todos los nodos de la lista hasta que llegue al elemento i th.

El bucle foreach (o el bucle basado en un iterador, que es el mismo), no tiene este problema, ya que el iterador mantiene una referencia al nodo actual y simplemente pasa al siguiente en cada iteración. Es la mejor opción, porque funciona bien con todos los tipos de listas. También expresa la intención más claramente, y es más seguro porque no se arriesga a incrementar el índice dentro del bucle, ni a utilizar el índice incorrecto en caso de bucles anidados.

Answer 4

El para-cada utiliza la interfaz Iterator. Dudo que sea más eficiente que el estilo "antiguo". El iterador también necesita verificar el tamaño de la lista.

Es sobre todo para la legibilidad.

Debería ser más rápido para las colecciones de acceso no aleatorio como LinkedList, pero la comparación es injusta. De todos modos, no habría usado una segunda implementación (con un acceso lento indexado).

Answer 5

Es un poco simplista decir que el bucle mejorado para es más eficiente. Puede ser, pero en muchos casos es casi exactamente lo mismo que un bucle de la vieja escuela.

Lo primero que se debe tener en cuenta es que, para las colecciones, el bucle for mejorado usa un Iterator , por lo que si realiza una iteración manual sobre una colección con un Iterator , debería tener prácticamente el mismo rendimiento que el bucle for mejorado.

Un lugar donde el bucle for mejorado es más rápido que un bucle tradicional ingenuamente implementado es algo como esto:

LinkedList<Object> list = ...;
// Loop 1:
int size = list.size();
for (int i = 0; i<size; i++) {
Object o = list.get(i);
/// do stuff
}
// Loop 2:
for (Object o : list) {
// do stuff
}
// Loop 3:
Iterator<Object> it = list.iterator();
while (it.hasNext()) {
Object o = it.next();
// do stuff
}

En este caso, el bucle 1 será más lento que el bucle 2 y el bucle 3, ya que tendrá que (parcialmente) recorrer la lista en cada iteración para encontrar el elemento en la posición i . Loop 2 y 3, sin embargo, solo serán un paso más allá en la lista, debido al uso de un Iterator . Loop 2 y 3 también tendrán prácticamente el mismo rendimiento, ya que Loop 3 es exactamente lo que el compilador producirá cuando escribas el código en Loop 2.

Answer 6

Me sorprendí en un pequeño experimento que hice hoy con los puntos mencionados anteriormente. Entonces, lo que hice fue que inserté un cierto número de elementos en una lista enlazada y lo repetí usando los tres métodos mencionados anteriormente 1) usando avanzado para el bucle 2) usando el iterador 3) usando el bucle simple y get ()
Supongo que programadores como ustedes pueden entender mejor lo que hice al ver el código.

long advanced_timeElapsed,iterating_timeElapsed,simple_timeElapsed;
long first=System.nanoTime();
for(Integer i: myList){
Integer b=i;
}
long end= System.nanoTime();
advanced_timeElapsed=end-first;
System.out.println("Time for Advanced for loop:"+advanced_timeElapsed);
first=System.nanoTime();
Iterator<Integer> it = myList.iterator();
while(it.hasNext())
{
Integer b=it.next();
}
end= System.nanoTime();
iterating_timeElapsed=end-first;
System.out.println("Time for Iterating Loop:"+iterating_timeElapsed);
first=System.nanoTime();
int counter=0;
int size= myList.size();
while(counter<size)
{
Integer b=myList.get(counter);
counter++;
}
end= System.nanoTime();
simple_timeElapsed=end-first;
System.out.println("Time for Simple Loop:"+simple_timeElapsed);

Los resultados donde no es lo que esperaba. A continuación se muestra la gráfica del tiempo transcurrido en 3 casos.

Eje-tiempo transcurrido X prueba de eje caso
caso de prueba1: 10 entradas
caso de prueba2: 30 entradas
test case3: 50 entradas
test case4: 100 entradas
test case5: 150 entradas
test case6: 300 entradas
caso de prueba7: 500 entradas
test case8: 1000 entradas
caso de prueba9: 2000 entradas
test case10: 5000 entradas
test case11: 10000 entradas
test case12: 100000 entradas

Aquí puede ver que el simple bucle funciona mucho mejor que otros. Si encuentra algún error en el código anterior, responda y lo verificaré nuevamente. se actualizará más sobre esto después de que busco código de bytecode y vea lo que sucede debajo del capó. Mis disculpas por una respuesta tan larga, pero me gusta ser descriptivo. Felipe

Answer 7

todas las respuestas son buenas, y creo que no se necesitan más respuestas, pero solo quiero señalar que:

La sentencia for mejorado solo se puede utilizar para obtain array elements

no se puede utilizar para modify elements .

Si su programa necesita modificar elementos, use el counter-controlled tradicional for declaración.

echar un vistazo

int[] array = { 1, 2, 3, 4, 5 };
for (int counter = 0; counter < array.length; counter++)
array[counter] *= 2;

No pudimos usar el enhanced for porque estamos modifying the array''s elements .