Java Language
StringBuilder

Introduction

Syntaxe

• nouveau StringBuilder ()

• nouveau StringBuilder (capacité int)

• new StringBuilder (CharSequence seq)

• new StringBuilder (générateur StringBuilder)

• new StringBuilder (chaîne de caractères)

• new StringJoiner (délimiteur CharSequence)

• new StringJoiner (délimiteur CharSequence, préfixe CharSequence, suffixe CharSequence)

Remarques

 StringBuilder v = new StringBuilder('I'); //'I' is a character, "I" is a String.
 System.out.println(v.capacity()); --> output 73
 System.out.println(v.toString()); --> output nothing

Répéter une chaîne n fois

Problème: Créez une String contenant n répétitions d'une String s .

L'approche triviale serait la concaténation répétée de la String

final int n = ...
final String s = ...
String result = "";

for (int i = 0; i < n; i++) {
    result += s;
}

Cela crée n nouvelles instances de chaîne contenant 1 à n répétitions de s résultant en un temps d'exécution de O(s.length() * n²) = O(s.length() * (1+2+...+(n-1)+n)) .

Pour éviter cela, StringBuilder devrait être utilisé, ce qui permet de créer la String dans O(s.length() * n) place:

final int n = ...
final String s = ...

StringBuilder builder = new StringBuilder();

for (int i = 0; i < n; i++) {
    builder.append(s);
}

String result = builder.toString();

Comparaison de StringBuffer, StringBuilder, Formatter et StringJoiner

Les classes StringBuffer , StringBuilder , Formatter et StringJoiner sont des classes d'utilitaires Java SE principalement utilisées pour assembler des chaînes à partir d'autres informations:

• La classe StringBuffer est présente depuis Java 1.0 et fournit diverses méthodes pour créer et modifier un "tampon" contenant une séquence de caractères.

• La classe StringBuilder été ajoutée à Java 5 pour résoudre les problèmes de performances liés à la classe StringBuffer origine. Les API pour les deux classes sont essentiellement les mêmes. La principale différence entre StringBuffer et StringBuilder est que le premier est thread-safe et synchronisé et que le second ne l'est pas.

Cet exemple montre comment StringBuilder peut être utilisé:

int one = 1;
String color = "red";
StringBuilder sb = new StringBuilder();
sb.append("One=").append(one).append(", Color=").append(color).append('\n');
System.out.print(sb);
// Prints "One=1, Colour=red" followed by an ASCII newline.

(La classe StringBuffer est utilisée de la même manière: changez simplement StringBuilder en StringBuffer dans ce qui précède)

Les classes StringBuffer et StringBuilder conviennent pour l'assemblage et la modification de chaînes. c'est-à-dire qu'ils fournissent des méthodes pour remplacer et supprimer des caractères, ainsi que pour les ajouter à divers. Le remining deux classes sont spécifiques à la tâche d'assemblage des chaînes.

• La classe Formatter été ajoutée à Java 5 et est modélisée librement sur la fonction sprintf dans la bibliothèque standard C. Il prend une chaîne de format avec des spécificateurs de format incorporés et une séquence d'autres arguments, et génère une chaîne en convertissant les arguments en texte et en les substituant aux spécificateurs de format. Les détails des spécificateurs de format indiquent comment les arguments sont convertis en texte.

• La classe StringJoiner été ajoutée à Java 8. C'est un formateur spécial qui formate succinctement une séquence de chaînes avec des séparateurs entre elles. Il est conçu avec une API fluide et peut être utilisé avec les flux Java 8.

Voici quelques exemples typiques d'utilisation de Formatter :

// This does the same thing as the StringBuilder example above
int one = 1;
String color = "red";
Formatter f = new Formatter();
System.out.print(f.format("One=%d, colour=%s%n", one, color));
// Prints "One=1, Colour=red" followed by the platform's line separator

// The same thing using the `String.format` convenience method
System.out.print(String.format("One=%d, color=%s%n", one, color));

La classe StringJoiner n'est pas idéale pour la tâche ci-dessus, voici donc un exemple de formatage d'un tableau de chaînes.

StringJoiner sj = new StringJoiner(", ", "[", "]");
for (String s : new String[]{"A", "B", "C"}) {
    sj.add(s);
}
System.out.println(sj);
// Prints "[A, B, C]"

Les cas d'utilisation des 4 classes peuvent être résumés:

• StringBuilder convient à toute tâche de modification de chaîne OU d'assemblage de chaînes.
• StringBuffer utilise (uniquement) lorsque vous avez besoin d'une version thread-safe de StringBuilder .
• Formatter fournit des fonctionnalités de formatage de chaînes beaucoup plus riches, mais n'est pas aussi efficace que StringBuilder . C'est parce que chaque appel à Formatter.format(...) implique:
  • analyser la chaîne de format ,
  • créer et remplir un tableau varargs , et
  • Autoboxing des arguments de type primitif.
• StringJoiner fournit un formatage succinct et efficace d'une séquence de chaînes avec des séparateurs, mais ne convient pas aux autres tâches de formatage.