Java Language
StringBuilder

Introducción

Sintaxis

• nuevo StringBuilder ()

• nuevo StringBuilder (capacidad int)

• nuevo StringBuilder (CharSequence seq)

• Nuevo StringBuilder (constructor StringBuilder)

• nuevo StringBuilder (cadena de cadena)

• Nuevo StringJoiner (delimitador de CharSequence)

• Nuevo StringJoiner (delimitador de CharSequence, prefijo de CharSequence, sufijo de CharSequence)

Observaciones

 StringBuilder v = new StringBuilder('I'); //'I' is a character, "I" is a String.
 System.out.println(v.capacity()); --> output 73
 System.out.println(v.toString()); --> output nothing

Repetir una cadena n veces

Problema: Cree una String contenga n repeticiones de una String s .

El enfoque trivial consistiría repetidamente en concatenar la String

final int n = ...
final String s = ...
String result = "";

for (int i = 0; i < n; i++) {
    result += s;
}

Esto crea n nuevas instancias de cadena que contienen de 1 a n repeticiones de s resultan en un tiempo de ejecución de O(s.length() * n²) = O(s.length() * (1+2+...+(n-1)+n)) .

Para evitar esto, debe utilizarse StringBuilder , que permite crear la String en O(s.length() * n) lugar:

final int n = ...
final String s = ...

StringBuilder builder = new StringBuilder();

for (int i = 0; i < n; i++) {
    builder.append(s);
}

String result = builder.toString();

Comparando StringBuffer, StringBuilder, Formatter y StringJoiner

Las clases StringBuffer , StringBuilder , Formatter y StringJoiner son clases de utilidad de Java SE que se usan principalmente para ensamblar cadenas a partir de otra información:

• La clase StringBuffer ha estado presente desde Java 1.0 y proporciona una variedad de métodos para construir y modificar un "búfer" que contiene una secuencia de caracteres.

• La clase StringBuilder se agregó en Java 5 para abordar los problemas de rendimiento con la clase StringBuffer original. Las API para las dos clases son esencialmente las mismas. La principal diferencia entre StringBuffer y StringBuilder es que el primero es seguro para subprocesos y está sincronizado y el segundo no.

Este ejemplo muestra cómo se puede usar StringBuilder :

int one = 1;
String color = "red";
StringBuilder sb = new StringBuilder();
sb.append("One=").append(one).append(", Color=").append(color).append('\n');
System.out.print(sb);
// Prints "One=1, Colour=red" followed by an ASCII newline.

(La clase StringBuffer se usa de la misma manera: simplemente cambie StringBuilder a StringBuffer en la parte superior)

Las clases StringBuffer y StringBuilder son adecuadas tanto para ensamblar como para modificar cadenas; es decir, proporcionan métodos para reemplazar y eliminar caracteres, así como agregarlos en varios. Las dos clases de remisión son específicas a la tarea de ensamblar cadenas.

• La clase Formatter se agregó en Java 5 y está modelada de manera flexible en la función sprintf en la biblioteca estándar de C. Toma una cadena de formato con especificadores de formato incrustados y una secuencia de otros argumentos, y genera una cadena convirtiendo los argumentos en texto y sustituyéndolos en lugar de los especificadores de formato. Los detalles de los especificadores de formato dicen cómo los argumentos se convierten en texto.

• La clase StringJoiner se agregó en Java 8. Es un formateador de propósito especial que formatea sucintamente una secuencia de cadenas con separadores entre ellas. Está diseñado con una API fluida y puede usarse con flujos de Java 8.

Aquí hay algunos ejemplos típicos de uso del Formatter :

// This does the same thing as the StringBuilder example above
int one = 1;
String color = "red";
Formatter f = new Formatter();
System.out.print(f.format("One=%d, colour=%s%n", one, color));
// Prints "One=1, Colour=red" followed by the platform's line separator

// The same thing using the `String.format` convenience method
System.out.print(String.format("One=%d, color=%s%n", one, color));

La clase StringJoiner no es ideal para la tarea anterior, por lo que aquí hay un ejemplo de StringJoiner formatear una matriz de cadenas.

StringJoiner sj = new StringJoiner(", ", "[", "]");
for (String s : new String[]{"A", "B", "C"}) {
    sj.add(s);
}
System.out.println(sj);
// Prints "[A, B, C]"

Los casos de uso para las 4 clases se pueden resumir:

• StringBuilder adecuado para cualquier montaje de cadena O tarea de modificación de cadena.
• Utilice StringBuffer (solo) cuando necesite una versión segura de subprocesos de StringBuilder .
• Formatter proporciona una funcionalidad de formato de cadena mucho más rica, pero no es tan eficiente como StringBuilder . Esto se debe a que cada llamada a Formatter.format(...) implica:
  • analizando la cadena de format ,
  • creando y rellenando una matriz de varargs , y
  • Autoboxing cualquier tipo de argumentos primitivos.
• StringJoiner proporciona un formateo StringJoiner y eficiente de una secuencia de cadenas con separadores, pero no es adecuado para otras tareas de formateo.