Explication complète de la relation entre les classes StringBuilder, StringBuffer et String en Java

1. Classe String

La valeur de String est immuable, ce qui fait que chaque opération sur String génère un nouvel objet String, ce qui est non seulement inefficace, mais gaspille également beaucoup d'espace mémoire limité.
String a = "a"; //Supposons que a pointe vers l'adresse 0x0001
a = "b";//Après la réaffectation, a pointe vers l'adresse 0x0002, mais le "a" enregistré dans l'adresse 0x0001 existe toujours, mais cela a été. Ce n'est plus ce que a indique, a indique déjà une autre adresse.
Par conséquent, les opérations sur les chaînes consistent uniquement à modifier l'adresse d'affectation plutôt qu'à modifier la valeur.

2. StringBuffer est une classe mutable et une classe d'opérations de chaîne thread-safe. Toute opération sur la chaîne vers laquelle elle pointe ne créera pas de nouvel objet. Chaque objet StringBuffer a une certaine capacité de tampon. Lorsque la taille de la chaîne ne dépasse pas la capacité, aucune nouvelle capacité ne sera allouée. Lorsque la taille de la chaîne dépasse la capacité, la capacité sera automatiquement augmentée.

StringBuffer buf=new StringBuffer(); //Allouer un tampon de caractères de 16 octets
StringBuffer buf=new StringBuffer(512); //Allouer un tampon de caractères de 512 octets
StringBuffer buf= new StringBuffer("this is a test")//Stockez la chaîne dans le tampon et réservez ensuite un tampon vide de 16 octets.

3.StringBuffer
Les fonctions des classes StringBuffer et StringBuilder sont fondamentalement similaires. La principale différence est que les méthodes de la classe StringBuffer sont multithread et sûres, tandis que StringBuilder n'est pas thread-safe en comparaison. , la classe StringBuilder sera légèrement Dépêchez-vous. Pour les chaînes dont les valeurs changent fréquemment, les classes StringBuffer et StringBuilder doivent être utilisées.

4. Sécurité des threads
Sécurité des threads StringBuffer
StringBuilder thread non sécurisé

5. Vitesse
En général, la vitesse va de rapide à lente : StringBuilder>StringBuffer> String ,Cette comparaison est relative et non absolue.

6. Résumé
(1). Si vous souhaitez utiliser une petite quantité de données, utilisez = String
(2). data = StringBuilder
(3 ). Opération multithread du tampon de chaîne pour exploiter une grande quantité de données = StringBuffer

Voici le code et les instructions de démonstration :

public class TestCharacter { 
final static int time = 50000; //循环次数 

public TestCharacter(){ 

} 
public void test(String s){ 
long begin = System.currentTimeMillis(); 
for(int i=0; i<time; i++){ 
s += “add”; 
} 
long over = System.currentTimeMillis(); 
System.out.println(“操作”+s.getClass().getName()+”类型使用的时间为：”+(over-begin)+”毫秒”); 
} 
public void test(StringBuffer s){ 
long begin = System.currentTimeMillis(); 
for(int i=0; i<time; i++){ 
s.append(“add”); 
} 
long over = System.currentTimeMillis(); 
System.out.println(“操作”+s.getClass().getCanonicalName()+”类型使用的时间为：”+(over-begin)+”毫秒”); 
} 
public void test(StringBuilder s){ 
long begin = System.currentTimeMillis(); 
for(int i=0; i<time; i++){ 
s.append(“add”); 
} 
long over = System.currentTimeMillis(); 
System.out.println(“操作”+s.getClass().getName()+”类型使用的时间为：”+(over-begin)+”毫秒”); 
} 

/*对 String 直接进行字符串拼接的测试*/ 
public void test2(){ 
String s2 = “abcd”; 
long begin = System.currentTimeMillis(); 
for(int i=0; i<time; i++){ 
String s = s2 + s2 +s2; 
} 
long over = System.currentTimeMillis(); 
System.out.println(“操作字符串对象引用相加类型使用的时间为：”+(over-begin)+”毫秒”); 
} 
public void test3(){ 
long begin = System.currentTimeMillis(); 
for(int i=0; i<time; i++){ 
String s =”abcd” + “abcd” + “abcd”; 
} 
long over = System.currentTimeMillis(); 
System.out.println(“操作字符串相加使用的时间为：”+(over-begin)+”毫秒”); 
} 
public static void main(String[] args){ 
String s1 = “abcd”; 
StringBuffer st1 = new StringBuffer(“abcd”); 
StringBuilder st2 = new StringBuilder(“abcd”); 
TestCharacter tc = new TestCharacter(); 
tc.test(s1); 
tc.test(st1); 
tc.test(st2); 
tc.test2(); 
tc.test3(); 
} 
}

J'ai exécuté ce code sous myeclipse et dos. Les temps imprimés par chacun sont légèrement différents et les résultats d'exécution sont les suivants :
1) Lorsque myeclipse est cyclé 10 000 fois :

2) Lorsque myeclipse est cyclé 50 000 fois :

3) Lors de l'exécution sous DOS :

Explications plus complètes de StringBuilder, StringBuffer, String en java Pour les articles liés à la relation entre les classes, veuillez faire attention au site Web PHP chinois !