A menudo solía ver discusiones sobre el empalme de cadenas de Java y otros aspectos en Internet. Vi a algunos desarrolladores de Java en sus sugerencias a programadores novatos como los siguientes:
No use las cadenas de Sign to Splice, use el método append () de StringBuffer o StringBuilder en cadenas de empalme.
Sin embargo, es realmente tan molesto para empalmar las cadenas con + signos. ¿No hay nada bueno en usar + letreros para empalmarse?
Al buscar un contenido sobre la clase de cadena en la documentación de la API Java, podemos ver el siguiente fragmento:
"El lenguaje Java proporciona un soporte especial para símbolos de concatenación de cadenas ("+") y la conversión de otros objetos en cadenas. La concatenación de cadena se implementa a través de la clase StringBuilder (o StringBuffer) y su método de apéndice.
Este pasaje claramente nos dice que en Java, el uso de cadenas de empalme de Sign String es realmente implementado por StringBuffer o StringBuilder y su método de apéndice.
Además de la documentación de la API de Java, también podemos usar la herramienta para ver el comando bytecode del archivo de clase para obtener la respuesta anterior. Por ejemplo Código:
public static void main (string [] args) {string a = "hello"; Cadena b = "mundo"; Cadena str = a + b + "!"; System.out.println (str);} El comando para ver el bytecode correspondiente a través de la herramienta es el siguiente:
Desde el comando bytecode, podemos ver claramente que el siguiente código que escribimos
Cadena str = a + b + "!";
Se convirtió en una declaración similar a la siguiente:
String str = new StringBuilder (String.ValueOf (a)). Append (b) .Append ("!"). ToString ();No solo eso, el compilador Java también es un compilador relativamente inteligente. Cuando el empalme + de signo es todos los literales de cadena, el compilador Java lo convertirá inteligentemente en una cadena completa durante la compilación. Por ejemplo:
public static void main (string [] args) {string str = "hello" + "world" + ", java!"; System.out.println (str);} El compilador de Java abulla directamente este tipo de cadena que es todo literal y la convierte en una cadena completa cuando se compila.
Incluso si hay variables en la cadena empalmada con signo +, el compilador Java fusionará los literales de la cadena delantera en una cadena.
public static void main (string [] args) {string java = ", java!"; Cadena str = "hola" + "mundo" + java; System.out.println (str);}De lo anterior, se puede ver que para una operación como String Str = Str1 + Str2 + Str3 + Str4, no hay problema con el empalmado de múltiples cadenas a la vez.
En Java, los objetos de cadena son inmutables (inmutables). En el código, puede crear múltiples alias para un determinado objeto de cadena. Pero las referencias de estos alias son las mismas.
Por ejemplo, S1 y S2 son alias para objetos "droidyue.com", y los alias se almacenan en referencias al objeto real. Entonces S1 = S2
String S1 = "droidyue.com"; String S2 = S1; System.out.println ("S1 y S2 tiene la misma referencia =" + (S1 == S2));Y en Java, el único operador sobrecargado está relacionado con el empalme de cadenas. +,+=. Además de eso, los diseñadores de Java no permiten sobrecargar a otros operadores.
En Java, el único operador sobrecargado está relacionado con el empalme de cadena. +,+=. Además de eso, los diseñadores de Java no permiten sobrecargar a otros operadores.
Como todos sabemos, antes de Java 1.4, las costuras de cadena podrían usarse para empalmar las cadenas. A partir de Java 1.5, podemos usar StringBuilder hasta cadenas de empalme. La principal diferencia entre StringBuffer y StringBuilder es que StringBuffer es segura y es adecuada para la operación de cadenas de múltiples hilos; StringBuilder es seguro de hilo y es adecuado para operar cadenas debajo de un solo hilo. Sin embargo, la mayoría de nuestras operaciones de costura de cadenas se realizan bajo un solo hilo, por lo que usar StringBuilder es beneficioso para el rendimiento.
Antes de Java 1.4, el compilador usaba StringBuffer para manejar cadenas con cadenas empalmadas de signo +; A partir de Java 1.5, el compilador usó StringBuilder para manejar cadenas con cadenas empalmadas + de signo en la mayoría de los casos.
Cuando escribimos código en el entorno JDK 1.4, se recomienda que el signo + se use para lidiar con la situación anterior donde múltiples cadenas se empaldenan a la vez. De esta manera, cuando JDK se actualiza a 1.5 y más, el compilador lo convertirá automáticamente a StringBuilder a cadenas de empalme, mejorando así la eficiencia del empalme de cuerdas.
Por supuesto, el uso recomendado de cadenas de empalme de + signo solo se limita a usar al empalmar múltiples cadenas en una declaración. Si emplomea una cadena en múltiples declaraciones, aún se recomienda usar StringBuffer o StringBuilder. Por ejemplo:
public static void main (string [] args) {string java = ", java!"; Cadena str = ""; str += "hola"; str += "mundo"; str += java; System.out.println (str);} Los comandos de byte compilados del compilador son los siguientes:
De la imagen de arriba, podemos saber que cada declaración de empalme de + signo crea un nuevo objeto StringBuilder. Esta situación es particularmente evidente en condiciones de ciclo, lo que resulta en pérdidas de rendimiento relativamente grandes. Por lo tanto, se recomienda usar StringBuffer o StringBuilder para manejar cadenas en múltiples declaraciones.
Sobre la optimización traída por el uso de StringBuilder
Además, al usar StringBuffer o StringBuilder, también podemos usar el siguiente método para mejorar aún más el rendimiento (el siguiente código toma StringBuilder como ejemplo, StringBuffer es similar a esto).
1. Predecir la longitud máxima de la cadena obtenida final.
La longitud predeterminada de la matriz de char StringBuilder es 16. Cuando agregamos la cadena y superamos esta longitud, StringBuilder expandirá la capacidad de matriz interna para satisfacer las necesidades. En este proceso, StringBuilder crea una nueva matriz de caracteres de mayor capacidad y copia los datos de la matriz original en la nueva matriz. Si podemos predecir aproximadamente la longitud máxima de la cadena que finalmente se empalma, podemos especificar la capacidad inicial del tamaño apropiado al crear el objeto StringBuilder. Por ejemplo, necesitamos empalmar para obtener una cadena que contenga 100 letras a. Puede escribir el siguiente código:
StringBuilder sb = new StringBuilder (100); for (int i = 0; i <100; i ++) {sb.append ('a');} system.out.println (sb);Por favor, equilibre de acuerdo con las condiciones reales para crear un StringBuilder adecuado para la capacidad inicial.
2. Para caracteres individuales, use el tipo de char en lugar del tipo de cadena tanto como sea posible.
A veces, necesitamos agregar un solo carácter después de la cadena (por ejemplo: a), y debemos usarlo tanto como sea posible en este momento.
sb.append ('a');En lugar de usar:
sb.append ("a");