java - 为什么说String的拼接会产生很多的无用对象呢？

Question

为什么说String的拼接会产生很多的无用对象呢？
eg.
String str = "";
while(true){

str +="abc";

}

按我的理解，字符串拼接只会在常量池中创建共享对象，常量池的对象会被垃圾回收器回收吗？为什么说会产生很多无用的对象，需要垃圾回收，从而影响程序性能呢？

Answer 1

Concernant ce que dit l'affiche, l'épissage de chaînes ne créera que des objets partagés dans le pool constant, je ne comprends pas à quoi cela fait spécifiquement référence, mais je peux expliquer pourquoi cette façon d'écrire produit beaucoup d'objets inutiles, j'espère. cela aidera. L’affiche originale a été utile.

Voici les réponses :

Regardez d'abord l'image ci-dessus. La classe String dans JDK est une classe finale, et la valeur utilisée pour stocker les caractères String est également finale !

Cela signifie que la valeur de l'objet chaîne ne peut pas être modifiée après sa création ! Par conséquent, la chaîne générée par chaque boucle doit être un nouvel objet String. Mais le code ci-dessus génère plus d’objets que vous ne le pensez ! s'il vous plaîtContinuez à regarder les photos !

----------------------Belle ligne de démarcation----------------------------------- - -------

La case rouge de la deuxième image est le code décompilé dans la case rouge de la première image. On peut le voir sur l'image :
a+=a ; fait les choses suivantes :

1. Appelez String.valueOf(a). Dans cette étape, comme a est également une chaîne, aucun nouvel objet ne sera généré.

2. nouveau StringBulid (le premier objet est en fait la chaîne a), cette étape générera un objet Stringbuild.

3. .append (chaîne ajoutée)

4. .toString(), cette étape appellera la méthode toString de Stringbuild.

Jetons un coup d'œil au code source toString() de Stringbuild

public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }

Oups ! Pourquoi un autre objet String est-il créé ?

L'analyse de a+=a est terminée ici, donc chaque opération d'ajout de chaîne dans la boucle crée en fait au moins un objet StringBuild et un objet String !

Answer 2

String est un objet immuable, donc chaque fois que le type String est modifié, cela équivaut en fait à générer un nouvel objet String, puis à pointer le pointeur vers le nouvel objet String, de sorte que les chaînes qui changent fréquemment de contenu sont les plus importantes. Il est préférable de ne pas utiliser String, car chaque fois qu'un objet est généré, cela aura un impact sur les performances du système. Surtout lorsqu'il y a trop d'objets non référencés dans la mémoire, le GC de la JVM commencera à fonctionner et la vitesse sera certainement. assez lent.

Pour les variables fréquemment modifiées, StringBuffer doit être utilisé~

Answer 3

... Ce n'est qu'après jdk1.8 que StringBuild peut être utilisé pour l'épissage multiple de chaînes. . L'ancienne version n'est pas comme ça ! ~~
J'ai lu un article 0 0 la dernière fois et je ne sais pas si c'est faux.
Avant la version 1.8, plusieurs modifications de String nécessitaient l'utilisation de StringBuffer ou StringBuilder.
1.8 a activé le sucre syntaxique et modifié cette zone, nous permettant de bénéficier d'une grande efficacité sans appeler explicitement StringBuilder.

Et pour la chaîne, vous créerez uniquement un objet partagé dans le pool constant,

str +="abc";
1.abc
2.abcabc
3........

Tous les objets créés ici ne sont-ils pas des objets inutiles ? Outre les résultats finaux, le recyclage des GC prend également du temps.

Parce que string est la modification finale de char[], un nouvel objet doit être créé à chaque fois.
La raison pour laquelle StringBuilder est si efficace est que le tableau est étendu dynamiquement, généralement en ajoutant des opérations, pour créer uniquement un. new plus grand char[] lorsque la capacité est pleine, et copiez les anciennes données avant de les ajouter. En résumé, stringbuilder réduit la génération d'objets et n'a pas besoin de générer de nouveaux objets à chaque fois. N’hésitez pas à demander conseil aux experts ! ~! ~! ~