Java: la mejor manera de iterar a través de una colección (aquí ArrayList)

Hoy estaba felizmente codificando cuando llegué a un fragmento de código que ya usé cientos de veces:

Iterando a través de una colección (aquí ArrayList)

Por alguna razón, miré las opciones de autocompletado de Eclipse y me pregunto:

¿En qué casos es mejor utilizar los siguientes bucles que los demás?

El ciclo de índice de matriz clásico:

for (int i = 0; i < collection.length; i++) {
  type array_element = collection.get(index);
}

El iterador tieneNext () / next ():

for (Iterator iterator = collection.iterator(); iterator.hasNext();) {
  type type = (type) iterator.next();   
}

Y mi favorito porque es muy sencillo de escribir:

for (iterable_type iterable_element : collection) {

}

El primero es útil cuando también necesita el índice del elemento. Esto es básicamente equivalente a las otras dos variantes de ArrayLists, pero será muy lento si usa a LinkedList.

El segundo es útil cuando no necesita el índice del elemento, pero es posible que deba eliminar los elementos a medida que itera. Pero esto tiene la desventaja de ser un poco demasiado detallado en mi opinión.

La tercera versión también es mi opción preferida. Es breve y funciona para todos los casos en los que no necesita ningún índice o el iterador subyacente (es decir, solo está accediendo a elementos, no eliminándolos ni modificando Collectionde ninguna manera, que es el caso más común).

Todos ellos tienen sus propios usos:

1. Si tiene un iterable y necesita atravesar incondicionalmente a todos ellos:

   para (iterable_type iterable_element: colección)

2. Si tiene un iterable pero necesita atravesar condicionalmente:

   para (Iterador iterador = colección.iterador (); iterador.hasNext ();)

3. Si la estructura de datos no se implementa iterable:

   para (int i = 0; i <collection.length; i ++)

También hay una utilidad stream () de colecciones con Java 8

collection.forEach((temp) -> {
            System.out.println(temp);
});

o

collection.forEach(System.out::println);

Más información sobre el enlace y colecciones de Java 8 para maravillas

Ninguno de ellos es "mejor" que los demás. El tercero es, para mí, más legible, pero para alguien que no usa foreaches puede parecer extraño (quizás prefieran el primero). Los 3 son bastante claros para cualquiera que entienda Java, así que elija el que le haga sentirse mejor con el código.

El primero es el más básico, por lo que es el patrón más universal (funciona para matrices, todos los iterables en los que puedo pensar). Esa es la única diferencia en la que puedo pensar. En casos más complicados (por ejemplo, necesita tener acceso al índice actual o necesita filtrar la lista), el primer y segundo caso pueden tener más sentido, respectivamente. Para el caso simple (objeto iterable, sin requisitos especiales), el tercero parece el más limpio.

La primera opción es un mejor rendimiento (como ArrayList implementa la interfaz RandomAccess). Según el documento de Java, una implementación de List debería implementar la interfaz RandomAccess si, para instancias típicas de la clase, este bucle:

 for (int i=0, n=list.size(); i < n; i++)
     list.get(i);

corre más rápido que este bucle:

 for (Iterator i=list.iterator(); i.hasNext(); )
     i.next();

Espero que ayude. La primera opción sería lenta para listas de acceso secuenciales.

Aquí hay un ejemplo

Query query = em.createQuery("from Student");
             java.util.List list = query.getResultList();
             for (int i = 0; i < list.size(); i++) 
             {

                 student = (Student) list.get(i);
                 System.out.println(student.id  + "  " + student.age + " " + student.name + " " + student.prenom);

             }