Scorrendo un elenco in ordine inverso in Java

Sto migrando un pezzo di codice per usare i generici. Un argomento per farlo è che il ciclo for è molto più pulito rispetto al tenere traccia degli indici o all'utilizzo di un iteratore esplicito.

In circa la metà dei casi, l'elenco (una ArrayList) viene ripetuto in ordine inverso utilizzando oggi un indice.

Qualcuno può suggerire un modo più pulito di farlo (dal momento che non mi piace indexed for loopquando lavoro con le raccolte), sebbene funzioni?

 for (int i = nodes.size() - 1; i >= 0; i--) {
    final Node each = (Node) nodes.get(i);
    ...
 }

Nota: non riesco ad aggiungere nuove dipendenze al di fuori di JDK.

Prova questo:

// Substitute appropriate type.
ArrayList<...> a = new ArrayList<...>();

// Add elements to list.

// Generate an iterator. Start just after the last element.
ListIterator li = a.listIterator(a.size());

// Iterate in reverse.
while(li.hasPrevious()) {
  System.out.println(li.previous());
}

Guava offre Lists#reverse(List)e ImmutableList#reverse(). Come nella maggior parte dei casi per Guava, i primi delegano ai secondi se l'argomento è un ImmutableList, quindi puoi usare i primi in tutti i casi. Questi non creano nuove copie dell'elenco ma solo "viste invertite" di esso.

Esempio

List reversed = ImmutableList.copyOf(myList).reverse();

Non credo sia possibile usare la sintassi del ciclo for. L'unica cosa che posso suggerire è fare qualcosa del tipo:

Collections.reverse(list);
for (Object o : list) {
  ...
}

... ma non direi che questo è "più pulito" dato che sarà meno efficiente.

Opzione 1: hai pensato di invertire l'elenco con le raccolte # reverse () e quindi di usare foreach?

Naturalmente, potresti anche voler riformattare il tuo codice in modo tale che l'elenco sia ordinato correttamente in modo da non doverlo invertire, che utilizza spazio / tempo extra.

MODIFICARE:

Opzione 2: in alternativa, potresti usare un Deque invece di un ArrayList? Ti permetterà di iterare avanti e indietro

MODIFICARE:

Opzione 3: come altri hanno suggerito, potresti scrivere un iteratore che scorrerà l'elenco al contrario, ecco un esempio:

import java.util.Iterator;
import java.util.List;

public class ReverseIterator<T> implements Iterator<T>, Iterable<T> {

    private final List<T> list;
    private int position;

    public ReverseIterator(List<T> list) {
        this.list = list;
        this.position = list.size() - 1;
    }

    @Override
    public Iterator<T> iterator() {
        return this;
    }

    @Override
    public boolean hasNext() {
        return position >= 0;
    }

    @Override
    public T next() {
        return list.get(position--);
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }

}


List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");

for (String s : new ReverseIterator<String>(list)) {
    System.out.println(s);
}

È possibile utilizzare la classe concrete LinkedListanziché l'interfaccia generale List. Quindi hai un descendingIteratorper iterare con la direzione inversa.

LinkedList<String > linkedList;
for( Iterator<String > it = linkedList.descendingIterator(); it.hasNext(); ) {
    String text = it.next();
}

Non so perché non c'è descendingIteratorcon ArrayList...

Questa è una vecchia domanda, ma manca una risposta amichevole per java8. Ecco alcuni modi per ripetere l'iterazione dell'elenco, con l'aiuto dell'API Streaming:

List<Integer> list = new ArrayList<Integer>(Arrays.asList(1, 3, 3, 7, 5));
list.stream().forEach(System.out::println); // 1 3 3 7 5

int size = list.size();

ListIterator<Integer> it = list.listIterator(size);
Stream.generate(it::previous).limit(size)
    .forEach(System.out::println); // 5 7 3 3 1

ListIterator<Integer> it2 = list.listIterator(size);
Stream.iterate(it2.previous(), i -> it2.previous()).limit(size)
    .forEach(System.out::println); // 5 7 3 3 1

// If list is RandomAccess (i.e. an ArrayList)
IntStream.range(0, size).map(i -> size - i - 1).map(list::get)
    .forEach(System.out::println); // 5 7 3 3 1

// If list is RandomAccess (i.e. an ArrayList), less efficient due to sorting
IntStream.range(0, size).boxed().sorted(Comparator.reverseOrder())
    .map(list::get).forEach(System.out::println); // 5 7 3 3 1

Ecco un'implementazione (non testata) di a ReverseIterable. Quando iterator()viene chiamato crea e restituisce ReverseIteratorun'implementazione privata , che mappa semplicemente le chiamate hasNext()a hasPrevious()e le chiamate a next()vengono mappate previous(). Vuol dire che potresti iterare ArrayListal contrario come segue:

ArrayList<String> l = ...
for (String s : new ReverseIterable(l)) {
  System.err.println(s);
}

Definizione della classe

public class ReverseIterable<T> implements Iterable<T> {
  private static class ReverseIterator<T> implements Iterator {
    private final ListIterator<T> it;

    public boolean hasNext() {
      return it.hasPrevious();
    }

    public T next() {
      return it.previous();
    }

    public void remove() {
      it.remove();
    }
  }

  private final ArrayList<T> l;

  public ReverseIterable(ArrayList<T> l) {
    this.l = l;
  }

  public Iterator<T> iterator() {
    return new ReverseIterator(l.listIterator(l.size()));
  }
}

Se gli elenchi sono abbastanza piccoli in modo che le prestazioni non siano un vero problema, si può usare il reverse-metod della -class Listsin Google Guava. for-eachRende piuttosto il codice e l'elenco originale rimane lo stesso. Inoltre, l'elenco invertito è supportato dall'elenco originale, quindi qualsiasi modifica all'elenco originale si rifletterà in quello invertito.

import com.google.common.collect.Lists;

[...]

final List<String> myList = Lists.newArrayList("one", "two", "three");
final List<String> myReverseList = Lists.reverse(myList);

System.out.println(myList);
System.out.println(myReverseList);

myList.add("four");

System.out.println(myList);
System.out.println(myReverseList);

Produce il seguente risultato:

[one, two, three]
[three, two, one]
[one, two, three, four]
[four, three, two, one]

Ciò significa che l'iterazione inversa di myList può essere scritta come:

for (final String someString : Lists.reverse(myList)) {
    //do something
}

Crea un'abitudine reverseIterable.

Esempio molto semplice:

List<String> list = new ArrayList<String>();

list.add("ravi");

list.add("kant");

list.add("soni");

// Iterate to disply : result will be as ---     ravi kant soni

for (String name : list) {
  ...
}

//Now call this method

Collections.reverse(list);

// iterate and print index wise : result will be as ---     soni kant ravi

for (String name : list) {
  ...
}

Puoi usare ReverseListIteratorda Apache Commons-Collections:

https://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/iterators/ReverseListIterator.html

Ho trovato anche il metodo inverso delle raccolte di Google .

Per avere un codice simile al seguente:

List<Item> items;
...
for (Item item : In.reverse(items))
{
    ...
}

Inserisci questo codice in un file chiamato "In.java":

import java.util.*;

public enum In {;
    public static final <T> Iterable<T> reverse(final List<T> list) {
        return new ListReverseIterable<T>(list);
    }

    class ListReverseIterable<T> implements Iterable<T> {
        private final List<T> mList;

        public ListReverseIterable(final List<T> list) {
            mList = list;
        }

        public Iterator<T> iterator() {
            return new Iterator<T>() {
                final ListIterator<T> it = mList.listIterator(mList.size());

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

Come è stato suggerito almeno due volte, è possibile utilizzare descendingIteratorcon a Deque, in particolare con a LinkedList. Se vuoi usare il ciclo for-each (cioè, avere un Iterable), puoi costruire e usare un wrapper come questo:

import java.util.*;

public class Main {

    public static class ReverseIterating<T> implements Iterable<T> {
        private final LinkedList<T> list;

        public ReverseIterating(LinkedList<T> list) {
            this.list = list;
        }

        @Override
        public Iterator<T> iterator() {
            return list.descendingIterator();
        }
    }

    public static void main(String... args) {
        LinkedList<String> list = new LinkedList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");

        for (String s : new ReverseIterating<String>(list)) {
            System.out.println(s);
        }
    }
}

Motivo: "Non so perché non esiste un DiscendenteIteratore con ArrayList ..."

Poiché l'elenco di array non mantiene l'elenco nello stesso ordine in cui i dati sono stati aggiunti all'elenco. Quindi, non usare mai Arraylist.

L'elenco collegato manterrà i dati nello stesso ordine di AGGIUNGI all'elenco.

Quindi, sopra nel mio esempio, ho usato ArrayList () per indurre l'utente a distorcere la mente e fargli allenare qualcosa dalla propria parte.

Invece di questo

List<String> list = new ArrayList<String>();

USO:

List<String> list = new LinkedList<String>();

list.add("ravi");

list.add("kant");

list.add("soni");

// Iterate to disply : result will be as ---     ravi kant soni

for (String name : list) {
  ...
}

//Now call this method

Collections.reverse(list);

// iterate and print index wise : result will be as ---     soni kant ravi

for (String name : list) {
  ...
}