我正在迁移一段代码以使用泛型。这样做的一个理由是，for循环比跟踪索引或使用显式迭代器干净得多。
在大约一半的情况下，列表(ArrayList)通过使用索引以相反的顺序迭代。
谁能建议一种更干净的方法来做到这一点(因为我不喜欢索引for循环时使用集合)，尽管它确实有效?
for (int i = nodes.size() - 1; i >= 0; i--) {
final Node each = (Node) nodes.get(i);
...
}
注意:我不能在JDK之外添加任何新的依赖项。
当前回答
正如至少两次建议的那样，您可以将descent iterator用于Deque，特别是用于LinkedList。如果你想使用for-each循环(即拥有一个Iterable)，你可以构造并使用这样的包装器:
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);
}
}
}
其他回答
试试这个:
// 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());
}
创建一个定制的reverseIterable。
下面是一个(未经测试的)ReverseIterable的实现。当iterator()被调用时，它创建并返回一个私有的ReverseIterator实现，它简单地将对hasNext()的调用映射到hasPrevious()，并将对next()的调用映射到previous()。这意味着你可以逆向遍历一个数组列表，如下所示:
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()));
}
}
Valid for Java 9+
List<String> strList = List.of("a", "b", "c", "d", "e");
IntStream.iterate(strList.size() - 1, i -> i >= 0, i -> --i)
.mapToObj(strList::get)
.forEach(System.out::println);
如果列表相当小，因此性能不是真正的问题，则可以使用谷歌Guava中的lists类的反向方法。每个代码都产生相当的结果，并且原始列表保持不变。另外，反向列表是由原始列表支持的，因此对原始列表的任何更改都将反映在反向列表中。
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
}
