Formas de iterar sobre una lista en Java

Ejemplo de cada tipo enumerado en la pregunta:

Ejemplo de lista.java

import java.util.*;

public class ListIterationExample {

     public static void main(String []args){
        List<Integer> numbers = new ArrayList<Integer>();

        // populates list with initial values
        for (Integer i : Arrays.asList(0,1,2,3,4,5,6,7))
            numbers.add(i);
        printList(numbers);         // 0,1,2,3,4,5,6,7

        // replaces each element with twice its value
        for (int index=0; index < numbers.size(); index++) {
            numbers.set(index, numbers.get(index)*2); 
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // does nothing because list is not being changed
        for (Integer number : numbers) {
            number++; // number = new Integer(number+1);
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14  

        // same as above -- just different syntax
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            number++;
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // ListIterator<?> provides an "add" method to insert elements
        // between the current element and the cursor
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.add(number+1);     // insert a number right before this
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15

        // Iterator<?> provides a "remove" method to delete elements
        // between the current element and the cursor
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            if (number % 2 == 0)    // if number is even 
                iter.remove();      // remove it from the collection
        }
        printList(numbers);         // 1,3,5,7,9,11,13,15

        // ListIterator<?> provides a "set" method to replace elements
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.set(number/2);     // divide each element by 2
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7
     }

     public static void printList(List<Integer> numbers) {
        StringBuilder sb = new StringBuilder();
        for (Integer number : numbers) {
            sb.append(number);
            sb.append(",");
        }
        sb.deleteCharAt(sb.length()-1); // remove trailing comma
        System.out.println(sb.toString());
     }
}

No se recomienda el bucle básico ya que no conoce la implementación de la lista.

Si eso era una lista de enlaces, cada llamada a

list.get(i)

Estaría iterando sobre la lista, resultando en una complejidad de tiempo N^2.

Una iteración al estilo JDK8:

public class IterationDemo {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        list.stream().forEach(elem -> System.out.println("element " + elem));
    }
}

En Java 8 tenemos múltiples formas de iterar sobre las clases de colección.

Usando forEach iterable

Las colecciones que implementan Iterable (por ejemplo todas las listas) ahora tienen el método forEach. Podemos usar method-reference introducido en Java 8.

Arrays.asList(1,2,3,4).forEach(System.out::println);

Usando flujos forEach y forEachOrdered

También podemos iterar sobre una lista usando Stream como:

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
Arrays.asList(1,2,3,4).stream().forEachOrdered(System.out::println);

Deberíamos preferir forEachOrdered sobre forEach porque el comportamiento de forEach es explícitamente no determinista donde as the forEachOrdered realiza una acción para cada elemento de esta secuencia, en el orden de encuentro de la secuencia si la secuencia tiene un orden de encuentro definido. Así que forEach no garantiza que el orden se mantendría.

La ventaja con los flujos es que también podemos hacer uso de flujos paralelos cuando sea apropiado. Si el objetivo es solo imprimir los elementos independientemente del orden, entonces podemos usar parallel stream como:

Arrays.asList(1,2,3,4).parallelStream().forEach(System.out::println);

No se lo que consideras patológico, pero déjame darte algunas alternativas que no podrías haber visto antes:

List<E> sl= list ;
while( ! sl.empty() ) {
    E element= sl.get(0) ;
    .....
    sl= sl.subList(1,sl.size());
}

O su versión recursiva:

void visit(List<E> list) {
    if( list.isEmpty() ) return;
    E element= list.get(0) ;
    ....
    visit(list.subList(1,list.size()));
}

También, una versión recursiva del clásico for(int i=0...:

void visit(List<E> list,int pos) {
    if( pos >= list.size() ) return;
    E element= list.get(pos) ;
    ....
    visit(list,pos+1);
}

Los menciono porque eres "algo nuevo en Java" y esto podría ser interesante.

Puedes usar forEach a partir de Java 8:

 List<String> nameList   = new ArrayList<>(
            Arrays.asList("USA", "USSR", "UK"));

 nameList.forEach((v) -> System.out.println(v));

Para una búsqueda hacia atrás debe utilizar lo siguiente:

for (ListIterator<SomeClass> iterator = list.listIterator(list.size()); iterator.hasPrevious();) {
    SomeClass item = iterator.previous();
    ...
    item.remove(); // For instance.
}

Si desea conocer una posición, utilice el iterador.previousIndex (). También ayuda a escribir un bucle interno que compara dos posiciones en la lista (los iteradores no son iguales).

En java 8 puede usar el método List.forEach() con lambda expression para iterar sobre una lista.

import java.util.ArrayList;
import java.util.List;

public class TestA {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Apple");
        list.add("Orange");
        list.add("Banana");
        list.forEach(
                (name) -> {
                    System.out.println(name);
                }
        );
    }
}

Correcto, se enumeran muchas alternativas. Lo más fácil y limpio sería simplemente usar la sentencia enhanced for como se muestra a continuación. El Expression es de algún tipo que es iterable.

for ( FormalParameter : Expression ) Statement

Por ejemplo, para iterar a través de, Lista ids, podemos simplemente así,

for (String str : ids) {
    // Do something
}

Siempre se puede cambiar el primer y tercer ejemplo con un bucle while y un poco más de código. Esto le da la ventaja de poder usar el do-while:

int i = 0;
do{
 E element = list.get(i);
 i++;
}
while (i < list.size());

Por supuesto, este tipo de cosas podrían causar una excepción NullPointerException si la lista.size () devuelve 0, porque siempre se ejecuta al menos una vez. Esto se puede arreglar probando si el elemento es null antes de usar sus atributos / métodos tho. Aún así, es mucho más simple y más fácil usar el bucle for