Discussion :

[Ivelios]

Bonjour,

Je cherche à trouver la manière la plus simple, rapide et élégante de concacter une list<String> en String avec chaque valeur séparées par un séparateur.

Voici les 3 solutions que j'ai relevé :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public static String firstConcat(List<String> list, String sep) {
        StringBuilder resultBuilder = new StringBuilder();
        boolean firstValue = true;
        for (String value : list) {
            if (firstValue) {
                firstValue = false;
            } else {
                resultBuilder.append(sep);
            }
            resultBuilder.append(value);
        }
        return resultBuilder.toString();
    }

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public static String secondConcat(List<String> list, String sep) {
        StringBuilder resultBuilder = new StringBuilder();
        for (String value : list) {
            resultBuilder.append(value);
            resultBuilder.append(sep);
        }
        if (resultBuilder.length() == 0) {
            return "";
        } else {
            return resultBuilder.substring(0, resultBuilder.length() - 1);
        }
    }

Code :

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

1
2
3
4
5
6
7
8
9
10
public static String thirdConcat(List<String> list, String sep) {
        StringBuilder resultBuilder = new StringBuilder();
        String mySep = "";
        for (String value : list) {
            resultBuilder.append(mySep);
            resultBuilder.append(value);
            mySep = sep;
        }
        return resultBuilder.toString();
    }

Un test de performance ne permet pas de privilégié une solution plus qu'une autre, les timers change tout le temps
J'aimerais avoir votre avis sur la meilleur solution, ou votre propre solution si vous en avez une.

Merci

Code de test :

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package sandbox;
 
import java.util.LinkedList;
import java.util.List;
 
public class Concat {
 
    public static void main(String[] args) {
        for (int i = 0; i < 7; i++) {
            test(i*1000000);
        }
    }
 
    public static void test(int nbValues) {
        List<String> list = new LinkedList<>();
        for (int i = 0; i < nbValues; i++) {
            list.add(String.valueOf(i));
        }
 
        System.out.println("nbValues : " + nbValues);
        long time;
 
        time = System.currentTimeMillis();
        firstConcat(list, ",");
        long timerFirstConcat = System.currentTimeMillis() - time;
 
        time = System.currentTimeMillis();
        secondConcat(list, ",");
        long timerSecondConcat = System.currentTimeMillis() - time;
 
        time = System.currentTimeMillis();
        thirdConcat(list, ",");
        long timerThirdConcat = System.currentTimeMillis() - time;
 
        System.out.println("first : " + timerFirstConcat+" | second : " + timerSecondConcat+" | third :  "+ timerThirdConcat);
    }
 
    public static String firstConcat(List<String> list, String sep) {
        StringBuilder resultBuilder = new StringBuilder();
        boolean firstValue = true;
        for (String value : list) {
            if (firstValue) {
                firstValue = false;
            } else {
                resultBuilder.append(sep);
            }
            resultBuilder.append(value);
        }
        return resultBuilder.toString();
    }
 
    public static String secondConcat(List<String> list, String sep) {
        StringBuilder resultBuilder = new StringBuilder();
        for (String value : list) {
            resultBuilder.append(value);
            resultBuilder.append(sep);
        }
        if (resultBuilder.length() == 0) {
            return "";
        } else {
            return resultBuilder.substring(0, resultBuilder.length() - 1);
        }
    }
 
    public static String thirdConcat(List<String> list, String sep) {
        StringBuilder resultBuilder = new StringBuilder();
        String mySep = "";
        for (String value : list) {
            resultBuilder.append(mySep);
            resultBuilder.append(value);
            mySep = sep;
        }
        return resultBuilder.toString();
    }
 
}

[dinobogan]

Par performance, tu entends uniquement temps d'exécution ?
Attention : une recherche de performance prématurée va entraîner un grand nombre de problèmes.
Est-ce que cette concaténation est ce qui pose le plus gros problème sur le temps d'exécution global de ton programme ? Si c'est non, laisse tomber et concentre-toi sur la portion de code qui prend le plus de temps.

[eulbobo]

En Java 8, String.join(String delimiter, String... elements)


Donc String.join("-", list)

Code :

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

1
2
3
public String firstConcat(List<String> list, String sep){
     return String.join(sep, list);
}

Pour être précis, la signature de méthode est public static String join(CharSequence delimiter, CharSequence... elements), donc on peut lui passer du String, mais aussi du StringBuffer, StringBuilder...

[Ivelios]

@dinobogan

Il n'est pas vraiment question de performance, les listes que je traite n'auront que 100 éléments max. Mais je me posais tout de même la question de la performance si je devais l'utiliser à plus grande échelle un jour ou l'autre. Et ça semble être le seule critère fiable pour les comparer

@eulbobo

Effectivement, c'est bien vu
Je n'ai pas encore pris le temps de me mettre à la page java 8

[Népomucène]

Si tu peux prendre un profiler (dans NetBeans il y en a un) il te donneras des résultats plus précis (mémoire occupée par exemple)

[eulbobo]

Effectivement, c'est bien vu
Je n'ai pas encore pris le temps de me mettre à la page java 8

Depuis le temps que je l'attendais cette fonction, j'étais content de la voir débarquer en java 8 ^^

Sinon, sur les projets sur lesquels j'ai participé, j'ai vu les trois forme que tu as présenté plus haut... Au niveau perf, il n'y a pas réellement de différence puisqu'il n'y a pas plus de parcours, plus de test...
Sauf pour le deuxième qui concatène tout et qui enlève la fin (attention à ne pas avoir un séparateur qui fait plus d'un caractère par contre... Et celle là, tu n'y avais pas pensé vu ton code :p)


Et pour faire du profiling, il y a plein d'outils avec ton JDK8 comme jVisualVM ou JMC (java mission control)

[adiGuba]

Salut,


Coté performance les différences entre les versions doivent vraiment être minimes... Le principal étant d'utiliser StringBuilder.
Mais perso si je devais implémenter cela j'ajouterais le premier élément seul, puis les autres dans une boucle.

Avec un Iterator ca se fait tout seul :

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
	public static String concat(Iterable<String> values, String sep) {
		Iterator<String> iterator = values.iterator();
		if (iterator.hasNext()) {
			StringBuilder sb = new StringBuilder();
			// On ajoute le premier élément :
			sb.append(iterator.next());
			while (iterator.hasNext()) {
				// Puis les suivants précédés du séparateur :
				sb.append(sep);
				sb.append(iterator.next());
			}
			// Et on renvoit le résultat :
			return sb.toString();
		}
		// Cas particulier : aucun élément
		return "";
	}

En plus j'utiliserais Iterable<String> à la place de List<String>, afin d'ouvrir ma méthode à d'autres types...





A noter qu'une autre solution consiste à utiliser les Streams :

Code :

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

1
2
3
4
	public static String concat(List<String> list, String sep) {
		return list.stream()
				.collect(Collectors.joining(sep));
	}

Tel quel il y a peu d'intérêt, mais cela a deux avantages :

• L'API de Stream permet de manipuler facilement les données, si besoin.
• Le tout peut être paralléliser facilement.

a++

[Ivelios]

Bonjour à tous,

Sauf pour le deuxième qui concatène tout et qui enlève la fin (attention à ne pas avoir un séparateur qui fait plus d'un caractère par contre... Et celle là, tu n'y avais pas pensé vu ton code :p)

Effectivement c'est un oubli bête et méchant ça

Avec un Iterator ca se fait tout seul

Je n'y avais pas pensé à celle-ci, merci

Merci à tous pour vos réponses.
Conclusion : Pas de solution miracle pour faire le concat en Java 7, il faut faire une fonction utilitaire maison qui sont toutes plus ou moins pareil.
Conclusion 2 : Passer sous Java 8

[hwoarang]

Pour la meme problématique, je me suis orienté sur ta solution 1. La solution 2 me semble moche. La 3 est equivalente à la 1.

Pour avoir un peu pensé à ca (faut croire que tu n'es pas le seul à te poser des questions métaphysiques aussi importantes), je n'ai pas trouvé mieux non plus. Sinon, la solution d'adiGuba est sympa mais à le désavantage d'avoir 2 niveaux d'imbrication. Je ne parle pas des solutions java 8 / stream, l'interet à mes yeux étant plutot l'adaptation de la logique plutot que l'implementation dans un langage (la question etant aussi valable en c++, c#, ...).

[tac.p]

Bonjour,

J'ai souvent rencontré ces problématiques et j'avoue que en utilisant Java 8 et les streams, j'ai trouvé plein d'avantages en terme de compacité de code. On peut faire des choses très pratiques et très efficaces et assez modulaire. Par exemple, l'utilisation de Stream.collect() avec un collector de String permet de partir d'une liste d'Objets quelconques (au lieu d'une liste de String)

Code :

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

1
2
3
		Collection<Object> objects = new LinkedList<>();
		String sep = " ; ";
		String resultat = objects.stream().map(o->o.toString()).collect(Collectors.joining(sep));

dans ce cas j'ai utilisé toString(), mais on peut choisir de récupérer un nom ou un identifiant si les Objets en questions en ont.

Après on peut aussi générer son propre Collecteur, ce qui permet de faire des choses plus compliquées (bien que plus dur de gérer l'élément de séparation de façon propre).

Code :

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

1
2
3
		String autreResultat = objects.stream().map(o->o.toString()).collect(StringBuilder::new,(sb,s)->sb.append(s),(sb1,sb2)->sb1.append(sb2)).toString();
		String idem = objects.stream().map(o->o.toString()).collect(StringBuilder::new,StringBuilder::append,StringBuilder::append).toString();
		String idemInverse = objects.stream().map(o->o.toString()).collect(StringBuilder::new,(sb,s)->sb.insert(0,s),StringBuilder::append).toString();

Où le premier argument est l'initiateur (Supplier), le deuxième argument est la fonction d’agrégation des éléments dans l'objet contenant (ici un StringBuilder) et enfin la dernier argument est l'opération de réduction entre deux streams qui ont été parallélisés. (les 2 premières lignes sont strictement équivalentes)
Cette definition de son collecteur, permet de faire les choses manuellement et donc de faire des choses un peu différentes, comme au dessus où la dernière instruction inverse l’ordonnancement des Objets.