¿Cómo obtener una vista de lista invertida en una lista en Java?

Quiero tener una vista de lista invertida en una lista (de manera similar a la que List#sublistproporciona una vista de sublista en una lista). ¿Hay alguna función que proporcione esta funcionalidad?

No quiero hacer ningún tipo de copia de la lista ni modificarla.

Sin embargo, sería suficiente si pudiera obtener al menos un iterador inverso en una lista en este caso.

Además, sé cómo implementar esto yo mismo. Solo pregunto si Java ya proporciona algo como esto.

Implementación de demostración:

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

Acabo de descubrir que algunas Listimplementaciones tienen descendingIterator()lo que necesito. Aunque no existe tal implementación general para List. Lo cual es un poco extraño porque la implementación que he visto LinkedListes lo suficientemente general como para funcionar con cualquiera List.

Guava proporciona esto: Lists.reverse (List)

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

diferente a Collections.reverse , esto es puramente una vista ... no altera el orden de los elementos en la lista original. Además, con una lista original que es modificable, los cambios tanto en la lista original como en la vista se reflejan en la otra.

Use el método .clone () en su Lista. Devolverá una copia superficial, lo que significa que contendrá punteros a los mismos objetos, por lo que no tendrá que copiar la lista. Entonces solo use Colecciones.

Es decir,

Collections.reverse(list.clone());

Si está utilizando Listay no tiene acceso clone(), puede usar subList():

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

Si he entendido bien, entonces es una línea de código. Funcionó para mí.

 Collections.reverse(yourList);

No es exactamente elegante, pero si usa List.listIterator (int index) puede obtener un ListIterator bidireccional al final de la lista:

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

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

Collections.reverse (nums) ... Realmente invierte el orden de los elementos. El siguiente código debe ser muy 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);

Salida: 15,94,83,42,61

java.util.Dequetiene descendingIterator()- si tu Listes un Deque, puedes usar eso.

Sé que esta es una publicación antigua, pero hoy estaba buscando algo como esto. Al final escribí el código yo mismo:

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

No se recomienda para listas largas, esto no está optimizado en absoluto. Es una especie de solución fácil para escenarios controlados (las Listas que manejo no tienen más de 100 elementos).

Espero que ayude a alguien.

Yo uso esto:

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

}

Me gusta esto:

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

También puedes hacer esto:

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

También puede invertir la posición cuando solicita un objeto:

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

Para una lista de tamaño pequeño, podemos crear LinkedListy luego usar el 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

Utiliza reverse(...)métodos de java.util.Collectionsclase. Pase su lista como parámetro y su lista se revertirá.

Collections.reverse(list);