Como obter uma exibição de lista invertida em uma lista em Java?

Desejo ter uma exibição de lista invertida em uma lista (de maneira semelhante ao que List#sublistfornece uma exibição de sub-lista em uma lista). Existe alguma função que fornece essa funcionalidade?

Não quero fazer nenhum tipo de cópia da lista nem modificá-la.

Seria o suficiente se eu pudesse obter pelo menos um iterador reverso em uma lista nesse caso.

Além disso, eu sei como implementar isso sozinho. Só estou perguntando se o Java já fornece algo assim.

Implementação de demonstração:

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

Acabei de descobrir que algumas Listimplementações têm o descendingIterator()que eu preciso. Embora não exista essa implementação geral para List. O que é meio estranho, porque a implementação que eu vi LinkedListé geral o suficiente para funcionar com qualquer List.

A Goiaba fornece o seguinte: Lists.reverse (Lista)

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

Ao contrário Collections.reverse, essa é uma visão puramente ... não altera a ordem dos elementos na lista original. Além disso, com uma lista original modificável, as alterações na lista original e na exibição são refletidas na outra.

Use o método .clone () na sua lista. Ele retornará uma cópia superficial, o que significa que conterá ponteiros para os mesmos objetos, para que você não precise copiar a lista. Depois, basta usar Coleções.

Ergo,

Collections.reverse(list.clone());

Se você estiver usando um Liste não tiver acesso, clone()poderá usar subList():

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

Se eu entendi correto, então é uma linha de código. Funcionou para mim.

 Collections.reverse(yourList);

Não é exatamente elegante, mas se você usar List.listIterator (int index), poderá obter um ListIterator bidirecional no final da lista:

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

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

Collections.reverse (nums) ... Na verdade, inverte a ordem dos elementos. O código abaixo deve ser muito apreciado -

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

Saída: 15,94,83,42,61

java.util.Dequehas descendingIterator()- se você Listé um Deque, você pode usá-lo.

Eu sei que este é um post antigo, mas hoje eu estava procurando por algo assim. No final, eu mesmo escrevi o código:

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

Não recomendado para listas longas, isso não é otimizado. É uma solução fácil para cenários controlados (as Listas que mantenho não têm mais que 100 elementos).

Espero que ajude alguém.

Eu uso isso:

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

}

como isso:

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

Você também pode fazer isso:

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

Você também pode inverter a posição ao solicitar um objeto:

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

Para lista de tamanho pequeno, podemos criar LinkedListe usar o iterador descendente como:

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

Use reverse(...)métodos de java.util.Collectionsclasse. Passe sua lista como parâmetro e sua lista será revertida.

Collections.reverse(list);