Problème avec une itération

Version imprimable

Bonjour,

J'ai un problème avec le code suivant
Code:

1 2 3 4 5 6 7 public T prochainElement() { T element = null; if (iterateur.hasNext()) { element = iterateur.next(); // c est ici ou je me plante } return element; }
iterateur c'est un attribut de la classe listImpl que j'utilise pour parcourir mes listes.

J'ai utilisé iterateur.next() dans d'autres méthodes et ça fonctionne mais ici ça me donne un exception java.util.ConcurrentModificationException

Quelqu'un saurait-il m'expliquer d'où vient le problème ?

Merci d'avance pour votre aide.

08/10/2011, 10h23
welcome_59

java.util.ConcurrentModificationException survient en général lorsque tu essaies de modifier ta liste pendant son parcours (ou l'inverse).

Le code que tu as posté est insuffisant pour te dire ce qui se passe précisément dans ton cas, idem pour les solutions.

Poste le code de la classe, celui dans lequel tu l'utilises et la trace complète de l'exception.

le code en entier

Citation:

Envoyé par welcome_59

java.util.ConcurrentModificationException survient en général lorsque tu essaies de modifier ta liste pendant son parcours (ou l'inverse).

Le code que tu as posté est insuffisant pour te dire ce qui se passe précisément dans ton cas, idem pour les solutions.

Poste le code de la classe, celui dans lequel tu l'utilises et la trace complète de l'exception.

Voici mon code. Ce que j'essaye de faire c'est d'ajouter une liste sur une autre liste qui n'accepte pas des doublons.

Code:

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
public class ListeAdtArraylistImpl<T> implements ListeAdt<T> {
 
    private ArrayList<T> listeAdt;
    private Iterator<T> iterateur;
 
    public ListeAdtArraylistImpl() {
        listeAdt = new ArrayList<T>();
        iterateur = listeAdt.iterator();
        }
    public T[] ajouter(ListeAdt<T> liste) {
        ArrayList<T> listElementNonAjoute = new ArrayList<T>();
        while (liste.existeProchainElement() && liste != null) {
            T elementCourant = liste.prochainElement();
            if (liste.estElements(elementCourant)) {
                ajouter(elementCourant);
            } else {
                listElementNonAjoute.add(elementCourant);
            }
        }
        return (T[]) listElementNonAjoute.toArray();
    }
 
    public boolean estElements(T element) {
        for (T elementExiste : listeAdt) {
            if (elementExiste.equals(element)) {
                return true;
            }
        }
        return false;
    }
public T prochainElement() {
T element = null;
if (iterateur.hasNext()) {
element = iterateur.next(); // c est ici ou je me plante 
}
return element;
}

09/10/2011, 11h21
welcome_59
Citation:

Ce que j'essaye de faire c'est d'ajouter une liste sur une autre liste qui n'accepte pas des doublons

Pourquoi pas simplement :
Code:

1 2 3 4 5 Set<T> collectionSansDoublons = new HashSet<T>(); ... // Tu peux utiliser ton set List<T> liste = new ArrayList<T>(); ... //Tu peux utiliser ta liste (la remplir par exemple)
Et tu peux ajouter des éléments à ton set
Code:

1 2 collectionSansDoublons.addAll(liste); //pour ajouter tous les éléments de la liste
ou
Code:

1 2 collectionSansDoublons.add(liste.get(0)); // pour ajouter un seul élément de la liste
Les Set sont des collections qui n'acceptent pas les doublons et la gestion du problème est implémentée en "natif" dans l'API. C'est plus sûr et plus rapide.
10/10/2011, 00h40
ayago
Citation:
Envoyé par welcome_59

Pourquoi pas simplement :

Code:

1 2 3 4 5 Set<T> collectionSansDoublons = new HashSet<T>(); ... // Tu peux utiliser ton set List<T> liste = new ArrayList<T>(); ... //Tu peux utiliser ta liste (la remplir par exemple)

Et tu peux ajouter des éléments à ton set

Code:

1 2 collectionSansDoublons.addAll(liste); //pour ajouter tous les éléments de la liste

ou

Code:

1 2 collectionSansDoublons.add(liste.get(0)); // pour ajouter un seul élément de la liste

Les Set sont des collections qui n'acceptent pas les doublons et la gestion du problème est implémentée en "natif" dans l'API. C'est plus sûr et plus rapide.
merci pour la proposition. mais je n'ai pas le droit d'utiliser autre structure que ArrayList, aussi je dois faire usage aux méthodes que moi même j'ai développer c-à-d estElement(T element); prochainElement(); ajouter(T element); pour développer la méthode ajouter(listeAdt<T> liste);
si vous avez une autre piste ça va beaucoup m'aider
Merci d'avance
10/10/2011, 14h13
wax78

Tu utilises 2 thread qui jouent avec ton arrayList ? (Ce que je suppose Welcome voulait dire dans son premier message, on ne voit pas "qui" joue avec la liste)

Si oui, as tu bien crée ta liste avec ?

Code:

List list = Collections.synchronizedList(new ArrayList(...));

en fin solution trouver

voici la solution que j ai pu trouver grâce a vos éclaircissement, si vous voyez une façon plus optimiser pour faire bienvenue a toute autres suggestions :;)

Code:

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
 
public class ListeAdtArraylistImpl<T> implements ListeAdt<T> {
 
	/**
         * Liste des éléments de la pile.
         */
	private ArrayList<T> listeAdt;
	private Iterator<T> iterateur;
 
	public ListeAdtArraylistImpl() {
		listeAdt = new ArrayList<T>();
		iterateur = listeAdt.iterator();
	}
 
public T[] ajouter(ListeAdt<T> liste) {
		ArrayList<T> listeElementNonAjoute = new ArrayList<T>();
		ArrayList<T> listeElementAjoute = new ArrayList<T>();
 
		for (T element : listeAdt) {
			if (liste.estElements(element)) {
				listeElementNonAjoute.add(element);
			} else {
				listeElementAjoute.add(element);
			}
		}
		for (T t : listeElementAjoute) {
			liste.ajouter(t);
		}
		return (T[]) listeElementNonAjoute.toArray();
 
	}

Code:

1
2
3
public T prochainElement() {
		return listeAdt.iterator().next();
	}

je l'ai tester est ça marche, pour si quelqu'un trouveras un jour le même problème au moins ça va donner une piste.:ccool: