Peut-on faire un pour chaque boucle en java dans l'ordre inverse?

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

Alors, où cela fait-il avancer:

for(String string: stringList){
//...do something
}

Existe-t-il un moyen d'itérer la liste de chaînes dans l'ordre inverse en utilisant pour chaque syntaxe?

Pour plus de clarté: je sais comment parcourir une liste dans l'ordre inverse mais j'aimerais savoir (par curiosité) comment le faire dans le pour chaque style.

La méthode Collections.reverse retourne en fait une nouvelle liste avec les éléments de la liste d'origine copiés dans l'ordre inverse, ce qui a des performances O (n) en ce qui concerne la taille de la liste d'origine.

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

Par exemple:

public class Reversed<T> implements Iterable<T> {
    private final List<T> original;

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

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

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

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

Et vous l'utiliseriez comme:

import static Reversed.reversed;

...

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

Pour une liste, vous pouvez utiliser la bibliothèque Google Guava :

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

Notez que cela n'inverse pas toute la collection, ou ne fait rien de semblable - cela permet simplement l'itération et l'accès aléatoire, dans l'ordre inverse. C'est plus efficace que d'annuler d'abord la collection.Lists.reverse

Pour inverser un itérable arbitraire, vous devez tout lire et le «rejouer» à l'envers.

(Si vous n'êtes pas déjà l' utiliser, je bien vous recommandons de jeter un oeil à la goyave . Il est super choses.)

La Liste (contrairement à l'Ensemble) est une collection ordonnée et l'itération sur elle préserve la commande par contrat. Je me serais attendu à ce qu'un Stack itère dans l'ordre inverse, mais malheureusement ce n'est pas le cas. La solution la plus simple à laquelle je puisse penser est donc la suivante:

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

Je me rends compte que ce n'est pas une solution de boucle «pour chaque». Je préfère utiliser la boucle for plutôt que d'introduire une nouvelle bibliothèque comme les collections Google.

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

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

Collections.reverse(stringList);

for(String string: stringList){
//...do something
}

AFAIK il n'y a pas une sorte de chose standard "reverse_iterator" dans la bibliothèque standard qui supporte la syntaxe for-each qui est déjà un sucre syntaxique qu'ils ont introduit tardivement dans le langage.

Vous pouvez faire quelque chose comme pour (élément Item: 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 - car une liste, par définition, pourrait avoir une complexité d'accès aléatoire O (N) (vous pouvez implémenter l'interface avec un lien unique), inverser l'itération pourrait finir par être O (N ^ 2). Bien sûr, si vous avez une ArrayList, vous ne payez pas ce prix.

Cela peut être une option. J'espère qu'il existe une meilleure façon de commencer à partir du dernier élément que de faire une boucle while jusqu'à la fin.

public static void main(String[] args) {        
    List<String> a = new ArrayList<String>();
    a.add("1");a.add("2");a.add("3");a.add("4");a.add("5");

    ListIterator<String> aIter=a.listIterator();        
    while(aIter.hasNext()) aIter.next();

    for (;aIter.hasPrevious();)
    {
        String aVal = aIter.previous();
        System.out.println(aVal);           
    }
}

Au moment du commentaire : vous devriez pouvoir utiliser Apache CommonsReverseListIterator

Iterable<String> reverse 
    = new IteratorIterable(new ReverseListIterator(stringList));

for(String string: reverse ){
    //...do something
}

Comme @rogerdpack dit , vous avez besoin d'envelopper le ReverseListIteratorcomme Iterable.

Non sans écrire du code personnalisé qui vous donnera un énumérateur qui inversera les éléments pour vous.

Vous devriez pouvoir le faire en Java en créant une implémentation personnalisée de Iterable qui renverra les éléments dans l'ordre inverse.

Ensuite, vous instanciez le wrapper (ou appelez la méthode, what-have-you) qui renverrait l'implémentation Iterable qui inverse l'élément dans la boucle for each.

Vous pouvez utiliser la classe Collections http://java.sun.com/j2se/1.4.2/docs/api/java/util/Collections.html pour inverser la liste puis boucler.

Vous devrez inverser votre collection si vous souhaitez utiliser le pour chaque syntaxe prête à l'emploi et aller dans l'ordre inverse.

Toutes les réponses ci-dessus ne remplissent que l'exigence, soit en enveloppant une autre méthode ou en appelant un code étranger à l'extérieur;

Voici la solution copiée de la 4ème édition de Thinking in Java , chapitre 11.13.1 AdapterMethodIdiom ;

Voici le code:

// The "Adapter Method" idiom allows you to use foreach
// with additional kinds of Iterables.
package holding;
import java.util.*;

@SuppressWarnings("serial")
class ReversibleArrayList<T> extends ArrayList<T> {
  public ReversibleArrayList(Collection<T> c) { super(c); }
  public Iterable<T> reversed() {
    return new Iterable<T>() {
      public Iterator<T> iterator() {
        return new Iterator<T>() {
          int current = size() - 1; //why this.size() or super.size() wrong?
          public boolean hasNext() { return current > -1; }
          public T next() { return get(current--); }
          public void remove() { // Not implemented
            throw new UnsupportedOperationException();
          }
        };
      }
    };
  }
}   

public class AdapterMethodIdiom {
  public static void main(String[] args) {
    ReversibleArrayList<String> ral =
      new ReversibleArrayList<String>(
        Arrays.asList("To be or not to be".split(" ")));
    // Grabs the ordinary iterator via iterator():
    for(String s : ral)
      System.out.print(s + " ");
    System.out.println();
    // Hand it the Iterable of your choice
    for(String s : ral.reversed())
      System.out.print(s + " ");
  }
} /* Output:
To be or not to be
be to not or be To
*///:~

Un travail autour:

Collections.reverse(stringList).forEach(str -> ...);

Ou avec de la goyave :

Lists.reverse(stringList).forEach(str -> ...);

Certainement une réponse tardive à cette question. Une possibilité est d'utiliser le ListIterator dans une boucle for. Ce n'est pas aussi clair que la syntaxe deux-points, mais cela fonctionne.

List<String> exampleList = new ArrayList<>();
exampleList.add("One");
exampleList.add("Two");
exampleList.add("Three");

//Forward iteration
for (String currentString : exampleList) {
    System.out.println(currentString); 
}

//Reverse iteration
for (ListIterator<String> itr = exampleList.listIterator(exampleList.size()); itr.hasPrevious(); /*no-op*/ ) {
    String currentString = itr.previous();
    System.out.println(currentString); 
}

Le mérite de la syntaxe ListIterator va aux "façons d'itérer sur une liste en Java"