Cómo invertir una lista en Java?

Question

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

No deseo hacer ningún tipo de copia de la lista ni modificar la lista.

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 por mí mismo. Solo estoy preguntando si Java ya ofrece algo como esto.

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

---

que acaba de descubrir que algunas implementaciones tienen ListdescendingIterator() que es lo que necesito. Aunque no existe una implementación general de este tipo para List. Lo cual es un poco extraño porque la implementación que he visto en LinkedList es lo suficientemente general para funcionar con cualquier List.

Answer 1

Guava proporciona la siguiente: Lists.reverse(List)

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

A diferencia 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 en la lista original y la vista se reflejan en la otra.

Answer 2

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

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

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

Answer 3

java.util.Deque tiene descendingIterator() - si su List es a Deque, puede usar eso.

Answer 4

Utilice 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 usa Colecciones.

Ergo,

Collections.reverse(list.clone()); 

Si está utilizando un List y no tiene acceso a clone() puede utilizar subList():

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

Answer 5

Sé que esto es una entrada 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 recomendado para largas Listas, 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.

Answer 6

También puede 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; 
} 

Answer 7

si he entendido correctamente, entonces es una línea de código .Es trabajó para mí.

Collections.reverse(yourList); 

Answer 8

utilizo este:

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

} 

así:

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

Answer 9

Collections.reverse (nums) ... En realidad, invertir el orden de los elementos. A continuación 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); 

Collections.sort(nums); 

Collections.reverse(nums); 

System.out.println(nums); 

Answer 10

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

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

Answer 11

Para la lista de tamaño pequeño podemos crear LinkedList y luego se puede hacer uso de 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); // Four, Three, Two, One 
System.out.println(stringList); // One, Two, Three, Four