Lorsque j'effectue une itération inverse sur une ArrayList, je reçois une exception IndexOutOfBoundsException. J'ai essayé de faire une itération en avant et il n'y a pas de problème. J'attends et je sais qu'il y a cinq éléments dans la liste. Le code est ci-dessous:
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));
}
Itération en avant - qui fonctionne bien, mais qui ne me sert à rien:
for(int j=0;j<list.size();j++){
System.out.println(list.isEmpty());
System.out.println(list.get(j));
} // this worked fine
L'erreur:
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)
De plus, si quelqu'un connaît un meilleur langage pour l'itération inversée, je serais heureux de l'essayer.
Démarrez l'itération à list.size() - 1
car les éléments array (ou ArrayList
) sont numérotés de 0 à 1 de moins que la taille de la liste. C'est un idiome assez standard:
for (int j = list.size() - 1; j >= 0; j--) {
// whatever
}
Notez que votre itération directe fonctionne car elle arrête avant pour atteindre list.size()
.
Évitez les index tout à fait? Que diriez-vous:
for (ListIterator iterator = list.listIterator(list.size()); iterator.hasPrevious();) {
final Object listElement = iterator.previous();
}
Je sais que cette question est ancienne, mais Java contient une méthode Collections.reverse( List<T> )
. Pourquoi ne pas simplement l'inverser et faire une itération en avant?
La méthode la plus élégante consiste à inverser le tableau, puis à utiliser un itérateur direct (ou même implicite):
Collections.reverse(arrayList);
for (Object item : arrayList) {
...
}
List.size () est passé le dernier index autorisé.
for(int j = list.size() - 1; j >= 0; j--) {
System.out.println(list.get(j));
}
Les tableaux Java sont indexés à zéro . Vous devrez définir j = list.size () - 1 et continuer jusqu'à j = 0.
Si les listes sont assez petites pour que les performances ne soient pas un réel problème, vous pouvez utiliser la métrique reverse
- de la classe Lists
- dans Google Guava
. Rend jolie for-each
- code et la liste originale reste la même. De plus, la liste inversée est accompagnée de la liste d'origine. Toute modification apportée à la liste d'origine sera reflétée dans la liste inversée.
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);
Donne le résultat suivant:
[one, two, three]
[three, two, one]
[one, two, three, four]
[four, three, two, one]
Ce qui signifie que l'itération inverse de myList peut être écrite comme suit:
for (final String someString : Lists.reverse(myList) {
//do something
}
Vous pouvez inverser d'une ligne
Collections.reverse (liste);
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);
Sortie
Before Reverse Order : [A, B]
After Reverse : [B, A]
Vous pouvez le faire si vous êtes à l'aise avec la boucle 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());
}