Je voyais souvent des discussions sur l'épissage de la chaîne Java et d'autres aspects sur Internet. J'ai vu des développeurs Java dans leurs suggestions aux programmeurs novices comme les suivants:
N'utilisez pas le signe + pour épisser les chaînes, utilisez la méthode APPEND () de StringBuffer ou StringBuilder pour épisser les chaînes.
Cependant, c'est vraiment tellement ennuyeux d'épisser les cordes avec + signes. N'y a-t-il rien de bien à utiliser + des signes pour épisser les chaînes?
En recherchant un contenu sur la classe String dans la documentation de l'API Java, nous pouvons voir l'extrait suivant:
"Le langage Java fournit une prise en charge spéciale pour les symboles de concaténation des chaînes (" + ") et la conversion d'autres objets en chaînes. La concaténation de la chaîne est implémentée via la classe StringBuilder (ou StringBuffer) et sa méthode d'appel. La conversion de chaîne est implémentée via la méthode de tostring, qui est définie par la classe d'objets et peut être inhérente à toutes les classes dans Java."
Ce passage nous dit clairement qu'en Java, l'utilisation de chaînes d'épissage + signe est en fait implémentée par StringBuffer ou StringBuilder et sa méthode d'ajout.
En plus de la documentation de l'API Java, nous pouvons également utiliser l'outil pour afficher la commande bytecode du fichier de classe pour obtenir la réponse ci-dessus. Par exemple le code:
public static void main (String [] args) {String a = "Hello"; String b = "world"; String str = a + b + "!"; System.out.println (str);} La commande pour afficher le bytecode correspondant via l'outil est la suivante:
À partir de la commande bytecode, nous pouvons clairement voir que le code suivant que nous avons écrit
String str = a + b + "!";
Il a été converti en une déclaration similaire à ce qui suit:
String str = new StringBuilder (string.valueof (A)). APPEND (b) .APPEND ("!"). ToString ();Non seulement cela, le compilateur Java est également un compilateur relativement intelligent. Lorsque l'épissage + signe est entièrement littéraux de chaîne, le compilateur Java le convertira intelligemment en une chaîne complète pendant la compilation. Par exemple:
public static void main (String [] args) {String str = "Hello" + "world" + ", java!"; System.out.println (str);} Le compilateur Java épissant directement ce type de chaîne qui est tout littéral et le convertit en une chaîne complète lorsqu'elle est compilée.
Même s'il y a des variables dans la chaîne épissées avec + signe, le compilateur Java fusionnera les littéraux de chaîne avant en une seule chaîne.
public static void main (String [] args) {String java = ", java!"; String str = "Hello" + "World" + Java; System.out.println (str);}À partir de ce qui précède, on peut voir que pour une opération comme String str = str1 + str2 + str3 + str4, il n'y a aucun problème avec l'épissage de plusieurs chaînes en même temps.
En Java, les objets de chaîne sont immuables (immuables). Dans le code, vous pouvez créer plusieurs alias pour un certain objet String. Mais les références de ces alias sont les mêmes.
Par exemple, S1 et S2 sont un alias pour les objets "droidyue.com", et les alias sont stockés dans des références à l'objet réel. SO S1 = S2
String S1 = "Droidyue.com"; String S2 = S1; System.out.println ("S1 et S2 a la même référence =" + (S1 == S2));Et dans Java, le seul opérateur surchargé est lié à l'épissage de chaîne. +, + =. En plus de cela, les concepteurs de Java n'autorisent pas la surcharge d'autres opérateurs.
Dans Java, le seul opérateur surchargé est lié à l'épissage de chaîne. +, + =. En plus de cela, les concepteurs de Java n'autorisent pas la surcharge d'autres opérateurs.
Comme nous le savons tous, avant Java 1.4, les coutures à cordes pourraient être utilisées pour épisser les chaînes. À partir de Java 1.5, nous pouvons utiliser StringBuilder pour épisser les chaînes. La principale différence entre StringBuffer et StringBuilder est que StringBuffer est thread-safe et convient au fonctionnement multi-thread des chaînes; StringBuilder est fileté et convient aux chaînes de fonctionnement sous un seul thread. Cependant, la plupart de nos opérations de couture de chaîne sont effectuées sous un seul thread, donc l'utilisation de StringBuilder est bénéfique pour les performances.
Avant Java 1.4, le compilateur a utilisé StringBuffer pour gérer les chaînes avec des chaînes épissées + signe; À partir de Java 1.5, le compilateur a utilisé StringBuilder pour gérer les chaînes avec des chaînes épissées + signe dans la plupart des cas.
Lorsque nous écrivons du code dans l'environnement JDK 1.4, il est recommandé que le signe + soit utilisé pour gérer la situation ci-dessus où plusieurs chaînes sont épissées en même temps. De cette façon, lorsque JDK est mis à niveau à 1,5 et plus, le compilateur le convertira automatiquement en StringBuilder en chaînes d'épissage, améliorant ainsi l'efficacité de l'épissage des cordes.
Bien sûr, l'utilisation recommandée des chaînes d'épissage + des signes ne se limite qu'à utiliser lors de l'épissage de plusieurs chaînes dans une déclaration. Si vous épissez une chaîne en plusieurs instructions, il est toujours recommandé d'utiliser StringBuffer ou StringBuilder. Par exemple:
public static void main (String [] args) {String java = ", java!"; String str = ""; str + = "bonjour"; str + = "monde"; str + = java; System.out.println (str);} Les commandes d'octets compilées du compilateur sont les suivantes:
Depuis l'image ci-dessus, nous pouvons savoir que chaque instruction d'épissage + signe crée un nouvel objet StringBuilder. Cette situation est particulièrement évidente dans des conditions de cycle, entraînant des pertes de performances relativement importantes. Par conséquent, il est fortement recommandé d'utiliser StringBuffer ou StringBuilder pour gérer les chaînes dans plusieurs instructions.
À propos de l'optimisation apportée en utilisant StringBuilder
De plus, lorsque vous utilisez StringBuffer ou StringBuilder, nous pouvons également utiliser la méthode suivante pour améliorer davantage les performances (le code suivant prend StringBuilder à titre d'exemple, StringBuffer est similaire à celui-ci).
1. Prédire la longueur maximale de la chaîne finale obtenue.
La longueur par défaut du tableau char à l'intérieur de StringBuilder est 16. Lorsque nous ajoutons la chaîne et dépassons cette longueur, StringBuilder élargira la capacité du tableau interne pour répondre aux besoins. Dans ce processus, StringBuilder crée un nouveau tableau de char à plus grande capacité et copie les données du tableau d'origine dans le nouveau tableau. Si nous pouvons prédire à peu près la longueur maximale de la chaîne finalement épissée, nous pouvons spécifier la capacité initiale de la taille appropriée lors de la création de l'objet StringBuilder. Par exemple, nous devons épisser pour obtenir une chaîne contenant 100 lettres a. Vous pouvez écrire le code suivant:
StringBuilder sb = new StringBuilder (100); pour (int i = 0; i <100; i ++) {sb.append ('a');} System.out.println (sb);Veuillez équilibrer en fonction des conditions réelles pour créer un STRINGBUILDER adapté à la capacité initiale.
2. Pour les caractères individuels, utilisez le type de char au lieu du type de chaîne autant que possible.
Parfois, nous devons ajouter un seul caractère après la chaîne (par exemple: a), et nous devons l'utiliser autant que possible pour le moment.
SB.APPEND ('A');Au lieu d'utiliser:
SB.APPEND ("A");