Vous pouvez utiliser l'opérateur '+' pour concaténer deux ou plusieurs strings, c'est le moyen le plus simple pour faire le travail. Par exemple "Un" + "Deux" produira l'objet String "UnDeux". Vous pouvez utiliser cet opérateur pour combiner au moins deux String par exemple: "ab"+"cde"+fghi" va donner "abcdefghi", et vous pouvez aussi utiliser des variables String.
Cette opération est transformée par le compilateur en:

new StringBuilder().append("string1").append("string2").toString()

Ce programme fait la concaténation de deux chaines de caractères:

public class Concatenation_string {
 public static void main(String[] args) {
 String s1 = "chaine1";
 String s2 = "chaine2";
 
 String s1s2 = concatenation_strings_java(s1, s2);
 System.out.println(s1s2);
 }
 
 public static String concatenation_strings_java (String s1, String s2) {
 return s1+s2;
 }
}

Exécution:

chaine1chaine2

Concaténer des strings avec la méthode String.concat()

Cette méthode concatène un String à la fin d'un autre. La méthode retourne un String avec la valeur de String passé dans la méthode concaténé avec la fin de String utilisé pour invoquer cette méthode.

public String concat(String s)

Exemple:

public class Concatenation_string {
 public static void main(String[] args) {
 String s = "je suis un";
 s = s.concat(" programmeur");
 System.out.println(s);
 }
}

Exécution:

je suis un programmeur

Différence entre l'opérateur '+' et la méthode String.concat()

Pour pouvoir distinguer la différence entre l'opérateur '+' et la méthode concat(), on va travailler avec un exemple pratique.

a+=b
a.concat(b)

Premièrement, il y a une petite différence dans la sémantique. Si a est null, alors a.concat(b) déclenche un NullPointerException, par contre l'opérateur '+' dans l'instruction a+=b traite la valeur de a même si elle est null. Par ailleurs, la méthode concat() accepte seulement les valeurs de type String tandis que l'opérateur '+' convertit la valeur en un String( utilisant la méthode toString() ). On peut dire que la méthode concat() est plus stricte en ce qu'elle accepte.

Vous pouvez écrire ce code et voir ce que vous aurez en sortie:

public static void main(String[] args) {
 String s = null;
 s = s.concat(" programmeur");
 System.out.println(s);
}

Vous devez avoir ceci lors de l'exécution:

Exception in thread "main" java.lang.NullPointerException
 at Concatenation_string.main(Concatenation_string.java:5)

Le même exemple avec l'opérateur '+':

public static void main(String[] args) {
 String s = null;
 s = s + programmeur;
 System.out.println(s);
}

Vous devez avoir ce résultat:

nullprogrammeur

Donc, comme on a dit précédemment l'opérateur '+' est équivalent à :

a = new StringBuilder()
 .append(a)
 .append(b)
 .toString();

Concaténer des strings avec StringBuffer et StringBuilder

Ce moyen de concaténation réduit les coûts de mémoire et de temps parce qu'il ne va pas générer des objets String. En fait, vous devez toujours utiliser StringBuilder au lieu de StringBuffer parce qu'il a les mêmes fonctionnalités mais sans synchronisation, ce qui veut dire une opération plus rapide. L'utilisation de StringBuffer ou StringBuilder donne aussi un code structuré comme montrer ci-dessous:

String result = new StringBuilder(15).append(nom).append(" ").append(prenom).toString();

Vous pouvez voir la facilité de concaténer multiple String en utilisant StringBuilder. Cependant, n'oubliez pas d'initialiser StringBuilder avec une capacité égale au nombre de caractères de String final. Cela va éviter de perdre la mémoire inutilisable en initialisant correctement notre String et réduire le temps CPU.

Voici un exemple d'un programme java qui va vous montrer comment concaténer un String avec StringBuilder et StringBuffer.

public static void main(String[] args) {
 String cour =" Cour de ";
 String module_math ="math";
 
 /* StringBuilder */
 String module_res = "réseaux";
 int longueur = cour.length()+module_math.length();
 StringBuilder sb = new StringBuilder(longueur);
 sb.append(cour).append(module_math);
 String res = sb.toString();
 System.out.println(res);
 
 /* StringBuilder */
 longueur = cour.length()+module_math.length();
 StringBuffer sBuffer = new StringBuffer(longueur);
 sb.append(" et").append(cour).append(module_res);
 res = sb.toString();
 System.out.println(res);
}

Sortie:

 Cour de math
 Cour de math et Cour de réseaux

Performance de la concaténation des String en Java

Il est clair que le moyen le plus simple et rapide pour la concaténation des String est l’utilisation de l'opérateur '+' et il marche très bien lorsqu'on a juste deux string, mais si vous avez besoin de concaténer des milliers des String et surtout à l'intérieur d'une boucle, alors là, les performances vont diminuer avec l'opérateur '+'. La cause des faibles performances est la création des lots temporaires pour les objets String. Si vous avez beaucoup de String dans votre programme, vous pouvez voir les résultats ci-dessous qui montrent que la meilleure façon pour la concaténation à grand échelle est l'utilisation de la classe StringBuilder. Ces statistiques ont été faits dans un environnement Windows 7 64 bits, Processeur Core 2 Duo (2.53 GHz) avec 4 GB de RAM.

public static void main(String[] args) {
 int nb_op=10000;
 String s="";
 
 double t1,t2,temps;
 t1= System.currentTimeMillis();
 for(int i = 0 ; i < nb_op; i++)
 s += "*";
 t2 = System.currentTimeMillis();
 temps = t2-t1;
 System.out.println("+: "+temps);
 
 s="";
 t1= System.currentTimeMillis();
 for(int i = 0 ; i < nb_op; i++)
 s.concat("*");
 t2 = System.currentTimeMillis();
 temps = t2-t1;
 System.out.println("concat: "+temps);
 
 StringBuilder sb=new StringBuilder();
 t1= System.currentTimeMillis();
 for(int i = 0 ; i < nb_op; i++)
 sb.append("*");
 t2 = System.currentTimeMillis();
 temps = t2-t1;
 System.out.println("StringBuilder: "+temps);
 
 StringBuffer sBuffer=new StringBuffer();
 t1= System.currentTimeMillis();
 for(int i = 0 ; i < nb_op; i++)
 sBuffer.append("*");
 t2 = System.currentTimeMillis();
 temps = t2-t1;
 System.out.println("StringBuffer: "+temps);
}

Les résultats pour 10000 opérations de concaténation:

+: 180.0
concat: 13.0
StringBuilder: 2.0
StringBuffer: 4.0

Temps en milliseconde pour 10000 opérations

Un autre graphique montrant le temps réalisé en fonction du nombre d'opérations:


La première impression est stupéfiante! Là on remarque tout de suite que le temps réalisé par l'opérateur '+' est proportionnelle avec le nombre d'opérations de concaténation et il a fait dix secondes pour 100000 opérations. Donc l'opérateur '+' est un très mauvais choix lorsqu'on travaille sur un projet large échelle. concat, StringBuilder et StringBuffer sont invisible face à l'opérateur '+', mais on peut remarquer dans le tableau des statistiques que StringBiulder a pris moins de temps.

La méthode concat() est rapide. Cependant, la concaténation de plusieurs strings se fait plus rapidement avec la méthode StringBuilder en terme de performance.

Le code source de String et StringBuilder est disponible dans le JDK Sun. Vous pouvez voir que vous être entrain de construire un tableau de char. Son allocation en mémoire est super rapide.

Ce qu'il faut retenir:

• N'utilisez jamais l'opérateur + dans une boucle.
• Utilisez toujours StringBuilder pour la concaténation de plusieurs String.
• Initialisez toujours la taille de StringBuilder.

Références:
Java - String concat() Method
String concatenation: concat() vs + operator
Java - String Buffer append() Method