AOWS

Just another adrian’s weblog

Trabajando con cadenas en Java: StringBuffer y StringBuilder

with 9 comments

Java nos proporciona varias clases a la hora de trabajar con cadenas, cada una tiene sus características que la hace más o menos adecuada dependiendo del uso que se le vaya a dar.

Lo más utilizado son sin duda objetos de tipo String, al proporcionar suficiente potencial para la mayor parte de los casos.

La clase StringBuffer permite guardar cadenas que cambiarán en la ejecución del programa (a diferencia de los objetos String normales, que son inmutables).

Una clase parecida, StringBuilder, llegó con Java 5. Es idéntica a la anterior salvo que no es síncrona, lo que significa que puede haber problemas si es una variable a la que accedan diferentes threads. Sin embargo, para la mayoría de las aplicaciones (donde se ejecuta un solo hilo) supone una mejora de rendimiento sobre StringBuffer.

Cómo se usan

El método principal (o al menos el más usado) de ambas clases es append.

// creamos un StringBuffer vacío
StringBuffer sb = new StringBuffer();
// el tamaño va aumentando a medida que vayamos añadiendo caracteres
// el método append convierte automáticamente cualquier tipo en String (llamando al método toString())
sb.append("Esto es una prueba");
// también podemos insertar en una posición determinada
sb.insert(4, " no"); // sb = "Esto no es una prueba"
// o borrar trozos de la cadena
sb.delete(4, 11); // sb = "Esto prueba"

También es posible hacer llamadas encadenadas:

sb.append("Esto ").append("es ").append("una prueba");

StringBuffer vs String

Como acabos de comentar, un objeto de tipo String es inmutable, lo cual quiere decir que cada vez que modificamos su contenido se crea un nuevo objeto (con la cadena nueva) y se desecha el anterior.

Por ejemplo:

String cadena = new String("Cuenta: ");
for (int i=0; i<100; i++) {
   cadena += " " + i + " ";
}
// cadena = "Cuenta: 1 2 3 4 5 ... 99"

Este código crea dentro del bucle 99 objetos de tipo String, y en cada uno de ellos va guardando el nuevo contenido. Esto por supuesto no es eficiente, un problema que podemos resolver con StringBuffer:

StringBuffer cadena = new StringBuffer("Cuenta: ");
for (int i=0; i<100; i++) {
   cadena.append(" " + i + " ");
}
// cadena = "Cuenta: 1 2 3 4 5 ... 99"

En esta ocasión sólo se crea un objeto, al que se le van añadiendo las cadenas con el método append. Lógicamente esto también tiene un coste computacional, pero éste es inferior al que supone crear un nuevo objeto. De todos modos podemos reservar un espacio inicial de forma que no sea necesario hacerlo en cada iteración del bucle, mejorando aún más el rendimiento.

// creamos espacio para 120 caracteres
StringBuffer cadena = new StringBuffer(120);
// procedemos como antes
cadena.append("Cuenta: ");
for (int i=0; i<100; i++) {
   cadena.append(" " + i + " ");
}
// cadena = "Cuenta: 1 2 3 4 5 ... 99"

Cuándo usar uno y cuándo usar otro

En definitiva:

  • Si el texto no va a cambiar, utilizar String.
  • Si va a cambiar, y la aplicación va a tener un solo hilo de ejecución, utilizar StringBuilder.
  • Si el texto cambia durante la ejecución, y la aplicación que accede a él es multi-thread, utilizaremos StringBuffer.

Basado en StringBuffer and StringBuilder.

Written by adrian

11 febrero, 2008 a 11:56

Publicado en Posts

Tagged with

9 comentarios

Subscribe to comments with RSS.

  1. Holas. buscando novedades de java especificamente de la version 6 encontre este blog me parecio interesante el tema de string stringBuffer, bueno recien me entero de la existencia de la clase StringBuilder mas aun si esta desde la version 5, espero que pongas mas novedades de lo nuevo en las versiones 5 y 6 de JAVA, bueno yo he programado y programo aun en la version 1.4 del JDK, por ello mi sorpresa. gracias bye

    javierfiis

    3 mayo, 2008 at 03:55

  2. Quisiera saber como tu implantaste el metodo de append.

    Es que tengo que hacer un programa utilizando un append y se usarlo pero no se hacerlo.

    a ver si me podrias ayudar…..

    mil gracias

    Carlos

    20 octubre, 2008 at 07:00

  3. Mucho mejor si lo hacemos así (evitamos la creación de dos objetos intermedios inútiles ya que la concatenación se resuelve en tiempo de ejecución):

    [java]
    StringBuffer cadena = new StringBuffer(”Cuenta: “);
    for (int i=0; i<100; i++) {
    cadena.append(” “).append(i).append(” “);
    }
    // cadena = “Cuenta: 1 2 3 4 5 … 99”
    [/java]

    Antonio

    16 marzo, 2009 at 12:00

  4. @Antonio efectivamente, gracias por el comentario😉

    adrian

    16 marzo, 2009 at 12:03

  5. […] mucho que el compilador optimice este código (reemplazando las concatenaciones de cadenas usando StringBuilder), si se ejecuta muchas veces repetidamente sin necesidad (porque la aplicación está desplegada en […]

    Logging con SLF4J « AOWS

    13 febrero, 2010 at 01:17

  6. muy bien explicado, sin trabas ni rellenos! me ha servido de mucho, gracias.

    evan

    4 mayo, 2010 at 18:55

  7. Me ayudo, gracias por el trabajo.

    Azemur

    28 septiembre, 2011 at 19:51

  8. Muy útil y bien explicado, gracias!

    Sergi

    27 enero, 2012 at 12:55

  9. Que genial, recién me entero de este método. me sera de gran utilidad de aqui en adelente

    Marlon

    29 julio, 2014 at 20:33


Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: