La liste conserve une référence d'objet à la valeur d'origine stockée dans la liste. Donc lorsque vous exécutez cette ligne :
Integer x = i.next();
À la fois x et la liste stockent une référence au même objet. Cependant, lorsque vous exécutez :
x = Integer.valueOf(9);
rien n'a changé dans la liste, mais x stocke maintenant une référence à un objet différent. La liste n'a pas changé. Vous devez utiliser certaines des méthodes de manipulation de la liste, telles que
list.set(index, Integer.valueof(9))
Remarque : cela n'a absolument rien à voir avec l'immutabilité de Integer, comme le suggèrent d'autres. Il s'agit simplement du comportement de référence d'objet Java de base.
Voici un exemple complet, pour expliquer le point. Notez que cela utilise la classe ListIterator, qui prend en charge la suppression/le remplacement d'éléments en cours d'itération :
import java.util.*;
public class ListExample {
public static void main(String[] args) {
List fooList = new ArrayList();
for (int i = 0; i < 9; i++)
fooList.add(new Foo(i, i));
// Itérateur standard suffisant pour modifier les éléments
Iterator iterator = fooList.iterator();
if (iterator.hasNext()) {
Foo foo = iterator.next();
foo.x = 99;
foo.y = 42;
}
printList(fooList);
// Itérateur de liste nécessaire pour remplacer des éléments
ListIterator listIterator = fooList.listIterator();
if (listIterator.hasNext()) {
// Besoin d'appeler next, avant set.
listIterator.next();
// Remplacer l'élément retourné par next()
listIterator.set(new Foo(99,99));
}
printList(fooList);
}
private static void printList(List list) {
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next());
}
System.out.println();
}
private static class Foo {
int x;
int y;
Foo(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return String.format("[%d, %d]", x, y);
}
}
}
Cela affichera :
[99, 42][1, 1][2, 2][3, 3][4, 4][5, 5][6, 6][7, 7][8, 8]
[99, 99][1, 1][2, 2][3, 3][4, 4][5, 5][6, 6][7, 7][8, 8]
