Peut-on faire une boucle for each en Java dans l'ordre inverse ?

Question

J'ai besoin de parcourir une liste dans l'ordre inverse en utilisant Java.

Donc là où cela le fait dans le sens avant:

for(String string: stringList){
//...faire quelque chose
}

Y a-t-il un moyen d'itérer sur la stringList dans l'ordre inverse en utilisant la syntaxe for each?

Pour clarifier: je sais comment itérer sur une liste dans l'ordre inverse mais j'aimerais savoir (par curiosité) comment le faire dans le style for each.

Answer 1

La méthode Collections.reverse retourne en fait une nouvelle liste avec les éléments de la liste d'origine copiés à l'envers, donc cela a une complexité en O(n) par rapport à la taille de la liste d'origine.

Comme solution plus efficace, vous pourriez écrire un décorateur qui présente une vue inversée d'une liste en tant qu'itérable. L'itérateur retourné par votre décorateur utiliserait le ListIterator de la liste décorée pour parcourir les éléments dans l'ordre inverse.

Par exemple:

public class Reversed implements Iterable {
    private final List original;

    public Reversed(List original) {
        this.original = original;
    }

    public Iterator iterator() {
        final ListIterator i = original.listIterator(original.size());

        return new Iterator() {
            public boolean hasNext() { return i.hasPrevious(); }
            public T next() { return i.previous(); }
            public void remove() { i.remove(); }
        };
    }

    public static  Reversed reversed(List original) {
        return new Reversed(original);
    }
}

Et vous l'utiliseriez comme ceci:

import static Reversed.reversed;

...

List someStrings = getSomeStrings();
for (String s : reversed(someStrings)) {
    doSomethingWith(s);
}

Answer 2

Pour une liste, vous pourriez utiliser la Bibliothèque Google Guava:

for (String item : Lists.reverse(stringList))
{
    // ...
}

Notez que Lists.reverse ne inverse pas toute la collection, ni ne fait quoi que ce soit de semblable - cela permet simplement l'itération et l'accès aléatoire, dans l'ordre inverse. C'est plus efficace que d'inverser la collection au préalable.

Pour inverser un itérable arbitraire, vous devriez le lire entièrement et ensuite le "rejouer" à l'envers.

(Si vous ne l'utilisez pas déjà, je vous recommande vivement de jeter un œil à Guava. C'est du très bon matériel.)

Answer 3

La liste (contrairement à l'ensemble) est une collection ordonnée et son itération préserve l'ordre par contrat. J'aurais attendu à ce qu'une pile itère dans l'ordre inverse mais malheureusement ce n'est pas le cas. Donc la solution la plus simple à laquelle je peux penser est la suivante:

for (int i = stack.size() - 1; i >= 0; i--) {
    System.out.println(stack.get(i));
}

Je réalise que ce n'est pas une solution de boucle "for each". Je préfère utiliser la boucle for plutôt que d'introduire une nouvelle bibliothèque comme Google Collections.

Collections.reverse() fait également le travail mais il met à jour la liste au lieu de retourner une copie dans l'ordre inverse.

Answer 4

Cela va perturber la liste originale et doit également être appelé en dehors de la boucle. De plus, vous ne voulez pas effectuer une inversion à chaque fois que vous bouclez - cela serait-il vrai si l'une des idées Iterables.reverse était appliquée?

Collections.reverse(stringList);

for(String string: stringList){
//...faire quelque chose
}

Answer 5

À ma connaissance, il n'y a pas de standard "reverse_iterator" dans la bibliothèque standard qui prend en charge la syntaxe for-each, qui est déjà du sucre syntaxique introduit tardivement dans le langage.

Vous pourriez faire quelque chose comme for(Item element: myList.clone().reverse()) et payer le prix associé.

Cela semble également assez cohérent avec le phénomène apparent de ne pas vous donner de moyens pratiques pour effectuer des opérations coûteuses - puisqu'une liste, par définition, pourrait avoir une complexité d'accès aléatoire O(N) (vous pourriez implémenter l'interface avec un seul lien), l'itération inverse pourrait finir par être de O(N^2). Bien sûr, si vous avez un ArrayList, vous ne payez pas ce prix.