Durchlaufen einer Liste in umgekehrter Reihenfolge in Java

Ich migriere einen Code, um Generika zu verwenden. Ein Argument dafür ist, dass die for-Schleife viel sauberer ist als das Verfolgen von Indizes oder die Verwendung eines expliziten Iterators.

In etwa der Hälfte der Fälle wird die Liste (eine ArrayList) heute mithilfe eines Index in umgekehrter Reihenfolge iteriert.

Kann jemand einen saubereren Weg vorschlagen, dies zu tun (da ich das indexed for loopbei der Arbeit mit Sammlungen nicht mag), obwohl es funktioniert?

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

Hinweis: Ich kann keine neuen Abhängigkeiten außerhalb des JDK hinzufügen.

Versuche dies:

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

Guave bietet Lists#reverse(List)und ImmutableList#reverse(). Wie in den meisten Fällen für Guave delegiert der erstere an den letzteren, wenn das Argument ein ist ImmutableList, sodass Sie den ersteren in allen Fällen verwenden können. Diese erstellen keine neuen Kopien der Liste, sondern nur "umgekehrte Ansichten" davon.

Beispiel

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

Ich denke nicht, dass es möglich ist, die for-Schleifensyntax zu verwenden. Das einzige, was ich vorschlagen kann, ist etwas zu tun wie:

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

... aber ich würde nicht sagen, dass dies "sauberer" ist, da es weniger effizient sein wird.

Option 1: Haben Sie darüber nachgedacht, die Liste mit Collections # reverse () umzukehren und dann foreach zu verwenden?

Natürlich möchten Sie Ihren Code möglicherweise auch so umgestalten, dass die Liste korrekt sortiert ist, damit Sie sie nicht umkehren müssen, was zusätzlichen Platz / Zeit beansprucht.

BEARBEITEN:

Option 2: Könnten Sie alternativ eine Deque anstelle einer ArrayList verwenden? Damit können Sie vorwärts und rückwärts iterieren

BEARBEITEN:

Option 3: Wie andere vorgeschlagen haben, können Sie einen Iterator schreiben, der die Liste in umgekehrter Reihenfolge durchläuft. Hier ein Beispiel:

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

Sie können die konkrete Klasse LinkedListanstelle der allgemeinen Schnittstelle verwenden List. Dann haben Sie eine descendingIteratorzum Iterieren mit der umgekehrten Richtung.

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

Weiß nicht warum es keine gibt descendingIteratormit ArrayList...

Dies ist eine alte Frage, aber es fehlt eine Java8-freundliche Antwort. Hier sind einige Möglichkeiten, die Liste mithilfe der Streaming-API rückgängig zu machen:

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

Hier ist eine (ungetestete) Implementierung von a ReverseIterable. Wenn iterator()es aufgerufen wird, wird eine private ReverseIteratorImplementierung erstellt und zurückgegeben , die einfach Aufrufe hasNext()an hasPrevious()und Aufrufe an next()zuordnet previous(). Dies bedeutet, dass Sie ArrayListwie folgt über eine Umkehrung iterieren können :

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

Klassendefinition

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

Wenn die Listen ziemlich klein sind, so dass die Leistung kein echtes Problem darstellt, kann man das reverse-metod der Lists-class in verwenden Google Guava. Ergibt hübschen for-eachCode und die ursprüngliche Liste bleibt gleich. Außerdem wird die umgekehrte Liste von der ursprünglichen Liste unterstützt, sodass jede Änderung an der ursprünglichen Liste in der umgekehrten Liste berücksichtigt wird.

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

Ergibt folgendes Ergebnis:

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

Dies bedeutet, dass die umgekehrte Iteration von myList wie folgt geschrieben werden kann:

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

Erstellen Sie eine benutzerdefinierte reverseIterable.

Sehr einfaches Beispiel:

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) {
  ...
}

Sie können ReverseListIteratoraus Apache Commons-Collections verwenden:

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

Auch gefunden Google Sammlungen umgekehrte Methode.

Um Code zu haben, der so aussieht:

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

Fügen Sie diesen Code in eine Datei mit dem Namen "In.java" ein:

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

Wie mindestens zweimal vorgeschlagen wurde, können Sie descendingIteratormit a Deque, insbesondere mit a, verwenden LinkedList. Wenn Sie die for-each-Schleife verwenden möchten (dh eine haben Iterable), können Sie einen Wraper wie folgt erstellen und verwenden:

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

Grund: "Weiß nicht, warum es mit ArrayList keinen absteigenden Iterator gibt ..."

Da die Array-Liste die Liste nicht in derselben Reihenfolge hält, in der Daten zur Liste hinzugefügt wurden. Verwenden Sie also niemals Arraylist.

Die verknüpfte Liste hält die Daten in derselben Reihenfolge wie ADD to list.

Also habe ich oben in meinem Beispiel ArrayList () verwendet, um den Benutzer dazu zu bringen, seinen Verstand zu verdrehen und ihn dazu zu bringen, etwas von seiner Seite zu trainieren.

An Stelle von

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

VERWENDEN:

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) {
  ...
}