Suppression d'un élément de liste différent de l'itérateur

**bobuse** · 08/02/2007, 17h57

Bon, le titre est un peu bof.

Mon problème :
Je fais une boucle sur les éléments d'une liste avec un itérateur. Ces éléments peuvent éventuellement être supprimé de la liste, d'où l'intérêt de l'itérateur.
Bon maintenant, admettons que pour un élément donné je détermine la suppression d'un autre élément de la même liste, y a-t-il un moyen propre de faire ça ?
Car mon itérateur est le seul moyen de supprimer un élément dans la liste sans déclencher une ConcurrentModificationException.

La solution qui me vient à l'esprit est de ne pas utiliser d'itérateur et boucler avec un indice et gérer moi-même les effets de bords lors de suppression

Me goure-je ?

Votre avis ?

**adiGuba** · 08/02/2007, 18h00

Salut,

Quel est le type exact de la liste ?
Comment fais tu pour déterminer qu'un élément donné doive supprimé un autre élément ?

a++

**bobuse** · 08/02/2007, 18h08

Salut

Ma liste est de type List

Et le critère peut être très variable puisque je suis dans une classe abstraite. En fait je code un framework où j'ai une liste d'individu sur lesquels j'effectue un traitement individuel. Et ce traitement peut déclencher (selon des critères variables) des actions genre suppression d'un individu de la liste.

**bobuse** · 08/02/2007, 18h31

Bon je vais illustrer par un exemple, ce sera plus parlant ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
public class Removes {
 
	static class Individu {
		double value;
		public Individu(double value) {
			this.value = value;
		}
		@Override
		public String toString() {
			return ""+value;
		}
	}
	static class MaListe {
		List<Individu> individus;
		public MaListe(List<Individu> l1) {
			this.individus = l1;
		}
 
		public void boucle(Traitement traitement) {
			for (ListIterator<Individu> it=individus.listIterator(); it.hasNext();) {
				traitement.faire(it, it.next(), individus);
			}
		}
	}
 
	static abstract class Traitement {
		public abstract void faire(ListIterator<Individu> it, Individu ind, List<Individu> liste);
	}
 
	static class UnTraitement extends Traitement {
		@Override
		public void faire(ListIterator<Individu> it, Individu ind, List<Individu> liste) {
			if (ind.value == 0.42) 
				; // TODO supprimer l'élément avant et celui après
			else if (ind.value == 0)
				it.remove();
		}		
	}
 
	static void test() {
		Individu[] individus = {new Individu(0.2),new Individu(0),new Individu(0.9),new Individu(0.42),new Individu(0.5),new Individu(0.8)};
		MaListe maListe = new MaListe(new ArrayList<Individu>(Arrays.asList(individus)));
		maListe.boucle(new UnTraitement());
		System.out.println(maListe.individus);
	}
	public static void main(String[] args) {
		test();
	}
}

Donc, voilà une liste d'individus (MaListe) avec une méthode pour effectuer un traitement en boucle. Et une implémentation de traitement dans lequel je veux supprimer de la liste les deux éléments périphérique si une condition est vrai. Y a-t-il un moyen de le faire comme ça facilement ?

**Sanguko** · 08/02/2007, 18h42

Une solution sure consiste a passer par une liste qui contient les elements a supprimer, que tu remplis au fur et a mesure. Et a la fin du traitement, tu retires cette liste à la liste individus.

**adiGuba** · 08/02/2007, 21h47

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

; // TODO supprimer l'élément avant et celui après

C'est surtout ca que je voulais savoir

Avec une List tu peux utiliser un ListIterator qui permet un parcours dans les deux sens...

a++

**bobuse** · 09/02/2007, 11h43

Envoyé par Sanguko

Une solution sure consiste a passer par une liste qui contient les elements a supprimer, que tu remplis au fur et a mesure. Et a la fin du traitement, tu retires cette liste à la liste individus.

J'y ai pensé, mais le problème est que les individus supprimer ne doivent pas être pris en compte dans le reste de la boucle. Donc ça implique de regarder à chaque itération, si l'élément pointé n'est pas dans la liste des éléments à supprimer.

**bobuse** · 09/02/2007, 11h45

Envoyé par adiGuba

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

; // TODO supprimer l'élément avant et celui après

C'est surtout ca que je voulais savoir

Avec une List tu peux utiliser un ListIterator qui permet un parcours dans les deux sens...

a++

Oui, mais ce n'est qu'un exemple. Ce peut être aussi supprimer les éléments dont la valeur d'un attribut est inférieur à celle de l'élément en cours (autre exemple).

Mais en fait, est-ce que je ne peux pas créer un second itérateur sur ma liste qui se chargera des suppressions ? Vais tenter ça ...