Si può fare un per ogni loop in Java in ordine inverso?

Devo scorrere una lista in ordine inverso usando Java.

Quindi, dove questo lo fa in avanti:

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

Esiste un modo per iterare la stringList in ordine inverso usando la per ogni sintassi?

Per chiarezza: so come ripetere un elenco in ordine inverso, ma vorrei sapere (per amor di curiosità) come farlo in ogni stile.

Il metodo Collections.reverse restituisce effettivamente un nuovo elenco con gli elementi dell'elenco originale copiati in esso in ordine inverso, quindi questo ha prestazioni O (n) rispetto alla dimensione dell'elenco originale.

Come soluzione più efficiente, è possibile scrivere un decoratore che presenta una vista inversa di un elenco come Iterable. L'iteratore restituito dal tuo decoratore userebbe il ListIterator dell'elenco decorato per camminare sugli elementi in ordine inverso.

Per esempio:

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

E lo useresti come:

import static Reversed.reversed;

...

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

Per un elenco, è possibile utilizzare la libreria di Google Guava :

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

Nota che non inverte l'intera raccolta o fa nulla di simile: consente solo l'iterazione e l'accesso casuale, nell'ordine inverso. Questo è più efficiente che invertire prima la raccolta.Lists.reverse

Per invertire un iterabile arbitrario, dovresti leggerlo tutto e "rigiocarlo" al contrario.

(Se non hai già utilizza, avrei accuratamente consigliamo di dare un'occhiata alla Guava . E 'roba grande.)

L'elenco (a differenza del set) è una raccolta ordinata e iterando su di essa preserva l'ordine per contratto. Mi sarei aspettato che uno Stack si ripetesse nell'ordine inverso, ma sfortunatamente non lo è. Quindi la soluzione più semplice che mi viene in mente è questa:

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

Mi rendo conto che questa non è una soluzione loop "per ogni". Preferirei usare il ciclo for piuttosto che introdurre una nuova libreria come Google Collections.

Anche Collections.reverse () esegue il lavoro ma aggiorna l'elenco anziché restituire una copia in ordine inverso.

Questo rovinerà l'elenco originale e dovrà essere chiamato anche al di fuori del ciclo. Inoltre, non vuoi eseguire un reverse ogni volta che esegui il loop: sarebbe vero se uno dei Iterables.reverse ideasfosse applicato?

Collections.reverse(stringList);

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

AFAIK non esiste una sorta di "reverse_iterator" standard nella libreria standard che supporti la sintassi for-each che è già uno zucchero sintattico che hanno portato tardi nella lingua.

Potresti fare qualcosa del genere per (Elemento elemento: myList.clone (). Reverse ()) e pagare il prezzo associato.

Ciò sembra anche abbastanza coerente con l'apparente fenomeno di non fornirti modi convenienti per eseguire operazioni costose - poiché un elenco, per definizione, potrebbe avere una complessità di accesso casuale O (N) (potresti implementare l'interfaccia con un singolo collegamento), viceversa l'iterazione potrebbe finire per essere O (N ^ 2). Naturalmente, se hai una ArrayList, non paghi quel prezzo.

Questa potrebbe essere un'opzione. Spero che ci sia un modo migliore per iniziare dall'ultimo elemento rispetto a while loop fino alla fine.

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

A partire dal commento : dovresti essere in grado di utilizzare Apache CommonsReverseListIterator

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

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

Come ha detto @rogerdpack , è necessario racchiuderlo ReverseListIteratorcome Iterable.

Non senza scrivere un codice personalizzato che ti darà un enumeratore che invertirà gli elementi per te.

Dovresti essere in grado di farlo in Java creando un'implementazione personalizzata di Iterable che restituirà gli elementi in ordine inverso.

Quindi, dovresti istanziare il wrapper (o chiamare il metodo, what-have-you) che restituirebbe l'implementazione Iterable che inverte l'elemento in per ogni ciclo.

È possibile utilizzare la classe Collections http://java.sun.com/j2se/1.4.2/docs/api/java/util/Collections.html per invertire l'elenco, quindi eseguire il ciclo.

Dovresti invertire la tua raccolta se vuoi usare il per ogni sintassi fuori dalla scatola e andare in ordine inverso.

Tutte le risposte sopra soddisfano solo il requisito, avvolgendo un altro metodo o chiamando un codice esterno all'esterno;

Ecco la soluzione copiata dalla quarta edizione di Thinking in Java , capitolo 11.13.1 AdapterMethodIdiom ;

Ecco il codice:

// 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'opera intorno:

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

O con guava :

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

Sicuramente una risposta tardiva a questa domanda. Una possibilità è usare ListIterator in un ciclo for. Non è pulito come la sintassi del colon, ma funziona.

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

Il credito per la sintassi di ListIterator va a "Modi per scorrere su un elenco in Java"