StringBuilder Java : le fonctionnement de cette classe modifiable

En langage Java, la classe StringBuilder peut être utilisée à la place d’une chaîne de caractères (string) traditionnelle. Contrairement à un string classique, elle permet de procéder à des modifications directes au sein de la chaîne de caractères. Ces modifications peuvent être initiées par différentes méthodes.

StringBuilder Java : une alternative au string traditionnel

La classe String Java est immuable ou immutable, et se passe de sous-classes. Une alternative à cette classe finale en Java est StringBuilder. Cette dernière génère une séquence de caractères pouvant être modifiée après sa création ce en quoi StringBuilder en Java est similaire à StringBuffer. Les deux classes remplissent en effet une tâche similaire, mais contrairement à l’option Buffer, StringBuilder n’est pas synchronisé. Pour travailler avec un seul thread (fil), ce choix est donc particulièrement recommandé, car il est capable de travailler beaucoup plus rapidement que la solution alternative. Découvrons ensemble cette classe et ses possibilités.

Syntaxe et utilité

En Java, la syntaxe de StringBuilder suit toujours le même modèle et se présente comme suit :

public final class StringBuilder
	extends Object
		implements Serializable, CharSequence

Pour comprendre le fonctionnement de base de cette classe ainsi que son objectif, il convient tout d’abord de se pencher sur la classe String traditionnelle. Lorsqu’un objet est déclaré dans String, celui-ci ne peut plus être modifié par la suite. Pour apporter des modifications, il faut créer un nouvel objet avec la valeur modifiée, puis l’enregistrer. Cela génère un surplus de données et peut entraîner une baisse des performances. Si, en revanche, vous utilisez StringBuilder en Java pour une chaîne de caractères, les modifications éventuelles seront apportées précisément à cette chaîne et aucune nouvelle chaîne ne sera créée. Ceci limite la quantité de données et améliore les performances.

Les contructeurs de la classe

La classe Java StringBuilder dispose de quatre constructeurs qui aident à mettre la chaîne de caractères dans le format approprié pour la classe. Ils servent également à la configuration. Voici les constructeurs et leurs fonctions :

• StringBuilder() : génère un StringBuilder vide d’une capacité maximale de 16 caractères.
• StringBuilder(int capacity) : crée un StringBuilder sans caractères, dont le nombre maximal de caractères est défini à l’aide de l’argument capacity.
• StringBuilder(CharSequence seq) : génère un StringBuilder avec les mêmes caractères que la séquence de caractères, CharSequence, déposée.
• StringBuilder(String str) : crée un StringBuilder sur la base de la chaîne déposée.

Le fonctionnement des constructeurs en pratique peut être illustré au mieux par un exemple de code. Voici comment fonctionnent ces quatre options :

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
	str.append("ABC");
	System.out.println("Premier Constructor = " + str.toString());
	StringBuilder str2 = new StringBuilder(5);
	System.out.println("Deuxième Constructor = " + str2.capacity());
	StringBuilder str3 = new StringBuilder("ABCDEFGHIJK");
	System.out.println("Troisième Constructor = " + str3.toString());
	StringBuilder str4 = new StringBuilder(str3.toString());
	System.out.println("Quatrième Constructor = " + str4.toString());
	}
}

En utilisant la commande Java System.out.println pour la sortie, vous obtenez ceci :

Premier Constructor = ABC
Deuxième Constructor = 5
Troisième Constructor = ABCDEFGHIJK
Quatrième Constructor = ABCDEFGHIJK

Exemples de méthodes de StringBuilder en Java

Il existe de nombreuses méthodes pour la classe StringBuilder Java. Voici les plus importantes d’entre elles, avec les extraits de code correspondants.

append()

La méthode append() est utilisée pour ajouter un string à un autre. Elle a différents paramètres. En pratique, la méthode fonctionne comme illustré dans l’exemple suivant :

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.append("FGHIJK");
	System.out.println(str);
	}
}

La sortie générée est :

ABCDEFGHIJK

insert()

La méthode insert() est utilisée en combinaison avec StringBuilder pour insérer un string à un emplacement précis. Voici un exemple qui illustre cette méthode :

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.insert(1,"FGHIJK");
	System.out.println(str);
	}
}

Le résultat obtenu est le suivant :

AFGHIJKBCDEFGHIJK

Avec Integer (dans ce cas 1), vous déterminez la position à laquelle la chaîne de caractères doit être insérée.

replace()

La méthode replace() remplace un string ou une partie d’un string. Elle est définie par beginIndex et endIndex. Voici l’exemple correspondant :

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.replace(1,4,"FGHIJK");
	System.out.println(str);
	}
}

La sortie obtenue a la forme suivante :

AFGHIJKE

reverse()

La méthode reverse() permet d’inverser complètement le string déposé. Voici un exemple qui illustre ce principe :

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.reverse();
	System.out.println(str);
	}
}

Le résultat généré est :

EDCBA

delete()

La méthode delete() avec StringBuilder Java permet de supprimer la totalité ou une partie d’un string. La méthode delete() avec StringBuilder Java permet de supprimer la totalité ou une partie d’un string. Ceci est également défini par beginIndexet endIndex. En voici un exemple :

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.delete(1,4);
	System.out.println(str);
	}
}

Nous obtenons la sortie suivante :

AE

capacity()

La méthode capacity() vous donne le nombre maximum actuel de caractères du StringBuilder Java qui est normalement de 16. Une augmentation de cette valeur se fait selon la formule « longueur de caractères actuelle * 2 + 2 ». S’il était de 16 jusqu’à présent, il sera multiplié par deux (32) et augmenté de deux (34). Voici l’exemple correspondant :

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
System.out.println(str.capacity());
str.append("ABCDE");
System.out.println(str.capacity());
	str.append("Ceci est un autre exemple");
	System.out.println(str.capacity());
	}
}

La sortie générée est la suivante :

16
16
34

ensureCapacity()

La méthode ensureCapacity() s’assure que le nombre de caractères disponibles correspond au moins à une valeur définie. Si ce n’est pas le cas, la capacité sera à nouveau augmentée selon la formule « longueur de caractères actuelle * 2 + 2 ». C’est ce qui apparaît dans l’exemple suivant :

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
System.out.println(str.capacity());
str.append("ABCDE");
System.out.println(str.capacity());
	str.append("Ceci est un autre exemple");
	System.out.println(str.capacity());
	str.ensureCapacity(5);
	System.out.println(str.capacity());
	str.ensureCapacity(40);
	System.out.println(str.capacity());
	}
}

En exécutant ce code, on obtient la sortie suivante :

16
16
34
34
70

La valeur par défaut (16) a d’abord été prise en compte deux fois, puis deux fois la valeur doublée plus deux (34), et enfin la valeur a encore été doublée et augmentée de deux (70).