Iterando a través de una lista en orden inverso en Java

Estoy migrando un fragmento de código para hacer uso de genéricos. Un argumento para hacerlo es que el ciclo for es mucho más limpio que hacer un seguimiento de los índices o usar un iterador explícito.

En aproximadamente la mitad de los casos, la lista (una ArrayList) se itera en orden inverso mediante el uso de un índice hoy.

¿Alguien puede sugerir una forma más limpia de hacerlo (ya que no me gusta indexed for loopcuando trabajo con colecciones), aunque funciona?

 for (int i = nodes.size() - 1; i >= 0; i--) {
    final Node each = (Node) nodes.get(i);
    ...
 }

Nota: No puedo agregar ninguna dependencia nueva fuera del JDK.

Prueba esto:

// Substitute appropriate type.
ArrayList<...> a = new ArrayList<...>();

// Add elements to list.

// Generate an iterator. Start just after the last element.
ListIterator li = a.listIterator(a.size());

// Iterate in reverse.
while(li.hasPrevious()) {
  System.out.println(li.previous());
}

Ofertas de guayabaLists#reverse(List) y ImmutableList#reverse(). Como en la mayoría de los casos para Guava, el primero delega a este último si el argumento es un ImmutableList, por lo que puede usar el primero en todos los casos. Estos no crean nuevas copias de la lista, sino simplemente "vistas invertidas" de la misma.

Ejemplo

List reversed = ImmutableList.copyOf(myList).reverse();

No creo que sea posible usar la sintaxis del bucle for. Lo único que puedo sugerir es hacer algo como:

Collections.reverse(list);
for (Object o : list) {
  ...
}

... pero no diría que esto es "más limpio" dado que será menos eficiente.

Opción 1: ¿Ha pensado en invertir la Lista con Colecciones # reverse () y luego usar foreach?

Por supuesto, es posible que también desee refactorizar su código de modo que la lista esté ordenada correctamente para que no tenga que revertirla, lo que usa espacio / tiempo adicional.

EDITAR:

Opción 2: Alternativamente, ¿podría usar una Deque en lugar de una ArrayList? Te permitirá iterar hacia adelante y hacia atrás

EDITAR:

Opción 3: como otros han sugerido, puede escribir un iterador que recorra la lista al revés, aquí hay un ejemplo:

import java.util.Iterator;
import java.util.List;

public class ReverseIterator<T> implements Iterator<T>, Iterable<T> {

    private final List<T> list;
    private int position;

    public ReverseIterator(List<T> list) {
        this.list = list;
        this.position = list.size() - 1;
    }

    @Override
    public Iterator<T> iterator() {
        return this;
    }

    @Override
    public boolean hasNext() {
        return position >= 0;
    }

    @Override
    public T next() {
        return list.get(position--);
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }

}


List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");

for (String s : new ReverseIterator<String>(list)) {
    System.out.println(s);
}

Podría usar la clase concreta en LinkedListlugar de la interfaz general List. Entonces tienes un descendingIteratorpara iterar con la dirección inversa.

LinkedList<String > linkedList;
for( Iterator<String > it = linkedList.descendingIterator(); it.hasNext(); ) {
    String text = it.next();
}

No sé por qué no hay descendingIteratorcon ArrayList...

Esta es una vieja pregunta, pero carece de una respuesta amigable para java8. Aquí hay algunas formas de iterar en reversa la lista, con la ayuda de la API de Streaming:

List<Integer> list = new ArrayList<Integer>(Arrays.asList(1, 3, 3, 7, 5));
list.stream().forEach(System.out::println); // 1 3 3 7 5

int size = list.size();

ListIterator<Integer> it = list.listIterator(size);
Stream.generate(it::previous).limit(size)
    .forEach(System.out::println); // 5 7 3 3 1

ListIterator<Integer> it2 = list.listIterator(size);
Stream.iterate(it2.previous(), i -> it2.previous()).limit(size)
    .forEach(System.out::println); // 5 7 3 3 1

// If list is RandomAccess (i.e. an ArrayList)
IntStream.range(0, size).map(i -> size - i - 1).map(list::get)
    .forEach(System.out::println); // 5 7 3 3 1

// If list is RandomAccess (i.e. an ArrayList), less efficient due to sorting
IntStream.range(0, size).boxed().sorted(Comparator.reverseOrder())
    .map(list::get).forEach(System.out::println); // 5 7 3 3 1

Aquí hay una implementación (no probada) de a ReverseIterable. Cuando iterator()se llama, crea y devuelve una ReverseIteratorimplementación privada , que simplemente asigna llamadas hasNext()a hasPrevious()y las llamadas a next()se asignan previous(). Significa que podría iterar sobre una ArrayListinversa de la siguiente manera:

ArrayList<String> l = ...
for (String s : new ReverseIterable(l)) {
  System.err.println(s);
}

Definición de clase

public class ReverseIterable<T> implements Iterable<T> {
  private static class ReverseIterator<T> implements Iterator {
    private final ListIterator<T> it;

    public boolean hasNext() {
      return it.hasPrevious();
    }

    public T next() {
      return it.previous();
    }

    public void remove() {
      it.remove();
    }
  }

  private final ArrayList<T> l;

  public ReverseIterable(ArrayList<T> l) {
    this.l = l;
  }

  public Iterator<T> iterator() {
    return new ReverseIterator(l.listIterator(l.size()));
  }
}

Si las listas son bastante pequeñas, de modo que el rendimiento no es un problema real, se puede usar el reversemétodo de la Listsclase en Google Guava. Produce un for-eachcódigo bonito , y la lista original permanece igual. Además, la lista reversa está respaldada por la lista original, por lo que cualquier cambio en la lista original se reflejará en la reversa.

import com.google.common.collect.Lists;

[...]

final List<String> myList = Lists.newArrayList("one", "two", "three");
final List<String> myReverseList = Lists.reverse(myList);

System.out.println(myList);
System.out.println(myReverseList);

myList.add("four");

System.out.println(myList);
System.out.println(myReverseList);

Produce el siguiente resultado:

[one, two, three]
[three, two, one]
[one, two, three, four]
[four, three, two, one]

Lo que significa que la iteración inversa de myList se puede escribir como:

for (final String someString : Lists.reverse(myList)) {
    //do something
}

Crea una costumbre reverseIterable.

Ejemplo muy simple:

List<String> list = new ArrayList<String>();

list.add("ravi");

list.add("kant");

list.add("soni");

// Iterate to disply : result will be as ---     ravi kant soni

for (String name : list) {
  ...
}

//Now call this method

Collections.reverse(list);

// iterate and print index wise : result will be as ---     soni kant ravi

for (String name : list) {
  ...
}

Puede usar ReverseListIteratorde Apache Commons-Collections:

https://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/iterators/ReverseListIterator.html

También encontré el método inverso de las colecciones de google .

Para tener un código que se vea así:

List<Item> items;
...
for (Item item : In.reverse(items))
{
    ...
}

Pon este código en un archivo llamado "In.java":

import java.util.*;

public enum In {;
    public static final <T> Iterable<T> reverse(final List<T> list) {
        return new ListReverseIterable<T>(list);
    }

    class ListReverseIterable<T> implements Iterable<T> {
        private final List<T> mList;

        public ListReverseIterable(final List<T> list) {
            mList = list;
        }

        public Iterator<T> iterator() {
            return new Iterator<T>() {
                final ListIterator<T> it = mList.listIterator(mList.size());

                public boolean hasNext() {
                    return it.hasPrevious();
                }
                public T next() {
                    return it.previous();
                }
                public void remove() {
                    it.remove();
                }
            };
        }
    }
}

Como se ha sugerido al menos dos veces, puede usar descendingIteratorcon a Deque, en particular con a LinkedList. Si desea utilizar el ciclo for-each (es decir, tener un Iterable), puede construir y utilizar un wraper como este:

import java.util.*;

public class Main {

    public static class ReverseIterating<T> implements Iterable<T> {
        private final LinkedList<T> list;

        public ReverseIterating(LinkedList<T> list) {
            this.list = list;
        }

        @Override
        public Iterator<T> iterator() {
            return list.descendingIterator();
        }
    }

    public static void main(String... args) {
        LinkedList<String> list = new LinkedList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");

        for (String s : new ReverseIterating<String>(list)) {
            System.out.println(s);
        }
    }
}

Motivo: "No sé por qué no hay ningún iterador descendente con ArrayList ..."

Dado que la lista de matriz no mantiene la lista en el mismo orden en que se agregaron los datos a la lista. Por lo tanto, nunca use Arraylist.

La lista vinculada mantendrá los datos en el mismo orden de AGREGAR a la lista.

Entonces, arriba en mi ejemplo, usé ArrayList () para hacer que el usuario tuerza su mente y haga que entrenen algo desde su lado.

En lugar de esto

List<String> list = new ArrayList<String>();

UTILIZAR:

List<String> list = new LinkedList<String>();

list.add("ravi");

list.add("kant");

list.add("soni");

// Iterate to disply : result will be as ---     ravi kant soni

for (String name : list) {
  ...
}

//Now call this method

Collections.reverse(list);

// iterate and print index wise : result will be as ---     soni kant ravi

for (String name : list) {
  ...
}