Méthode append() en Java : StringBuilder et StringBuffer

La méthode append Java appartient aux classes StringBuilder et StringBuffer et ajoute une certaine valeur à une chaîne existante. Même si tu ne connaissais pas la méthode append(), tu l'as probablement déjà utilisée implicitement. Cela se produit lorsque tu concatènes des chaînes en Java en utilisant l'opérateur +. Le fait est que la concaténation de chaînes en Java est implémentée en utilisant la classe StringBuilder ou StringBuffer et leurs méthodes append().

Quelques mots sur String, StringBuffer et StringBuilder

Comme tu le sais probablement déjà, la classe String est final (elle n'a pas de classes enfants) et immuable (les instances de cette classe ne peuvent pas être modifiées après leur création). En fait, l'immuabilité de la classe String signifie que de nouveaux objets String sont créés à la suite de chaque opération, et que les anciens sont jetés. Tout cela génère beaucoup de déchets. Pour faire face au problème des déchets temporaires générés lors de la modification d'un objet String, tu peux utiliser les classes StringBuffer ou StringBuilder. La principale différence entre elles est que StringBuffer est synchronisée, tandis que StringBuilder non. Par conséquent, utilise StringBuffer pour les chaînes qui seront modifiées fréquemment dans un environnement à plusieurs threads, et StringBuilder dans un environnement à thread unique.

Java append() dans StringBuilder et StringBuffer

Java string append() est l'une des méthodes les plus importantes des classes StringBuilder et StringBuffer. Elle ajoute une nouvelle valeur à la chaîne actuelle. Il existe 13 méthodes append() surchargées différentes dans les classes StringBuffer et StringBuilder. Découvrons la méthode append de StringBuilder. Dans tous les cas, les méthodes fonctionnent exactement de la même façon avec StringBuffer.

• public StringBuilder append(boolean b)
• public StringBuilder append(char c)
• public StringBuilder append(char[] str)
• public StringBuilder append(char[] str, int offset, int len)
• public StringBuilder append(CharSequence cs)
• public StringBuilder append(CharSequence cs, int start, int end)
• public StringBuilder append(double d)
• public StringBuilder append(float f)
• public StringBuilder append(int i)
• public StringBuilder append(long lng)
• public StringBuilder append(Object obj)
• public StringBuilder append(String str)
• public StringBuilder append(StringBuffer sb)

Passons en revue certaines d'entre elles et utilisons des exemples pour expliquer ce que fait exactement la méthode append().

Java.lang.StringBuilder.append(int i)

java.lang.StringBuilder.append(int i) est une méthode qui permet d'ajouter un entier à un objet StringBuilder existant. Observons quelques exemples d'utilisation de Java.lang.StringBuilder.append(int i) :

StringBuilder s = new StringBuilder("J'aime Java ");
int i = 14;
La méthode ajoute un StringBuilder et un entier
s.append(i); 
System.out.println(s);

Dans notre cas, la sortie sera : Que s'est-il passé ici ? Tout d'abord, nous avons créé un StringBuilder nommé s avec la valeur « J'aime Java ». Ensuite, nous lui avons ajouté un entier, 14, en utilisant append(int). À proprement parler, nous n'avons pas vraiment ajouté l'entier. En fait, nous avons ajouté la chaîne « 14 » et reçu un StringBuilder mis à jour avec la valeur « J'aime Java 14 ». Ainsi, la méthode transforme l'argument en objet StringBuilder, le lie à un objet StringBuilder existant et renvoie un objet mis à jour.

Exemple d'utilisation de StringBuilder.append() pour des arguments object, int, boolean et string

L'idée est la même pour toutes les autres méthodes surchargées avec des éléments numériques, des chaînes, des caractères ou des tableaux. Créons une classe LegoBrick et l'enum Color pour montrer le fonctionnement de la méthode public StringBuilder append(Object obj).

// enum avec des couleurs 
public enum Color {
   RED, YELLOW, BLUE;
}
// Code de la classe LegoBrick
public class LegoBrick {
   Color color;
   boolean isConnected;

   public void connect() {
       System.out.println("Cette brique est connectée");
       this.isConnected = true;
   }

   public void disconnect() {
       System.out.println("Déconnectée");
       isConnected = false;
   }

   public LegoBrick(Color color, boolean isConnected) {
       this.color = color;
       this.isConnected = isConnected;
   }

   public Color getColor() {
       return color;
   }

   public boolean isConnected() {
       return isConnected;
   }

   @Override
   public String toString() {
       return "LegoBrick{" +
              "color=" + color +
              ", isConnected=" + isConnected +
              '}';
   }
}

Maintenant, nous allons créer une classe AppendDemo, que nous allons utiliser pour montrer l'ajout d'un StringBuilder de base à des valeurs de type String, int, LegoBrick et boolean. Ça a l'air bizarre dit comme ça, mais ça marche !

public class AppendDemo {

   public static void main(String[] args) {
       StringBuilder s = new StringBuilder("J'aime");
       System.out.println(s)
// La méthode ajoute un StringBuilder et un String
       s.append(" Java");
       System.out.println(s);
// La méthode ajoute un StringBuilder et un int
       s.append(14);
       System.out.println(s);
       LegoBrick legoBrick = new LegoBrick(Color.RED, false);
// La méthode ajoute un StringBuilder et un LegoBrick
       s.append(legoBrick);
       System.out.println(s);
// La méthode ajoute un StringBuilder et un boolean
       System.out.println(s.append(5<7));
   }
}

Voici le résultat : Tout d'abord, nous avons créé et affiché un StringBuilder avec la valeur « J'aime ». Ensuite, nous avons utilisé la méthode append() pour ajouter à la suite une chaîne, un entier et des représentations sous forme de chaîne d'un objet et d'un booléen.

StringBuilder append(char[] cstr, int set, int length)

Examinons la méthode append() avec trois paramètres. Elle ajoute la représentation sous forme de chaîne d'un sous-ensemble du tableau de caractères donné à la chaîne. Dans ce cas :

• cstr est un tableau de caractères à ajouter
• set est l'index du premier caractère à ajouter
• length est le nombre de caractères à ajouter.

Comme avec les autres méthodes append(), celle-ci renvoie un objet StringBuilder élargi. Voici un exemple d'utilisation d'append(char[], cstr, int set, int length) dans le cadre du code d'une application Java.

public class AppendDemo {
   // Exemple d'utilisation d'append(char[], cStr, int set, int length)

   public static void main(String[] args) {
       StringBuilder s = new StringBuilder("J'aime ");
      // Voici un tableau de caractères, dont nous allons ajouter une partie à s
       char[] cStr = new char[]
               {'c', 'o', 'd', 'e', 'J', 'a', 'v', 'a', '1', '4'};
       Nous annexons 4 éléments du tableau cStr, à compter de celui à l'index 4, « J »
       s.append(cStr, 4, 4);
       System.out.println(s);
   }
}

Voici le résultat :

Méthodes append() de StringBuilder avec un argument CharSequence

Tu as peut-être remarqué que deux méthodes ont CharSequence en argument.

• public StringBuilder append(CharSequence cs)
• public StringBuilder append(CharSequence cs, int start, int end)

Tous les débutants ne savent pas que CharSequence est une interface. D'après la documentation, CharSequence est une séquence lisible de valeurs char et offre un accès uniforme en lecture seule à de nombreux types de séquences de caractères. L'interface est implémentée par des classes Java comme String, StringBuffer, StringBuilder et plus encore. Donc, si tu ne sais pas s'il est préférable d'utiliser String, StringBuffer ou StringBuilder dans ton programme, tu peux utiliser CharSequence. StringBuilder append(CharSequence cs, int start, int end) fonctionne quasiment comme la méthode append(char[] cstr, int set, int length) dont nous avons discuté plus haut. Toutefois, cette méthode prend le premier élément de la sous-séquence et le dernier. Il est important de se rappeler que l'index de départ est inclus dans la sous-séquence, mais que l'index final ne l'est pas (en d'autres termes, l'élément final de la sous-séquence est l'élément qui vient avant l'index final). Pourquoi ? C'est comme ça en Java, tout simplement. Montrons ce qu'est une CharSequence avec les méthodes append(CharSequence cs) et append(CharSequence cs, int start, int end).

public class CharSequenceDemo {

   public static void printCharSequence(CharSequence ch) {
       System.out.println(ch);
   }
       public static void main(String[] args) {
           CharSequence myString = new String("Ceci est un String ");
           printCharSequence(myString);
           CharSequence myStringBuilder = new StringBuilder("Ceci est un StringBuilder ");
           printCharSequence(myStringBuilder);
           StringBuilder s = new StringBuilder("myStringBuilder ");
// StringBuilder.append           
s.append(myStringBuilder);
           System.out.println(s);
// StringBuilder.append
           s.append(myString);
           System.out.println(s);
           s.append(myString, 5,7);
           System.out.println(s);
       }
   }

Voici le résultat : Nous avons créé deux CharSequences, leur avons lié un String et un StringBuilder, puis les avons imprimées. Nous ne pouvons pas appliquer la méthode append() directement à myStringBuilder, car CharSequence n'a pas cette méthode (si tu ne comprends pas pourquoi, alors penche-toi sur l'héritage ainsi que l'élargissement et la réduction des types de référence). Par conséquent, nous créons un StringBuilder et utilisons la méthode append pour concaténer en séquence les deux CharSequences. À la fin, nous avons ajouté la sous-séquence « is » à notre StringBuilder : « i » est l'élément en 5e place de l'index de myStringBuilder et « s » le 6e. N'oublie pas que la méthode exclut l'élément spécifié par l'index final.

Qui de StringBuffer.append() ?

La méthode StringBuffer.append a également 13 variantes et elles fonctionnent exactement de la même manière que StringBuilder.

• public StringBuffer append (boolean b)
• public StringBuffer append (char c)
• public StringBuffer append (char[] str)
• public StringBuffer append (char[] str, int offset, int len)
• public StringBuffer append (double d)
• public StringBuffer append (float f)
• public StringBuffer append (int i)
• public StringBuffer append (long lng)
• public StringBuffer append (CharSequence s)
• public StringBuffer append (CharSequence s, int start, int end)
• public StringBuffer append (Object obj)
• public StringBuffer append (String str)
• public StringBuffer append (StringBuffer sb)

Prenons un exemple d'utilisation de StringBuffer.append pour joindre une sous-chaîne. Nous allons simplement prendre l'exemple de StringBuilder et changer tous les StringBuilder dans le code en StringBuffer.

public class AppendDemo {
   // Exemple d'utilisation d'append(char[], cStr, int set, int length)

   public static void main(String[] args) {
       StringBuffer s = new StringBuffer("J'aime ");
      // Voici un tableau de caractères, dont nous allons ajouter une partie à s
       char[] cStr = new char[]
               {'c', 'o', 'd', 'e', 'J', 'a', 'v', 'a', '1', '4'};
       Nous annexons 4 éléments du tableau cStr, à compter de celui à l'index 4, « J »
// Utilisation de StringBuffer.append
       s.append(cStr, 4, 4);
       System.out.println(s);
// StringBuffer.append ajoute l'int 14 à s
s.append(14); 
System.out.println(s);
   }
}

Voici le résultat : Tu peux faire cela avec chacun des exemples de cet article. Ils fonctionneront tous !

Conclusion

Étant donné que StringBuilder et StringBuffer partagent la plupart des fonctions, il n'est pas surprenant que les deux classes offrent des façons similaires d'utiliser la méthode append(). C'est une bonne nouvelle pour les développeurs : tu n'as pas besoin d'apprendre des méthodes distinctes pour chaque classe. Cela étant, au vu des nombreuses façons qu'il existe d'utiliser append(), veille à avoir quelques heures de pratique d'ajout de représentations sous forme de chaîne de différents types de données à une chaîne.