java - example - ¿Cuándo deberías usar explícitamente un StringBuilder?
stringbuilder java example (3)
Es más general que los "bucles internos": cada vez que desea hacer concatenación sobre varias declaraciones y no necesita el resultado intermedio como una cadena. Por ejemplo:
StringBuilder builder = new StringBuilder("Start");
if (someCondition) {
builder.append("Foo");
}
if (someOtherCondition) {
builder.append("Bar");
}
builder.append("End");
String result = builder.toString();
Mientras puedas escribir eso como:
String result = "Start" + (someCondition ? "Foo" : "")
+ (someOtherCondition ? "Bar" : "") + "End";
... eso se vuelve difícil de leer. Y si hay más declaraciones dentro de los cuerpos de if , puede que ni siquiera sea factible.
Para corregir algo dentro de su pregunta sin embargo:
Como lo entiendo, cuando hago String baz = "foo" + "bar" + "123" el compilador java reemplaza internamente la expresión con un StringBuilder.
No, cuando escribes esa expresión, el compilador reconoce que es una constante de compilación y la reemplaza por
String baz = "foobar123";
Esa es una muy buena razón para no usar explícitamente un StringBuilder : el código anterior es claramente más eficiente en el momento de la ejecución que
String baz = new StringBuilder("foo").append("bar").append("123").toString();
Cuando no es una constante de tiempo de compilación, el compilador de Java realizará la concatenación utilizando un StringBuilder , por lo general dejándole un código más fácil de entender que con el uso explícito de StringBuilder , pero sin un impacto en el rendimiento. Sospecho que su profesor no entiende correctamente la concatenación de cadenas, o simplemente lee en otro lugar que debería usar StringBuilder sin entender completamente cuándo es apropiado.
Esta pregunta ya tiene una respuesta aquí:
Como lo entiendo, cuando hago String baz = "foo" + "bar" + "123" el compilador de Java reemplaza internamente la expresión con un StringBuilder . Sin embargo, nuestro profesor de Java nos dijo que es una buena práctica usar siempre un StringBuilder explícitamente ...
¿Tengo razón al suponer que solo necesitaré usar StringBuilder explícitamente al concatenar bucles internos como se indica en una respuesta a la pregunta de desbordamiento de pila Creador de cadenas frente a concatenación de cadenas ? ¿Hay otros casos en los que debería usar explícitamente un StringBuilder lugar de + o += ?
Obi Wan ha dicho que solo Sith piensa en absolutos o algo similar ...
Es bueno saber que el compilador de Java reemplaza internamente "+" en las cadenas con el uso de StringBuilder . Para eso son los compiladores: para hacer la vida más fácil.
A menos que tenga bucles, como en el caso vinculado, o condicionales del ejemplo de Jon Skeet, se trata principalmente de la cuestión de la legibilidad y la facilidad de mantenimiento.
Reemplazo
return "User " + userName + " said";
con
new StringBuilder().append("User ").append(userName).append(" said").toString();
hace que el código sea más largo, probablemente más difícil de modificar, es más probable que fuerce los saltos de línea y le brinda más rendimiento.
Sin embargo, cuando la adición se aplica no solo a las cadenas, sino que hay números involucrados, probablemente la solución con StringBuilder veces sea más legible.
return "User" + a + b + " said: " + (c + d);
Puede ser más confuso como:
return new StringBuilder().append("User ").append(a).append(b)
.append(" said: ").append(c+d).toString();
Pero es principalmente cuestión de opinión y estilo de codificación. "Debería" no es una buena palabra aquí.
También son buenos para implementar cosas como la palabra clave ''fuera'' de C # con una cadena. Ejemplo
public int getInt(StringBuilder error)
{
int retVal = 0;
if (someErrorOccured)
error.append("Couldn''t get int because of...");
else
retVal = whatItsSupposedToBe;
return retVal;
}