Façons d'itérer 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)

serait itératif sur la liste, résultant en n^2 complexité de temps.

a JDK8-style itération:

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 collecte.

à l'Aide de Itérable forEach

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

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

à l'Aide de Flux de forEach et forEachOrdered

nous pouvons aussi itérer sur une liste à l'aide de Flux :

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 où comme 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. Ainsi forEach ne garantit pas que la commande serait maintenue.

L'avantage avec streams est que nous pouvons également utiliser des streams 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 courant parallèle:

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

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

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 en 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 (). Cela aide aussi à é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 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);
                }
        );
    }
}

D'accord, de nombreuses alternatives sont énumérées. Le plus facile et le plus propre serait d'utiliser simplement l'énoncé amélioré for comme ci-dessous. Le Expression est d'un certain type qui est itérable.

for ( FormalParameter : Expression ) Statement

par exemple, pour itérer, List ids, nous pouvons simplement ainsi,

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

vous pouvez toujours désactiver les premier et troisième exemples avec une boucle de temps 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 causer une NullPointerException si la liste.size () renvoie 0, parce qu'il est toujours exécuté au moins une fois. Cela peut être corrigé en testant si l'élément est nul avant d'utiliser ses attributs / méthodes tho. Pourtant, il est beaucoup plus simple et plus facile à utiliser la boucle pour