numero - concatenar textos java

¿Es la cadena de StringBuilder.append más eficiente que la concatenación de cadenas?

Question

Según la sugerencia de Netbeans llamada cadena de uso de métodos .append en lugar de concatenación de cadenas

Concatenación de cadenas en el parámetro de una invocación del método de adición de StringBuilder o StringBuffer.

¿Es StringBuilder.append () realmente más eficiente que la concatenación de cadenas?

Muestra de código

StringBuilder sb = new StringBuilder();
sb.append(filename + "/");

vs.

StringBuilder sb = new StringBuilder();
sb.append(filename).append("/");

Answer 1

Bueno, tu primer ejemplo se traduce esencialmente por el compilador en algo parecido a lo siguiente:

StringBuilder sb = new StringBuilder();
sb.append(new StringBuilder().append(filename).append("/").toString());

entonces sí, hay cierta ineficiencia aquí. Sin embargo, si realmente importa en su programa es una pregunta diferente. Además de ser un estilo cuestionable (pista: subjetiva), por lo general solo importa, si estás haciendo esto en un círculo cerrado.

Answer 2

Debe equilibrar la legibilidad con la funcionalidad.

Digamos que tienes lo siguiente:

String str = "foo";
str += "bar";
if(baz) str += "baz";

Esto creará 2 constructores de cadenas (donde solo necesita 1, realmente) más un objeto de cadena adicional para el interino. Sería más eficiente si fuera:

StringBuilder strBuilder = new StringBuilder("foo");
strBuilder.append("bar");
if(baz) strBuilder.append("baz");
String str = strBuilder.toString();

Pero como una cuestión de estilo, creo que el primero se ve bien. El beneficio de rendimiento de la creación de un solo objeto parece muy mínimo para mí. Ahora, si en lugar de 3 cuerdas, tuvieras 10, o 20, o 100, diría que el rendimiento supera el estilo. Si estuviera en un bucle, seguro usaría el generador de cadenas, pero creo que solo un par de cadenas está bien para hacer la manera ''descuidada'' de hacer que el código se vea más limpio. Pero ... ¡esto tiene una trampa muy peligrosa al acecho! Lea a continuación (pausa para crear suspense ... dun dun dunnnn)

Hay quienes dicen usar siempre el generador de cadenas explícito. Una de las razones es que su código seguirá creciendo, y generalmente lo hará de la misma manera que ya lo está (es decir, no se tomarán el tiempo para refactorizar). Así que terminará con esas 10 o 20 declaraciones cada una de ellas creando su propio constructor cuando no es necesario. Para evitar esto desde el principio, dicen que siempre usan un constructor explícito.

Entonces, en su ejemplo, no será particularmente rápido, cuando alguien en el futuro decida que quiere una extensión de archivo al final, o algo así, si continúan usando la concatenación de cadenas en lugar de un StringBuilder, van a ir para encontrar eventualmente problemas de rendimiento.

También debemos pensar en el futuro. Digamos que estaba haciendo código Java en JDK 1.1 y tenía el siguiente método:

public String concat(String s1, String s2, String s3) {
    return s1 + s2 + s3;
}

En ese momento, habría sido lento porque StringBuilder no existía.

Luego en JDK 1.3 decidiste hacerlo más rápido usando StringBuffer (StringBuilder todavía no existe). Tu hiciste esto:

public String concat(String s1, String s2, String s3) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    sb.append(s3);
    return sb.toString();
}

Se pone mucho más rápido. ¡Increíble!

Ahora sale JDK 1.5, y con él viene StringBuilder (que es más rápido que StringBuffer) y la transacción automática de

return s1 + s2 + s3;

a

return new StringBuilder().append(s1).append(s2).append(s3).toString();

Pero no obtienes este beneficio de rendimiento porque estás usando StringBuffer explícitamente. Entonces, al ser inteligente, has causado un golpe de rendimiento cuando Java se volvió más inteligente que tú. Así que debes tener en cuenta que hay cosas por las que no pensarás.

Answer 3

Hasta el momento, ninguna de las respuestas aborda explícitamente el caso específico para el que se insinúa. No está diciendo usar siempre StringBuilder#append lugar de concatenación. Pero, si ya está usando un StringBuilder , no tiene sentido mezclar en concatenación, porque crea un StringBuilder redundante (vea la respuesta de Dirk ) y una instancia de String temporal innecesaria.

Varias respuestas ya explican por qué la forma sugerida es más eficiente, pero el punto principal es que si ya tienes una instancia de StringBuilder , simplemente llama a append sobre ella. Es igual de fácil de leer (en mi opinión, y al parecer, quien escribió la sugerencia de NetBeans), ya que está llamando a append todos modos, y es un poco más eficiente.

Answer 4

Solo es más eficiente si usa muchas concatenaciones y cadenas realmente largas. Para uso general, como crear un nombre de archivo en su ejemplo, cualquier concatenación de cadenas es sencilla y más legible.

En cualquier caso, es poco probable que esta parte de su aplicación sea el cuello de botella de rendimiento.

Answer 5

Teóricamente, sí. Porque los objetos String son inmutables: una vez construidos, ya no se pueden cambiar. Entonces, usar "+" (concatenación) básicamente crea un nuevo objeto cada vez.

Prácticamente no. El compilador es lo suficientemente inteligente como para reemplazar todo su "+" con anexos de StringBuilder.

Para una explicación más detallada: http://kaioa.com/node/59

PD: Netbeans ??? ¡Venga!

Answer 6

Un concat de dos cadenas es más rápido usando esta función.

Sin embargo, si tiene varias cadenas o tipos de datos diferentes, debe usar un StringBuilder explícita o implícitamente. Usar a + con Strings es usar StringBuilder implícitamente.