Goal : Joindre les éléments d'une liste avec un séparateur

Version imprimable

Ce post pourrait se trouver sur tous les forums relatifs à un langage. Etant plus vers Java, je me décide à poster ici. Mais, je ne suis pas fermé et j'avoue que les réponses d'un autre langage m’intéresse aussi.

Comment avez-vous traité ce snippet de façon élégante -volontairement écrit "gras et lourd" à piquer les yeux:
Code:

1 2 3 4 5 6 7 8 9 10 String result = ""; boolean first = true; for(String string : collection_de_String) { if(first) { result += string; first = false; } else { result += "," + string; } }
Tout le monde se confronte rapidement à ce bout de code. Aussi, j'aimerai savoir comment vous l'avez résolue ou si vous avez essayé de le rendre plus savoureux.

Je ne pense pas l'utilisation à des bibliothèques telles que GUAVA ou Apache qui permettent de résoudre cela en un appel.

A vos études, cours, TP, recherches, fantaisies.

En général la collection de String est une ArrayList ou similaire, du coup j'utilise plutôt un for indexé qu'un foreach, ce qui me dispense d'une variable "c'est le premier ou pas" :
Code:

1 2 3 4 5 6 7 8 StringBuilder builder = new StringBuilder(); for(int i = 0; i < collectionDeString.size(); i++) { if(i > 0) { builder.append(','); } builder.append(collectionDeString.get(i)); } return builder.toString();
Si je ne peux pas compter sur ArrayList ou similaire, j'utilise un itérateur :
Code:

1 2 3 4 5 6 7 8 9 StringBuilder builder = new StringBuilder(); Iterator<String> itr = collectionDeString.iterator(); while(itr.hasNext()) { builder.append(itr.next()); if(itr.hasNext()) { builder.append(','); } } return builder.toString();
Sinon, pour ce cas très précis, depuis Java 1.8 tout simplement String.join() :

Code:

String result = String.join(",", collectionDeString);

Et pour des cas moins simples mais dont le résultat c'est des String, profiter des streams et de Collectors.joining()
Code:

1 2 3 String result = collectionDePersonnes.stream() .map(p -> p.getName()) .collect(Collectors.joining(","));

03/12/2015, 12h45
Lorantus

Citation:

Sinon, pour ce cas très précis, depuis Java 1.8 tout simplement String.join() :

Les Streams ont beaucoup apporté. Pour ce coup, je relais cette API à une solution trop facile, car au final, il y a toujours cette notion de "si ce n'est pas le 1er élément alors ajoute le séparateur".

J'utilise aussi un StringBuilder que j'essaye d'initialiser avec une capacité -suivant le contexte- et les iterateurs afin de ne pas rechercher un élément et perdre du temps de traitement.

Comment perdre cette notion de "si ce n'est pas le 1er élément alors ajoute le séparateur" et surtout ce "if()" dans la boucle ?

Salut,

Citation:

Envoyé par thelvin

En général la collection de String est une ArrayList ou similaire, du coup j'utilise plutôt un for indexé qu'un foreach, ce qui me dispense d'une variable "c'est le premier ou pas" :

Attention toutefois car ce genre de code peut être très "dangereux" selon le type de List, car l'accès par index peut être énormément couteux (par exemple avec une LinkedList).
Et cela ne fonctionne pas avec une "Collection"...

A la rigueur pour un code similaire on peut se baser sur la taille du StringBuilder pour détecter le premier élément :
Code:

1 2 3 4 5 6 7 8 9 10 public static String join(Iterable<String> values, String separator) { final StringBuilder sb = new StringBuilder(); for (String value : values) { if (sb.length()>0) { sb.append(separator); } sb.append(value); } return sb.toString(); }
:arrow: Et en plus le code est vraiment utilisable avec n'importe quel type de Collection.

Sinon je vois deux alternatives à cela.

On peut ajouter le premier élément "seul", puis tous tous les autres précédé du séparateur :
Code:

1 2 3 4 5 6 7 8 9 10 11 public static String join(Iterable<String> values, String separator) { final StringBuilder sb = new StringBuilder(); final Iterator<String> iter = values.iterator(); if (iter.hasNext()) { sb.append(iter.next()); } while (iter.hasNext()) { sb.append(separator).append(iter.next()); } return sb.toString(); }
Ou alors on peut rajouter tous les éléments avec le séparateur, puis le "supprimer" à la fin du traitement :
Code:

1 2 3 4 5 6 7 8 9 10 11 public static String join(Iterable<String> values, String separator) { final StringBuilder sb = new StringBuilder(); for (String value : values) { sb.append(value).append(separator); } final int len = sb.length(); if (len>0) { sb.delete(len-separator.length(), len); } return sb.toString(); }
Mais sincèrement cela ne doit pas changer grand chose, à moins d'avoir vraiment de très grosses quantité de données...

Le point principal c'est surtout d'utiliser StringBuilder et non pas l'opérateur += qui n'est pas du tout adapté à cela.

a++

Ou encore

Code:

1
2
3
4
5
6
7
public static String join(Iterable<String> values, String separator) {
   final StringBuilder sb = new StringBuilder();
   for (String value : values) {
        sb.append(separator).append(value);
   }
   return sb.length()==0?"":sb.substring(separator.length());
}

Avant, Java 8, ma préférence allait à

Code:

1
2
3
4
5
6
7
8
9
10
public static String join(Iterable<String> values, String separator) {
		final StringBuilder sb = new StringBuilder();
		for (String value : values) {
			if (sb.length()>0) {
				sb.append(separator);
			}
			sb.append(value);
		}
		return sb.toString();
	}