stringbuilder java
Mejores prácticas/rendimiento: mezclando StringBuilder.append con String.concat (7)
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 un 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? De esta publicación , noté que el operador + en Strings 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() ; entonces si eso es cierto, entonces eso está fuera de discusión. Pero, ¿qué pasa con String.concat() ? ¿Es correcto usar .append() para cada concatenación? ¿O solo para las variables, y los literales están bien para anexar 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 de las mejores prácticas y el rendimiento para abordar estas situaciones? ¿Mi suposición es correcta en + y realmente no debería usarse?
+ operador
String s = s1 + s2
Detrás de escena esto se traduce a:
String s = new StringBuilder(s1).append(s2).toString();
Imagine cuánto trabajo adicional agrega si tiene s1 + s2 aquí:
stringBuilder.append(s1 + s2)
en lugar de:
stringBuilder.append(s1).append(s2)
Varias cadenas con +
Vale la pena notar que:
String s = s1 + s2 + s3 + ... +sN
se traduce a:
String s = new StringBuilder(s1).append(s2).append(s3)...apend(sN).toString();
concat()
String s = s1.concat(s2);
String crea una matriz char[] que puede ajustarse tanto a s1 como a s2 . Copia los contenidos de s1 y s2 a esta nueva matriz. En realidad, requiere menos trabajo entonces + operador.
StringBuilder.append()
Mantiene una matriz interna de caracteres char[] que crece cuando es necesario. No se crea ningún char[] adicional char[] si el interno es suficientemente grande.
stringBuilder.append(s1.concat(s2))
tampoco tiene un s1.concat(s2) rendimiento porque s1.concat(s2) crea una matriz char[] extra y copia s1 y s2 en ella solo para copiar los nuevos contenidos de la matriz en el char[] interno de StringBuilder char[] .
Dicho esto, debe usar append() todo el tiempo y anexar cadenas sin formato (su primer fragmento de código es correcto).
El compilador optimiza la + concatenación.
Asi que
int a = 1;
String s = "Hello " + a;
se transforma en
new StringBuilder().append("Hello ").append(1);
Hay un excelente tema here explica por qué debería usar el operador +.
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 sitio web de Java Best Practices on Oracles.
Si utiliza exactamente dos cadenas, use String.concat (crea una nueva cadena creando una nueva matriz de caracteres que se adapte a ambas cadenas y copie las dos matrices de cadenas de caracteres en ella).
Si combina varias cadenas (más de dos) en una línea, use + o StringBuilder.append, no importa, ya que el compilador convierte + a StringBuilder.append. Esto es bueno para múltiples cadenas porque mantiene una matriz de caracteres que crece según sea necesario.
Si concat varias cadenas en múltiples líneas crea un StringBuilder y utiliza el método de agregar. Al final, cuando haya terminado de anexar cadenas a StringBuilder, use su método .toString () para crear una cadena. Para la concatenación en múltiples 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, anexaría las cadenas y luego volvería a Cadena, mientras que el tercer método solo usaría un StringBuilder para todo.
Siempre deberías usar append .
concat crea una nueva Cadena así que es bastante como + Creo.
Si concat o usa + con 2 String final, la JVM puede optimizar, por lo que es lo mismo que agregar en este caso.
Usar + operador es la mejor práctica, también es simple y legible.
El lenguaje Java proporciona soporte especial para el operador de concatenación de cadenas (+) y para la conversión de otros objetos a cadenas. La concatenación de cadenas se implementa a través de la clase StringBuilder (o StringBuffer) y su método de adición.
Documento oficial: https://docs.oracle.com/javase/8/docs/api/java/lang/String.html
en el nivel de código de bytes no es diferente y no estamos comprometiendo la effeciancia 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 ensambles similares al ensamblado, habrá una llamada de registro adicional para almacenar + llamada de método en la pila y habrá un empuje adicional. (en realidad, el compilador cruzado podría optimizar el operador + llame, en ese caso, para que no haya diferencia con la eficiencia.)
Es una buena práctica tener una forma de aumentar la legibilidad. :)