Iterando uma Lista em Ordem Inversa em Java

Estou migrando um pedaço de código para fazer uso de genéricos. Um argumento para fazer isso é que o loop for é muito mais limpo do que controlar os índices ou usar um iterador explícito.

Em cerca de metade dos casos, a lista (um ArrayList) está sendo iterada na ordem inversa, usando um índice hoje.

Alguém pode sugerir uma maneira mais limpa de fazer isso (já que eu não gosto indexed for loopquando trabalho com coleções), embora funcione?

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

Nota: Não consigo adicionar novas dependências fora do JDK.

Tente o seguinte:

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

GoiabaLists#reverse(List) e ofertas ImmutableList#reverse(). Como na maioria dos casos para o Goiaba, o primeiro delega para o último se o argumento for um ImmutableList, então você pode usá-lo em todos os casos. Isso não cria novas cópias da lista, mas apenas "visões invertidas" dela.

Exemplo

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

Eu não acho que é possível usar a sintaxe do loop for. A única coisa que posso sugerir é fazer algo como:

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

... mas eu não diria que isso é "mais limpo", uma vez que será menos eficiente.

Opção 1: Você pensou em reverter a lista com coleções # reverse () e depois usar o foreach?

Obviamente, você também pode refatorar seu código, de modo que a lista seja ordenada corretamente, para que você não precise revertê-lo, o que utiliza espaço / tempo extra.

EDITAR:

Opção 2: Como alternativa, você poderia usar um Deque em vez de um ArrayList? Permite iterar para frente e para trás

EDITAR:

Opção 3: Como outros sugeriram, você pode escrever um Iterador que percorrerá a lista ao contrário, e aqui está um exemplo:

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

Você poderia usar a classe concreta em LinkedListvez da interface geral List. Então você tem um descendingIteratorpara iterar com a direção reversa.

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

Não sei por que não há descendingIteratorcom ArrayList...

Esta é uma pergunta antiga, mas está faltando uma resposta amigável para java8. Aqui estão algumas maneiras de reverter a iteração da lista, com a ajuda da 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

Aqui está uma implementação (não testada) de a ReverseIterable. Quando iterator()é chamado, ele cria e retorna uma ReverseIteratorimplementação privada , que simplesmente mapeia as chamadas hasNext()para hasPrevious()e as chamadas para next()são mapeadas previous(). Isso significa que você pode iterar um ArrayListinverso da seguinte maneira:

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

Definição de classe

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

Se as listas forem razoavelmente pequenas para que o desempenho não seja um problema real, é possível usar o reversemétodo-da Listsclasse-in Google Guava. for-eachProduz um código bonito e a lista original permanece a mesma. Além disso, a lista invertida é apoiada pela lista original, portanto, qualquer alteração na lista original será refletida na lista invertida.

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

Rende o seguinte resultado:

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

O que significa que a iteração reversa do myList pode ser escrita como:

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

Crie um costume reverseIterable.

Exemplo muito simples:

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) {
  ...
}

Você pode usar ReverseListIteratoras coleções-Apache Commons:

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

Também encontrou o método reverso das coleções do google .

Para ter um código parecido com este:

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

Coloque esse código em um arquivo chamado "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 foi sugerido pelo menos duas vezes, você pode usar descendingIteratorcom a Deque, em particular com a LinkedList. Se você quiser usar o loop for-each (ou seja, possuir um Iterable), poderá construir e usar um 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);
        }
    }
}

Razão: "Não sei por que não há descendingIterator com ArrayList ..."

Como a lista de matrizes não mantém a lista na mesma ordem em que os dados foram adicionados à lista. Portanto, nunca use Arraylist.

A lista vinculada manterá os dados na mesma ordem de ADD para listar.

Então, acima no meu exemplo, usei ArrayList () para fazer com que o usuário torça a cabeça e faça com que exercite algo do lado deles.

Em vez disso

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

USAR:

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) {
  ...
}