Kann man für jede Schleife in Java eine in umgekehrter Reihenfolge machen?

Ich muss eine Liste in umgekehrter Reihenfolge mit Java durchlaufen.

Also, wo dies vorwärts geht:

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

Gibt es eine Möglichkeit, die stringList in umgekehrter Reihenfolge mit der für jede Syntax zu iterieren ?

Aus Gründen der Klarheit: Ich weiß, wie man eine Liste in umgekehrter Reihenfolge durchläuft, möchte aber (aus Neugier) wissen, wie man es für jeden Stil macht.

Die Collections.reverse-Methode gibt tatsächlich eine neue Liste zurück, in die die Elemente der ursprünglichen Liste in umgekehrter Reihenfolge kopiert wurden. Dies hat also eine O (n) -Leistung in Bezug auf die Größe der ursprünglichen Liste.

Als effizientere Lösung können Sie einen Dekorateur schreiben, der eine umgekehrte Ansicht einer Liste als Iterable darstellt. Der von Ihrem Dekorateur zurückgegebene Iterator verwendet den ListIterator der dekorierten Liste, um die Elemente in umgekehrter Reihenfolge zu durchlaufen.

Beispielsweise:

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

Und Sie würden es wie folgt verwenden:

import static Reversed.reversed;

...

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

Für eine Liste können Sie die Google Guava-Bibliothek verwenden :

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

Beachten Sie, dass dies nicht die gesamte Sammlung umkehrt oder etwas Ähnliches tut - es ermöglicht lediglich Iteration und wahlfreien Zugriff in umgekehrter Reihenfolge. Dies ist effizienter, als zuerst die Sammlung umzukehren.Lists.reverse

Um eine beliebige Iterable umzukehren, müssten Sie alles lesen und dann rückwärts "wiedergeben".

(Wenn Sie nicht bereits verwenden, würde ich durchaus empfehlen Ihnen einen Blick auf die haben Guava . Es ist toll so.)

Die Liste ist (im Gegensatz zum Set) eine geordnete Sammlung, und wenn Sie sie durchlaufen, bleibt die Bestellung vertraglich erhalten. Ich hätte erwartet, dass ein Stapel in umgekehrter Reihenfolge iteriert, aber leider nicht. Die einfachste Lösung, die ich mir vorstellen kann, ist folgende:

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

Mir ist klar, dass dies keine "für jede" Schleifenlösung ist. Ich würde lieber die for-Schleife verwenden, als eine neue Bibliothek wie die Google-Sammlungen einzuführen.

Collections.reverse () erledigt den Job ebenfalls, aktualisiert jedoch die Liste, anstatt eine Kopie in umgekehrter Reihenfolge zurückzugeben.

Dies wird mit der ursprünglichen Liste in Konflikt geraten und muss auch außerhalb der Schleife aufgerufen werden. Außerdem möchten Sie nicht jedes Mal eine Umkehrung durchführen, wenn Sie eine Schleife ausführen. Wäre das wahr, wenn eine der Iterables.reverse ideasbeiden Methoden angewendet würde?

Collections.reverse(stringList);

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

AFAIK: In der Standardbibliothek gibt es keinen Standard "reverse_iterator", der die Syntax für jede Syntax unterstützt, die bereits ein syntaktischer Zucker ist, den sie spät in die Sprache gebracht haben.

Sie könnten so etwas wie für (Item-Element: myList.clone (). Reverse ()) tun und den zugehörigen Preis bezahlen.

Dies scheint auch ziemlich konsistent mit dem offensichtlichen Phänomen zu sein, dass Sie keine bequemen Möglichkeiten für teure Operationen haben - da eine Liste per Definition eine O (N) -Wahlzugriffskomplexität aufweisen könnte (Sie könnten die Schnittstelle mit einer einzelnen Verbindung implementieren), umgekehrt Die Iteration könnte O (N ^ 2) sein. Wenn Sie eine ArrayList haben, zahlen Sie diesen Preis natürlich nicht.

Dies kann eine Option sein. Ich hoffe, es gibt einen besseren Weg, um vom letzten Element zu beginnen, als bis zum Ende der while-Schleife.

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

Ab dem Kommentar : Sie sollten in der Lage sein, Apache Commons zu verwendenReverseListIterator

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

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

Wie @rogerdpack sagte , müssen Sie das ReverseListIteratorals einpackenIterable .

Nicht ohne einen benutzerdefinierten Code zu schreiben, der Ihnen einen Enumerator gibt, der die Elemente für Sie umkehrt.

Sie sollten dies in Java tun können, indem Sie eine benutzerdefinierte Implementierung von Iterable erstellen, die die Elemente in umgekehrter Reihenfolge zurückgibt.

Dann würden Sie den Wrapper instanziieren (oder die Methode what-have-you aufrufen), die die Iterable-Implementierung zurückgibt, die das Element in der für jede Schleife umkehrt.

Sie können die Collections-Klasse http://java.sun.com/j2se/1.4.2/docs/api/java/util/Collections.html verwenden , um die Liste umzukehren und dann zu schleifen.

Sie müssten Ihre Sammlung umkehren, wenn Sie die für jede Syntax sofort verwenden und in umgekehrter Reihenfolge vorgehen möchten.

Alle obigen Antworten erfüllen nur die Anforderung, entweder durch Umschließen einer anderen Methode oder durch Aufrufen eines Fremdcodes außerhalb;

Hier ist die Lösung, die aus der 4. Ausgabe von Thinking in Java , Kapitel 11.13.1 AdapterMethodIdiom , kopiert wurde .

Hier ist der 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
*///:~

Eine Arbeit um:

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

Oder mit Guave :

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

Auf jeden Fall eine späte Antwort auf diese Frage. Eine Möglichkeit besteht darin, den ListIterator in einer for-Schleife zu verwenden. Es ist nicht so sauber wie die Doppelpunktsyntax, aber es funktioniert.

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

Das Guthaben für die ListIterator-Syntax lautet "Möglichkeiten zum Durchlaufen einer Liste in Java".