Wie man eine Liste in Java umkehrt?

Question

Ich möchte eine umgekehrte Listenansicht auf einer Liste haben (ähnlich wie List#sublist bietet eine Unterliste Ansicht auf einer Liste). Gibt es eine Funktion, die diese Funktionalität bietet?

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

Es wäre genug, wenn ich in diesem Fall zumindest einen umgekehrten Iterator in einer Liste bekommen könnte.

---

Auch ich weiß, wie ich das selbst implementieren. Ich frage nur, ob Java schon so etwas 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 List Implementierungen descendingIterator() haben das ist, was ich brauche. Obwohl es keine allgemeine Implementierung für List gibt. Das ist irgendwie komisch, weil die Implementierung, die ich in LinkedList gesehen habe, allgemein genug ist, mit irgendeiner List zu arbeiten.

Answer 1

Guava dies bietet: Lists.reverse(List)

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

Im Gegensatz zu Collections.reverse, das ist eine reine Ansicht ... es nicht die Reihenfolge der Elemente in der ursprünglichen Liste verändern. Bei einer ursprünglichen Liste, die geändert werden kann, werden Änderungen an der ursprünglichen Liste und der Ansicht in der anderen reflektiert.

Answer 2

Es ist nicht genau elegant, aber wenn Sie verwenden List.listIterator (int index) Sie einen bidirektionalen ListIterator zum Ende der Liste bekommen:

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

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

Answer 3

java.util.Deque hat descendingIterator() - wenn Ihr List ist a Deque, können Sie das verwenden.

Answer 4

Verwenden Sie die .clone() -Methode für Ihre Liste. Es wird eine flache Kopie zurückgegeben, was bedeutet, dass es Zeiger auf dieselben Objekte enthält, so dass Sie die Liste nicht kopieren müssen. Dann benutze einfach die Sammlungen.

Ergo,

Collections.reverse(list.clone()); 

Wenn Sie eine List verwenden und haben keinen Zugriff auf clone() Sie subList() verwenden können:

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

Answer 5

Ich weiß, dass dies eine alte Post, aber heute war ich auf der Suche nach so etwas. Am Ende habe ich den Code selbst:

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 lange Listen empfohlen, ist dies nicht optimiert. Es ist eine einfache Lösung für kontrollierte Szenarien (die Listen, die ich behandle, haben nicht mehr als 100 Elemente).

Ich hoffe, es hilft jemandem.

Answer 6

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

Answer 7

Wenn ich richtig verstanden haben, dann ist es eine Zeile Code .Es für mich gearbeitet.

Collections.reverse(yourList); 

Answer 8

ich verwenden:

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

} 

wie folgt aus:

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

Answer 9

Collections.reverse (nums) ... Es umkehren tatsächlich die Reihenfolge der Elemente. Im Folgenden 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); 

Collections.sort(nums); 

Collections.reverse(nums); 

System.out.println(nums); 

Answer 10

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

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

Answer 11

für kleine Liste, die wir LinkedList und die Verwendung von absteigend Iterator machen können dann erstellen wie:

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