secuencias - java util iterator integer

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

Question

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

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

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 implementaciones de List tienen descendingIterator() que es lo que necesito. Aunque no hay una implementación general para la List . Lo que es un poco extraño porque la implementación que he visto en LinkedList es lo suficientemente general para trabajar con cualquier List .

Answer 1

Collections.reverse (números) ... En realidad, invierte el orden de los elementos. Debajo del 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.

Answer 2

No es exactamente elegante, pero si usa List.listIterator (índice int) 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()
}

Answer 3

Para listas de tamaño pequeño, podemos crear LinkedList y luego usar 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

Answer 4

Sé que este es un post antiguo, 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 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.

Answer 5

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

 Collections.reverse(yourList);

Answer 6

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

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

Answer 7

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

Answer 8

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

Es decir,

Collections.reverse(list.clone());

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

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

Answer 9

Utilice los métodos de reverse(...) de la clase java.util.Collections . Pase su lista como un parámetro y su lista se anulará.

Collections.reverse(list);

Answer 10

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

Answer 11

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]

A diferencia de Collections.reverse , esta 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.

Answer 12

java.util.Deque tiene un java.util.Deque descendingIterator() - si tu List es un Deque , puedes usarlo.