Discussion :

[sonia5]

Bonjour, tout le monde

Je travaille avec un ArrayList et je veux modifier ses èlèments.

Voici mon code

Code :

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

1
2
3
4
5
6
7
8
9
10
 
List l = new ArrayList();
…
 
for (int i = 0; i < l.size(); i++) {
//je supprime
l.remove(i);
//j’ajoute dans la meme position
l.add(i,”test”);
}

Est ce que c’est mieux de suprimer et insèrer ou bien il y a une mèthode qui fait la modification automatiquement ?

Merci d'avance

[eric39]

Bonjour,

L'interface List propose une méthode 'Set' qui permet de remplacer un élément à un index particulier:

Code :

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

1
2
 
set(int index, E element)

Voilà.

[thelvin]

Par ailleurs, si le but est de traiter toute la List, il vaut mieux utiliser un ListIterator :

Code :

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

1
2
3
4
5
6
ListIterator itr = l.listIterator();
while(itr.hasNext()) {
  Object o = itr.next();
  // remplace le dernier élément renvoyé par next()
  itr.set("test");
}

Cela évitera les performances catastrophiques si l s'avère être une LinkedList ou assimilé.

[eatherquake]

Moi on m'avait dit de ne jamais utiliser d'Iterator, car justement, ses perf sont catastrophique au regard des boucles for et while ...
http://www.mkyong.com/java/while-loo...nce-test-java/
Il y a un problème spécifique lié au linkedList pour utiliser un Iterator?

[Alkhan]

bonjour,

Il y a un problème spécifique lié au linkedList pour utiliser un Iterator?

il n'y a pas de problème avec les linkedList, mais de part son implémentation il est logique qu'avec un iterator ce soit plus rapide.
Chaque noeud de la liste connait son suivant et son précédant, donc c'est très rapide.
Maintenant le lien que tu as donné ne fait le test que sur une arrayList qui est basé sur un tableau et donc en effet dans ce cas il est plus rapide de faire des accès par get plutot que par une itération.

Concrètement cela dépend de la collection que tu utilises.

Dans penser en java, le chapitre collection il y a justement un test par type de collection, les résultats sont beaucoup plus instructif que dans ton lien.

[eatherquake]

ok merci

[adiGuba]

Salut,

Moi on m'avait dit de ne jamais utiliser d'Iterator, car justement, ses perf sont catastrophique au regard des boucles for et while ...

C'est une fausse idée reçu !!! Au contraire il est fortement conseillé de préférer l'Iterator !

Déjà il faut se méfier des micro-benchmark. Sans connaitre très bien les éléments qu'on manipule on peut arriver à fausser des résultats.

L'Iterator te garantie généralement le meilleur compromis entre sécurité et performance, bien adapté à la structure de donnée.



J'ai testé son code et j'obtiens a peu près les même résultats

Code :

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

1
2
3
Iterator - Elapsed time in milliseconds: 384
For - Elapsed time in milliseconds: 250
While - Elapsed time in milliseconds: 247

Outre le fait que le résultat n'est pas catastrophique (moins de 150ms pour 15 millions d'éléments - c'est sur cela permet de faire de beau graphique mais bon ), il faut voir que son test a une autre particularité : il n'utilise pas n'importe quel type de List mais le type privé Arrays.ArrayList. En effet il crée sa liste à partir d'un tableau via Arrays.asList(), qui renvoie en fait une implémentation simpliste permettant d'accéder au tableau à travers une List.

Code :

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

1
2
3
String sArray[] = createArray();
//convert array to list
List lList = Arrays.asList(sArray);

Cette implémentation se démarque par l'utilisation d'un Iterator par défaut, pas du tout adapté à la structure de donnée.

Du coup oui on se retrouve avec un résultat moyen... Surtout que la boucle for/while est, elle, adapté à la structure de donnée...



Afin d'être plus cohérent, on va remplacer sa méthode createArray() par une méthode qui va vraiment générer une List :

Code :

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

1
2
3
4
5
6
7
8
	static List<String> createList() {
		List<String> list = new ArrayList<String>(15000000);
 
		for (int i = 0; i < 15000000; i++)
			list.add( "Array " + i );
 
		return list;
	}

Avec une ArrayList on obtient des temps très proches dans les 3 cas :

Code :

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

1
2
3
Iterator - Elapsed time in milliseconds: 266
For - Elapsed time in milliseconds: 253
While - Elapsed time in milliseconds: 256

Remplaces l'ArrayList par une LinkedList et là tu auras vraiment des temps catastrophiques pour le for/while car ils ne sont pas du tout adapté à la structure de données !!!

Tellement catastrophique qu'on peut réduire la quantité de données pour tester. Avec une LinkedList et 100000 éléments (au lieu de 15000000), j'obtiens ceci :

Code :

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

1
2
3
Iterator - Elapsed time in milliseconds: 2
For - Elapsed time in milliseconds     : 5536
While - Elapsed time in milliseconds   : 5532

Pour info j'ai lancé le programme avec une LinkedList de 15000000 éléments. Cela m'a pris moins de 300ms via l'Iterator, mais la boucle fort n'est pas encore terminée (ca doit faire environ 5 minutes que ca tourne... )


Si on rajoute à cela le fait que l'Iterator nous protège des erreurs de parcours, je dirais qu'au contraire il n'y a strictement aucune raison d'utiliser la boucle for/while pour parcourir une collection !!!


a++

[adiGuba]

Pour en revenir au sujet initial : la bonne réponse est bien entendu celle de thelvin qui consiste à utiliser un ListIterator et sa méthode set() qui remplacera l'élément sans casser la structure de donnée (un remove+add indexé sur une ArrayList causera beaucoup de déplacement mémoire).


Quand à moi avec vos conneries j'ai une boucle for qui tourne depuis plus d'une heure, et qui me bouffe 100% du CPU (heureusement que j'ai un multicore !!!).


a++