La classe Java StringBuffer est utilisée pour créer des objets String mutables (modifiables). La classe StringBuffer en Java est la même que la classe String sauf qu'elle est mutable, c'est-à-dire qu'elle peut être modifiée.
Remarque : la classe Java StringBuffer est thread-safe, c'est-à-dire que plusieurs threads ne peuvent pas y accéder simultanément. C'est donc sécuritaire et donnera lieu à une commande.
Constructeurs importants de la classe StringBuffer
Constructeur | Description |
---|---|
StringBuffer() | Il crée un tampon String vide avec une capacité initiale de 16. |
StringBuffer(String chaîne) | Il crée un tampon de chaîne avec la chaîne spécifiée. |
StringBuffer (capacité entière) | Il crée un tampon de chaîne vide avec la capacité spécifiée en longueur. |
Méthodes importantes de la classe StringBuffer
Modificateur et type | Méthode | Description |
---|---|---|
StringBuffer synchronisé public | ajouter (Chaîne s) | Il est utilisé pour ajouter la chaîne spécifiée avec cette chaîne. La méthode append() est surchargée comme append(char), append(boolean), append(int), append(float), append(double) etc. |
StringBuffer synchronisé public | insérer (int offset, String s) | Il est utilisé pour insérer la chaîne spécifiée avec cette chaîne à la position spécifiée. La méthode insert() est surchargée comme insert(int, char), insert(int, boolean), insert(int, int), insert(int, float), insert(int, double) etc. |
StringBuffer synchronisé public | remplacer (int startIndex, int endIndex, String str) | Il est utilisé pour remplacer la chaîne de startIndex et endIndex spécifiés. |
StringBuffer synchronisé public | supprimer (int startIndex, int endIndex) | Il est utilisé pour supprimer la chaîne des startIndex et endIndex spécifiés. |
StringBuffer synchronisé public | inverse() | est utilisé pour inverser la chaîne. |
public entier | capacité() | Il est utilisé pour renvoyer la capacité actuelle. |
vide public | assurerCapacity(int minimumCapacity) | Il permet d'assurer une capacité au moins égale au minimum donné. |
caractère public | charAt (index int) | Il est utilisé pour renvoyer le caractère à la position spécifiée. |
public entier | longueur() | Il est utilisé pour renvoyer la longueur de la chaîne, c'est-à-dire le nombre total de caractères. |
Chaîne publique | sous-chaîne (int startIndex) | Il est utilisé pour renvoyer la sous-chaîne du startIndex spécifié. |
Chaîne publique | sous-chaîne (int startIndex, int endIndex) | Il est utilisé pour renvoyer la sous-chaîne du startIndex et du endIndex spécifiés. |
Qu'est-ce qu'une chaîne mutable ?
Une chaîne qui peut être modifiée ou changée est appelée chaîne mutable. Les classes StringBuffer et StringBuilder sont utilisées pour créer des chaînes mutables.
1) Méthode append() de la classe StringBuffer
La méthode append() concatène l'argument donné avec cette chaîne.
StringBufferExample.java
class StringBufferExample{ public static void main(String args[]){ StringBuffer sb=new StringBuffer('Hello '); sb.append('Java');//now original string is changed System.out.println(sb);//prints Hello Java } }
Sortir:
Hello Java
2) Méthode StringBuffer insert()
La méthode insert() insère la chaîne donnée avec cette chaîne à la position donnée.
StringBufferExample2.java
class StringBufferExample2{ public static void main(String args[]){ StringBuffer sb=new StringBuffer('Hello '); sb.insert(1,'Java');//now original string is changed System.out.println(sb);//prints HJavaello } }
Sortir:
HJavaello
3) Méthode StringBuffer replace()
La méthode replace() remplace la chaîne donnée à partir des startIndex et endIndex spécifiés.
StringBufferExample3.java
class StringBufferExample3{ public static void main(String args[]){ StringBuffer sb=new StringBuffer('Hello'); sb.replace(1,3,'Java'); System.out.println(sb);//prints HJavalo } }
Sortir:
HJavalo
4) Méthode StringBuffer delete()
La méthode delete() de la classe StringBuffer supprime la chaîne du startIndex spécifié vers le endIndex.
StringBufferExample4.java
class StringBufferExample4{ public static void main(String args[]){ StringBuffer sb=new StringBuffer('Hello'); sb.delete(1,3); System.out.println(sb);//prints Hlo } }
Sortir:
Hlo
5) Méthode StringBuffer reverse()
La méthode reverse() de la classe StringBuilder inverse la chaîne actuelle.
StringBufferExample5.java
class StringBufferExample5{ public static void main(String args[]){ StringBuffer sb=new StringBuffer('Hello'); sb.reverse(); System.out.println(sb);//prints olleH } }
Sortir:
olleH
6) Méthode StringBuffer capacité()
La méthode capacité() de la classe StringBuffer renvoie la capacité actuelle du tampon. La capacité par défaut du tampon est de 16. Si le nombre de caractères augmente par rapport à sa capacité actuelle, il augmente la capacité de (oldcapacity*2)+2. Par exemple, si votre capacité actuelle est de 16, elle sera (16*2)+2=34.
StringBufferExample6.java
class StringBufferExample6{ public static void main(String args[]){ StringBuffer sb=new StringBuffer(); System.out.println(sb.capacity());//default 16 sb.append('Hello'); System.out.println(sb.capacity());//now 16 sb.append('java is my favourite language'); System.out.println(sb.capacity());//now (16*2)+2=34 i.e (oldcapacity*2)+2 } }
Sortir:
16 16 34
7) Méthode StringBuffer EnsureCapacity()
La méthode EnsureCapacity() de la classe StringBuffer garantit que la capacité donnée est la capacité minimale par rapport à la capacité actuelle. Si elle est supérieure à la capacité actuelle, elle augmente la capacité de (oldcapacity*2)+2. Par exemple, si votre capacité actuelle est de 16, elle sera (16*2)+2=34.
StringBufferExample7.java
class StringBufferExample7{ public static void main(String args[]){ StringBuffer sb=new StringBuffer(); System.out.println(sb.capacity());//default 16 sb.append('Hello'); System.out.println(sb.capacity());//now 16 sb.append('java is my favourite language'); System.out.println(sb.capacity());//now (16*2)+2=34 i.e (oldcapacity*2)+2 sb.ensureCapacity(10);//now no change System.out.println(sb.capacity());//now 34 sb.ensureCapacity(50);//now (34*2)+2 System.out.println(sb.capacity());//now 70 } }
Sortir:
16 16 34 34 70