Mejores prácticas / rendimiento: mezcla de StringBuilder.añadir con cadena.concat
Estoy tratando de entender cuál es la mejor práctica y por qué para concatenar literales de cadena y variables para diferentes casos. Por ejemplo, si tengo código como este
StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
.append(B_String).append("CCCCCCCCCCC").append(D_String)
.append("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
.append("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
Es esta la manera de hacerlo? Desde este post, noté que el operador + en Cadenas crea una nueva instancia de StringBuilder, concatena los operandos y devuelve una conversión de cadena, lo que parece mucho más trabajo que simplemente llamar a .append(); así que si eso es cierto, entonces está fuera del pregunta. Pero, ¿qué pasa con String.concat()? ¿Es apropiado usar .append() para cada concatenación? O solo para variables, y literales están bien para añadir con .concat()?
StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
.append(B_String.concat("CCCCCCCCCCC")).append(D_String
.concat("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
.concat("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"));
¿Cuáles son las reglas generales para las mejores prácticas y el desempeño para hacer frente a estas situaciones? Es mi suposición correcta en + y realmente no debe ser utilizado?
7 answers
+ operador
String s = s1 + s2
Detrás de las escenas esto se traduce a:
String s = new StringBuilder(s1).append(s2).toString();
Imagina cuánto trabajo extra agrega si tienes s1 + s2 aquí:
stringBuilder.append(s1 + s2)
En lugar de:
stringBuilder.append(s1).append(s2)
Cadenas múltiples con +
Vale la pena señalar que:
String s = s1 + s2 + s3 + ... +sN
Se traduce como:
String s = new StringBuilder(s1).append(s2).append(s3)...apend(sN).toString();
concat()
String s = s1.concat(s2);
String crea char[] matriz que puede caber tanto s1 y s2. Copia s1 y s2 contenidos a este nuevo array. Realmente requiere menos trabajo que el operador +.
StringBuilder.append()
Mantiene un array interno char[] que crece cuando es necesario. No se crea un char[] extra si el interno es suficientemente grande.
stringBuilder.append(s1.concat(s2))
También está funcionando mal porque s1.concat(s2) crea un array char[] extra y copia s1 y s2 a él solo para copiar el contenido del nuevo array a interno StringBuilder char[].
Dicho esto, debe usar append() todo el tiempo y agregar cadenas sin procesar (su primer código el fragmento es correcto).
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2012-04-09 20:21:58
El compilador optimiza la concatenación+.
So
int a = 1;
String s = "Hello " + a;
Se transforma en
new StringBuilder().append("Hello ").append(1).toString();
Hay un excelente tema aquí explicando por qué debe usar el operador+.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2018-07-01 21:14:46
La optimización se realiza automáticamente por el compilador.
El compilador Java2 convertirá automáticamente lo siguiente:
String s = s1 + s2;
A
String s = (new StringBuffer()).append(s1).append(s2).toString();
Tomado directamente del Java Best Practices en el sitio web de Oracles.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2014-05-12 19:41:16
Siempre debe usar append.
concat crear una nueva cadena por lo que es bastante como + creo.
Si concat o usas + con 2 cadenas finales, la JVM puede hacer la optimización, por lo que es lo mismo que hacer append en este caso.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2012-04-09 19:58:25
Si concat exactamente dos Cadenas de Cuerda.concat (crea una nueva cadena creando una nueva matriz de caracteres que se ajuste a ambas cadenas y copie las matrices de caracteres de ambas cadenas en ella).
Si concatea varias (más de dos) cadenas en una línea, utilice + o StringBuilder.append, no importa, ya que el compilador convierte + a StringBuilder.anexar. Esto es bueno para cadenas múltiples porque mantiene una matriz de caracteres que crece según sea necesario.
Si concat múltiples cadenas sobre varias líneas crean un StringBuilder y usan el método append. Al final, cuando haya terminado de agregar cadenas al StringBuilder use it's.toString () - método para crear una cadena a partir de ella. Para concatear en varias líneas, esto es más rápido que el segundo método, ya que el segundo método crearía un nuevo StringBuilder en cada línea, agregaría las Cadenas y luego volvería a String, mientras que el tercer método solo usa un StringBuilder para todo.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2014-01-27 10:03:19
Usar el operador + es la mejor práctica, también es simple y legible.
El lenguaje Java proporciona soporte especial para la cadena operador de concatenación ( + ), y para la conversión de otros objetos a cadena. La concatenación de cadenas se implementa a través de StringBuilder (o StringBuffer) y su método append.
Documento oficial: https://docs.oracle.com/javase/8/docs/api/java/lang/String.html
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2016-08-10 03:34:26
En el nivel de código de bytes no hay diferencia y no estamos comprometiendo la eficacia allí. En caso de ejecutar el nivel de código de bytes, debe pasar por el método de sobrecarga del operador no en línea para + llamando a append. luego, en el nivel de lenguaje ensamblador (Java está escrito en C y C produce ensamblajes similares a assembly, habrá una llamada de registro adicional a store + method call en la pila y habrá push adicional. (en realidad, cross-compiler podría optimizar + llamada de operador, en ese caso haciendo no hay diferencia con la eficiencia.)
Es una buena práctica tener una manera de aumentar la legibilidad. :)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2017-09-26 14:26:21