通过ArrayList的反向迭代给IndexOutOfBoundsException异常

StackOverflow https://stackoverflow.com/questions/580269

题

当我反向迭代的ArrayList我得到一个IndexOutOfBoundsException异常。我试图做向前迭代，并没有问题。我希望，知道有列表中的五行。该代码是下面：

Collection rtns = absRtnMap.values();
List list = new ArrayList(rtns);
Collections.sort(list);

for(int j=list.size();j>0;j=j-1){
  System.out.println(list.get(j));
}

正向迭代 - 这是工作正常，但对我来说不是有用：

for(int j=0;j<list.size();j++){
    System.out.println(list.isEmpty());
    System.out.println(list.get(j));
} // this worked fine

在错误：

Exception in thread "Timer-0" java.lang.IndexOutOfBoundsException: Index: 3, Size: 3
    at java.util.ArrayList.RangeCheck(Unknown Source)
    at java.util.ArrayList.get(Unknown Source)
    at model.Return.getReturnMap(Return.java:61)
    at controller.Poller$1.run(Poller.java:29)
    at java.util.TimerThread.mainLoop(Unknown Source)
    at java.util.TimerThread.run(Unknown Source)

此外，如果任何人反向迭代更好成语知道我会很乐意去尝试了这一点。

有帮助吗？

解决方案

在list.size() - 1开始迭代因为阵列（或ArrayList）元件的从0到1编号小于所述列表的大小。这是相当标准的成语：

for (int j = list.size() - 1; j >= 0; j--) {
    // whatever
}

请注意，您的向前迭代的作品，因为它停止的前的深远list.size()。

其他提示

完全避免索引？如何：

for (ListIterator iterator = list.listIterator(list.size()); iterator.hasPrevious();) {
  final Object listElement = iterator.previous();
}

我知道这是一个老问题，但Java包含Collections.reverse( List<T> )方法。你为什么不将它取反，做向前迭代？

在最优雅的方式是扭转数组，然后使用直接（或甚至隐含的）迭代器：

Collections.reverse(arrayList);
for (Object item : arrayList) {
    ...
}

在则为list.size（）是过去的最后允许的索引。

for(int j = list.size() - 1; j >= 0; j--) {
  System.out.println(list.get(j));
}

的Java阵列零索引。 你将不得不设置J =则为list.size（） - 1，并继续直到J = 0

如果名单是相当小的，这样的表现是不是一个真正的问题，可以使用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
}

可以通过一条线扭转即

<强> Collections.reverse（列表）; 

ArrayList arrayList = new ArrayList();

arrayList.add("A");
arrayList.add("B");

System.out.println("Before Reverse Order : " + arrayList);

Collections.reverse(arrayList);

System.out.println("After Reverse : " + arrayList);

<强>输出 

Before Reverse Order : [A, B]
After Reverse : [B, A]

您可以做到这一点，如果你是舒服foreach循环。

List<String> list = new ArrayList<String>();
list.add("ABC");
list.add("DEF");
list.add("GHI");

ListIterator<String> listIterator = list.listIterator(list.size());

while(listIterator.hasPrevious()){
  System.out.println(listIterator.previous());
}
许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top