Wie erhalte ich eine umgekehrte Listenansicht für eine Liste in Java?

Ich möchte eine umgekehrte List#sublistListenansicht für eine Liste haben (ähnlich wie bei einer Unterlistenansicht für eine Liste). Gibt es eine Funktion, die diese Funktionalität bietet?

Ich möchte keine Kopie der Liste erstellen oder die Liste ändern.

In diesem Fall wäre es jedoch ausreichend, wenn ich mindestens einen Reverse-Iterator auf eine Liste setzen könnte.

Außerdem weiß ich, wie ich das selbst umsetzen kann. Ich frage nur, ob Java so etwas bereits bietet.

Demo-Implementierung:

static <T> Iterable<T> iterableReverseList(final List<T> l) {
    return new Iterable<T>() {
        public Iterator<T> iterator() {
            return new Iterator<T>() {
                ListIterator<T> listIter = l.listIterator(l.size());                    
                public boolean hasNext() { return listIter.hasPrevious(); }
                public T next() { return listIter.previous(); }
                public void remove() { listIter.remove(); }                 
            };
        }
    };
}

Ich habe gerade herausgefunden, dass einige ListImplementierungen genau das haben, descendingIterator()was ich brauche. Obwohl es keine allgemeine solche Implementierung für gibt List. Was irgendwie seltsam ist, weil die Implementierung, die ich gesehen habe, LinkedListallgemein genug ist, um mit jeder zu arbeiten List.

Guave bietet dies: Lists.reverse (Liste)

List<String> letters = ImmutableList.of("a", "b", "c");
List<String> reverseView = Lists.reverse(letters); 
System.out.println(reverseView); // [c, b, a]

Im Gegensatz Collections.reversedazu ist dies nur eine Ansicht ... es ändert nichts an der Reihenfolge der Elemente in der ursprünglichen Liste. Bei einer ursprünglichen Liste, die geändert werden kann, werden Änderungen sowohl an der ursprünglichen Liste als auch an der Ansicht in der anderen wiedergegeben.

Verwenden Sie die Methode .clone () in Ihrer Liste. Es wird eine flache Kopie zurückgegeben, was bedeutet, dass es Zeiger auf dieselben Objekte enthält, sodass Sie die Liste nicht kopieren müssen. Dann verwenden Sie einfach Sammlungen.

Ergo,

Collections.reverse(list.clone());

Wenn Sie ein verwenden Listund keinen Zugriff darauf haben clone(), können Sie Folgendes verwenden subList():

List<?> shallowCopy = list.subList(0, list.size());
Collections.reverse(shallowCopy);

Wenn ich richtig verstanden habe, dann ist es eine Codezeile. Es hat bei mir funktioniert.

 Collections.reverse(yourList);

Es ist nicht gerade elegant, aber wenn Sie List.listIterator (int index) verwenden, können Sie einen bidirektionalen ListIterator an das Ende der Liste bringen:

//Assume List<String> foo;
ListIterator li = foo.listIterator(foo.size());

while (li.hasPrevious()) {
   String curr = li.previous()
}

Collections.reverse (nums) ... Es kehrt tatsächlich die Reihenfolge der Elemente um. Der folgende Code sollte sehr geschätzt werden -

List<Integer> nums = new ArrayList<Integer>();
nums.add(61);
nums.add(42);
nums.add(83);
nums.add(94);
nums.add(15);
//Tosort the collections uncomment the below line
//Collections.sort(nums); 

Collections.reverse(nums);

System.out.println(nums);

Ausgabe: 15,94,83,42,61

java.util.Dequehat descendingIterator()- wenn du Listein Dequebist, kannst du das benutzen.

Ich weiß, dass dies ein alter Beitrag ist, aber heute habe ich nach so etwas gesucht. Am Ende habe ich den Code selbst geschrieben:

private List reverseList(List myList) {
    List invertedList = new ArrayList();
    for (int i = myList.size() - 1; i >= 0; i--) {
        invertedList.add(myList.get(i));
    }
    return invertedList;
}

Nicht empfohlen für lange Listen, dies ist überhaupt nicht optimiert. Es ist eine einfache Lösung für kontrollierte Szenarien (die von mir behandelten Listen enthalten nicht mehr als 100 Elemente).

Hoffe es hilft jemandem.

Ich benutze das:

public class ReversedView<E> extends AbstractList<E>{

    public static <E> List<E> of(List<E> list) {
        return new ReversedView<>(list);
    }

    private final List<E> backingList;

    private ReversedView(List<E> backingList){
        this.backingList = backingList;
    }

    @Override
    public E get(int i) {
        return backingList.get(backingList.size()-i-1);
    }

    @Override
    public int size() {
        return backingList.size();
    }

}

so was:

ReversedView.of(backingList) // is a fully-fledged generic (but read-only) list

Sie können dies auch tun:

static ArrayList<String> reverseReturn(ArrayList<String> alist)
{
   if(alist==null || alist.isEmpty())
   { 
       return null;
   }

   ArrayList<String> rlist = new ArrayList<>(alist);

   Collections.reverse(rlist);
   return rlist;
}

Sie können die Position auch umkehren, wenn Sie ein Objekt anfordern:

Object obj = list.get(list.size() - 1 - position);

Für kleine Listen können wir einen LinkedListabsteigenden Iterator erstellen und dann verwenden als:

List<String> stringList = new ArrayList<>(Arrays.asList("One", "Two", "Three"));
stringList.stream().collect(Collectors.toCollection(LinkedList::new))
         .descendingIterator().
         forEachRemaining(System.out::println); // Three, Two, One
System.out.println(stringList); // One, Two, Three

Verwenden Sie reverse(...)Methoden der java.util.CollectionsKlasse. Übergeben Sie Ihre Liste als Parameter und Ihre Liste wird umgekehrt.

Collections.reverse(list);