Jak uzyskać odwrócony widok listy na liście w Javie?

Chcę mieć odwrócony widok listy na liście (w podobny sposób, jak List#sublistzapewnia widok listy sublist na liście). Czy jest jakaś funkcja zapewniająca tę funkcjonalność?

Nie chcę tworzyć żadnej kopii listy ani modyfikować listy.

Wystarczyłoby, gdybym w tym przypadku znalazł przynajmniej jedną iterator do tyłu.

Wiem też, jak to zrobić. Pytam tylko, czy Java już zapewnia coś takiego.

Wdrożenie demonstracyjne:

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

Właśnie dowiedziałem się, że niektóre Listwdrożenia mają descendingIterator()to, czego potrzebuję. Chociaż nie ma takiej ogólnej implementacji List. Co jest dość dziwne, ponieważ implementacja, którą widziałem, LinkedListjest wystarczająco ogólna, aby z nią pracować List.

Guava zapewnia to: Lists.reverse (List)

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

W przeciwieństwie do Collections.reversetego jest to wyłącznie widok ... nie zmienia kolejności elementów na oryginalnej liście. Ponadto w przypadku modyfikowalnej oryginalnej listy zmiany zarówno pierwotnej listy, jak i widoku znajdują odzwierciedlenie w drugiej.

Użyj metody .clone () na swojej liście. Zwróci płytką kopię, co oznacza, że ​​będzie zawierała wskaźniki do tych samych obiektów, więc nie będziesz musiał kopiować listy. Następnie skorzystaj z kolekcji.

Ergo

Collections.reverse(list.clone());

Jeśli używasz Listi nie masz dostępu clone(), możesz użyć subList():

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

Jeśli dobrze zrozumiałem, to jest to jeden wiersz kodu. To zadziałało dla mnie.

 Collections.reverse(yourList);

Nie jest do końca elegancki, ale jeśli użyjesz List.listIterator (int index), możesz uzyskać dwukierunkowy ListIterator na końcu listy:

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

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

Collections.reverse (nums) ... Faktycznie odwraca kolejność elementów. Poniższy kod należy docenić -

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

Wyjście: 15,94,83,42,61

java.util.Dequema descendingIterator()- jeśli Listjest Deque, można użyć.

Wiem, że to stary post, ale dzisiaj szukałem czegoś takiego. Na koniec sam napisałem kod:

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

Niezalecane w przypadku długich list, nie jest to wcale zoptymalizowane. Jest to dość łatwe rozwiązanie dla kontrolowanych scenariuszy (obsługiwane przez mnie Listy zawierają nie więcej niż 100 elementów).

Mam nadzieję, że to komuś pomoże.

Używam tego:

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

}

lubię to:

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

Możesz także to zrobić:

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

Możesz także odwrócić pozycję, gdy zażądasz obiektu:

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

W przypadku małej listy możemy utworzyć, LinkedLista następnie użyć iteratora malejącego jako:

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

Użyj reverse(...)metod java.util.Collectionsklasy. Przekaż listę jako parametr, a lista zostanie odwrócona.

Collections.reverse(list);