Il y a deux problèmes ici:
La première question est, l'ajout d'un Collection après Iterator est retourné. Comme mentionné, il n'existe pas de comportement lorsque le sous-jacent Collection est modifié, comme indiqué dans la documentation pour l' Iterator.remove:
... Le comportement d'un itérateur est
non spécifié si le sous-jacent
la collection est modifiée alors que l'
l'itération en cours, en quelque sorte
d'autres que par l'appel de cette méthode.
Le deuxième problème est que, même si un Iterator pourrait être obtenu, et ensuite revenir à l'élément même de l' Iterator a été à l', il n'y a aucune garantie sur l'ordre de la iteratation, comme indiqué dans l' Collection.iterator documentation de la méthode:
... Il n'y a pas de garanties concernant la
l'ordre dans lequel les éléments sont
retournés (à moins que cette collection est une
instance d'une classe qui fournit un
la garantie).
Par exemple, disons que nous avons la liste [1, 2, 3, 4].
Disons - 5 a été ajoutée lors de l' Iterator a été à l' 3, et d'une certaine façon, nous obtenons un Iterator qui peut reprendre l'itération de l' 4. Cependant, il n'existe aucune garantie qu' 5 viendront après 4. L'itération de l'ordre peuvent être [5, 1, 2, 3, 4] -- puis l'itérateur va encore manquer l'élément 5.
Comme il n'y a aucune garantie pour le comportement, on ne peut pas présumer que les choses vont se passer d'une certaine manière.
Une alternative pourrait être d'avoir un Collection à laquelle le nouvellement créé éléments peuvent être ajoutés, puis une itération sur les éléments:
Collection<String> list = Arrays.asList(new String[]{"Hello", "World!"});
Collection<String> additionalList = new ArrayList<String>();
for (String s : list) {
// Found a need to add a new element to iterate over,
// so add it to another list that will be iterated later:
additionalList.add(s);
}
for (String s : additionalList) {
// Iterate over the elements that needs to be iterated over:
System.out.println(s);
}
Modifier
L'élaboration de sur Avi, en réponse, il est possible de faire la queue les éléments que nous voulons parcourir dans une file d'attente, et de supprimer les éléments, tandis que la file d'attente a des éléments. Cela permettra à l' "itération" sur les nouveaux éléments en plus des éléments d'origine.
Voyons comment cela fonctionnerait.
Sur le plan conceptuel, si nous avons les éléments suivants dans la file d'attente:
[1, 2, 3, 4]
Et, quand on enlève 1, nous décidons d'ajouter 42, la file d'attente seront les suivantes:
[2, 3, 4, 42]
Comme la file d'attente est une FIFO (first-in, first-out) structure de données, ce classement est typique. (Comme indiqué dans la documentation de l' Queue interface, ce n'est pas une nécessité d'un Queue. Prenons le cas d' PriorityQueue qui trie les éléments par leur ordre naturel, ce qui n'est pas FIFO.)
L'exemple suivant est un exemple à l'aide d'un LinkedList (ce qui est une Queue) afin d'aller à travers tous les éléments le long avec des éléments supplémentaires ajoutés au cours de la dequeing. Similaire à l'exemple ci-dessus, l'élément 42 est ajouté lorsque l'élément 2 est supprimé:
Queue<Integer> queue = new LinkedList<Integer>();
queue.add(1);
queue.add(2);
queue.add(3);
queue.add(4);
while (!queue.isEmpty()) {
Integer i = queue.remove();
if (i == 2)
queue.add(42);
System.out.println(i);
}
Le résultat est le suivant:
1
2
3
4
42
Comme espéré, l'élément 42 qui a été ajouté lorsque nous avons touché 2 est apparu.
