Analyse de la différence entre StringBuffer et String en JAVA

J'ai vu que cette explication était bonne, alors je l'ai transférée

Il existe trois classes en Java qui sont responsables des opérations sur les personnages.

1.Character opère sur un seul caractère,

2.String opère sur une chaîne de caractères, classe immuable.

3.StringBuffer fonctionne également sur une chaîne de caractères et est une classe variable.

String :
est un objet, pas un type primitif.
est un objet immuable. Une fois créé, sa valeur ne peut pas être modifiée.
Les modifications apportées aux objets String existants sont toutes nouvelles. Créez un nouvel objet et enregistrez-y la nouvelle valeur.
String est une classe finale, c'est-à-dire qu'elle ne peut pas être héritée

StringBuffer :
est un objet mutable, lorsqu'il est modifié. l'objet ne sera pas recréé comme String
Il ne peut être créé que via le constructeur,
StringBuffer sb = new StringBuffer();
Remarque : il ne peut pas être payé via le symbole d'affectation
sb. = "bienvenue ici!"; //Une fois l'objet error
créé, de l'espace mémoire sera alloué dans la mémoire et un null sera initialement enregistré. Lors de l'attribution d'une valeur à StringBuffer, vous pouvez utiliser son append().
sb.append("hello");

StringBuffer est plus efficace que String dans les opérations de connexion de chaîne :

String str = new String("bienvenue dans ");
str = "here"; Les étapes de traitement de
consistent en fait à créer un StringBuffer, puis à appeler append(), et enfin
convertir StringBuffer en Sting();
De cette façon, l'opération de connexion String est plus rapide que StringBuffer a quelques opérations supplémentaires, mais bien sûr l'efficacité est compromise.

Et comme l'objet String est un objet immuable, un nouvel objet sera recréé à chaque fois que Sting est utilisé pour enregistrer le nouveau valeur.
Voici comment il s'avère que l'objet est inutile et sera récupéré. Cela affectera également les performances

Regardez le code suivant :
Ajoutez à plusieurs reprises 26 lettres anglaises 5000 fois.

        String tempstr = "abcdefghijklmnopqrstuvwxyz";
        int times = 5000;
        long lstart1 = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < times; i++) {
            str += tempstr;
        }
        long lend1 = System.currentTimeMillis();
        long time = (lend1 - lstart1);
        System.out.println(time);

Malheureusement, mon ordinateur n'est pas un supercalculateur, et les résultats obtenus peuvent ne pas être les mêmes à chaque fois, généralement autour de 46687.
Cela fait 46 secondes.

Regardons à nouveau le code suivant

        String tempstr = "abcdefghijklmnopqrstuvwxyz";
        int times = 5000;
        long lstart2 = System.currentTimeMillis();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < times; i++) {
            sb.append(tempstr);
        }
        long lend2 = System.currentTimeMillis();
        long time2 = (lend2 - lstart2);
        System.out.println(time2);

Le résultat est 16 et parfois 0
La conclusion est donc évidente, StringBuffer est presque des dizaines de milliers de fois plus rapide que String. Bien entendu, ces données ne sont pas très précises. Car lorsque le nombre de cycles est de 100 000, la différence est encore plus grande. Si vous ne me croyez pas, essayez

Si vous n'arrivez toujours pas à comprendre :

1) La différence entre la méthode d'union de String et la méthode d'ajout de StringBuff :

<🎜 Lorsque l'opérateur >String effectue des opérations sur les chaînes, il convertit d'abord l'objet chaîne actuel en type StringBuff, appelle sa méthode append et convertit enfin l'objet StringBuff généré en une chaîne de type String via sa méthode toString, donc son L'efficacité est inférieure.

Mais en termes de lisibilité, l’opérateur de connexion de String est encore meilleur.

2) StringBuff est thread-safe

String n'est pas thread-safe

3) String est un objet chaîne qui ne peut pas être modifié, mais StringBuff peut être modifié.

public static boolean fileCopy(String srcStr, String destStr) {
File srcFile = null;
File destFile = null;
Reader reader = null;
Writer writer = null;
boolean flag = false;
try {
srcFile = new File(srcStr);
if (!srcFile.exists()) {
System.out.println(“源文件不存在”);
System.exit(0);
} else {
reader = new FileReader(srcFile);
}
destFile = new File(destStr);
writer = new FileWriter(destFile);
char[] buff = new char[1024];
int len;
String str = “”;
StringBuffer sbuff = new StringBuffer();
while ((len = reader.read(buff)) != -1) {
//        str += new String(buff, 0, len);
sbuff.append(new String(buff,0,len));
}
//      writer.write(str.toCharArray());
writer.write(sbuff.toString().toCharArray());
flag = true;
writer.flush();
reader.close();
writer.close();
} catch (IOException e) {
System.out.println(“文件拷贝异常:= ” + e.getMessage());
}
return flag;
}

Pour plus d'articles sur l'analyse de la différence entre StringBuffer et String en JAVA, veuillez faire attention au site Web PHP chinois !