Façons d'itérer sur une liste en Java

Exemple de chaque type énuméré dans la question:

ListIterationExample.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());
     }
}

La boucle de base n'est pas recommandée car vous ne connaissez pas l'implémentation de la liste.

Si c'était une liste de liens, chaque appel à

list.get(i)

Itérerait sur la liste, ce qui entraînerait une complexité temporelle N^2.

Une itération de style 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));
    }
}

Dans Java 8 nous avons plusieurs façons d'itérer sur les classes de collection.

Utilisation de forEach itérable

Les collections qui implémentent Iterable (par exemple toutes les listes) ont maintenant la méthode forEach. Nous pouvons utiliser méthode de référence introduit dans Java 8.

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

Utilisation des flux forEach et forEachOrdered

Nous pouvons également itérer sur une liste en utilisant Stream comme:

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

Nous devrions préférer forEachOrdered à forEach parce que le comportement de forEach est explicitement non déterministe lorsque le forEachOrdered effectue une action pour chaque élément de ce flux, dans l'ordre de rencontre du flux si le flux a un ordre de rencontre défini. Donc forEach ne garantit pas que la commande serait conservée.

L'avantage avec les flux est que nous pouvons également utiliser des flux parallèles lorsque cela est approprié. Si l'objectif est uniquement d'imprimer les éléments indépendamment de l'ordre alors nous pouvons utiliser en parallèle flux:

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

Je ne sais pas ce que vous considérez comme pathologique, mais permettez-moi de fournir quelques alternatives que vous n'auriez pas pu voir auparavant:

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

Ou sa version récursive:

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

Aussi, une version récursive du classique 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);
}

Je les mentionne parce que vous êtes "un peu nouveau sur Java" et cela pourrait être intéressant.

Vous pouvez utiliser forEach à partir de Java 8:

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

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

Pour une recherche en arrière, vous devez utiliser ce qui suit:

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

Si vous voulez connaître une position, utilisez iterator.previousIndex (). Il est également utile d'écrire une boucle interne qui compare deux positions dans la liste (les itérateurs ne sont pas égaux).

Dans java 8 vous pouvez utiliser List.forEach() méthode avec lambda expression pour itérer sur une liste.

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);
                }
        );
    }
}

À droite, de nombreuses alternatives sont énumérées. Le plus simple et le plus propre serait simplement d'utiliser l'instruction enhanced for comme ci-dessous. Le Expression est d'un type qui est itératif.

for ( FormalParameter : Expression ) Statement

Par exemple, pour parcourir la liste des ID , nous pouvons simplement le faire,

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

Vous pouvez toujours changer les premier et troisième exemples avec une boucle while et un peu plus de code. Cela vous donne l'avantage de pouvoir utiliser le do-while:

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

Bien sûr, ce genre de chose pourrait provoquer une NullPointerException si la liste.size () renvoie 0, car il est toujours exécuté au moins une fois. Cela peut être corrigé en testant si l'élément est null avant d'utiliser ses attributs / méthodes tho. Pourtant, il est beaucoup plus simple et plus facile d'utiliser la boucle for