Перебор списка в обратном порядке в Java

Question

Я переношу кусок кода, чтобы использовать дженерики. Один из аргументов для этого заключается в том, что цикл for намного чище, чем отслеживание индексов или использование явного итератора.

Примерно в половине случаев список (ArrayList) итерируется в обратном порядке с использованием индекса сегодня.

Может кто-нибудь предложить более чистый способ сделать это (поскольку мне не нравится indexed for loop при работе с коллекциями), хотя он работает?

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

Примечание: Я не могу добавить новые зависимости вне JDK.

Answer 1

Попробуйте это:

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

Answer 2

Гуава предлагает Lists#reverse(List) и ImmutableList#reverse(). Как и в большинстве случаев для Гуавы, первый делегируется второму, если аргумент ImmutableList, так что вы можете использовать первый во всех случаях. Они не создают новые копии списка, а просто «обращают его взгляды».

Пример

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

Answer 3

Я не думаю, что это возможно, используя синтаксис цикла for. Единственное, что я могу предложить, это сделать что-то вроде:

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

... но я бы не сказал, что это "чище", учитывая, что оно будет менее эффективным.

Answer 4

Вариант 1. Задумывались ли вы о реверсировании списка с помощью Collections # reverse () и последующем использовании foreach?

Конечно, вы также можете реорганизовать свой код так, чтобы список был упорядочен правильно, поэтому вам не нужно его реверсировать, что использует дополнительное пространство / время.

---

EDIT:

Вариант 2. В качестве альтернативы, вы могли бы использовать Deque вместо ArrayList? Это позволит вам перебирать вперед и назад

---

EDIT:

Вариант 3: Как уже предлагали другие, вы могли бы написать Итератор, который будет перебирать список в обратном порядке, вот пример:

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

Answer 5

Вы можете использовать конкретный класс LinkedList вместо общего интерфейса List. Тогда у вас есть descendingIterator для итерации в обратном направлении.

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

Не знаю, почему нет descendingIterator с ArrayList ...

Answer 6

Это старый вопрос, но ему не хватает java8-дружественного ответа. Вот несколько способов сделать итерацию списка с помощью Streaming API:

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

Answer 7

Создать кастом reverseIterable.

Answer 8

Если списки довольно малы, так что производительность не является реальной проблемой, можно использовать reverse -метод Lists -класса в Google Guava. Дает довольно for-each -код, и оригинальный список остается прежним. Кроме того, обратный список поддерживается исходным списком, поэтому любое изменение исходного списка будет отражено в обратном.

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

Дает следующий результат:

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

Это означает, что обратная итерация myList может быть записана как:

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

Answer 9

Вот (непроверенная) реализация ReverseIterable. Когда вызывается iterator(), он создает и возвращает частную реализацию ReverseIterator, которая просто отображает вызовы на hasNext() на hasPrevious(), а вызовы на next() отображаются на previous(). Это означает, что вы можете перебрать ArrayList в обратном порядке следующим образом:

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

Определение класса

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

Answer 10

Очень простой пример:

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