Método Append() en Java: StringBuilder y StringBuffer

append() es un método Java de las clases StringBuilder y StringBuffer que agrega algún valor a una secuencia actual. Incluso si no sabía qué es el método append() , probablemente ya lo haya usado implícitamente. Esto sucedió cuando concatenó cadenas en Java usando el operador +. El punto es que la concatenación de cadenas en Java se implementa usando la clase StringBuilder o StringBuffer y su método append() .

Muy brevemente sobre String, StringBuffer y StringBuilder

Como probablemente sepa, la clase String es definitiva (no tiene clases secundarias) e inmutable (las instancias de esta clase no se pueden modificar después de la creación). De hecho, debido a la inmutabilidad de la clase String, se crean nuevas instancias de cadenas como resultado de cada operación y las antiguas se descartan, lo que genera mucha basura. Para lidiar con la generación de basura temporal debido a modificaciones en el objeto String, puede usar las clases StringBuffer o StringBuilder. La principal diferencia entre los dos últimos es que StringBuffer está sincronizado mientras que StringBuilder no. Por lo tanto, utilice StringBuffer para las cadenas que se modificarán con frecuencia en un entorno de subprocesos múltiples y StringBuilder en el caso de un entorno de un solo subproceso.

Agregar () en StringBuilder y StringBuffer

append() es uno de los mejores métodos de las clases StringBuilder y StringBuffer. Agrega un nuevo valor a la secuencia actual. Hay 13 métodos append() sobrecargados en las clases StringBuffer y StringBuilder. Veamos el método de agregar para StringBuilder. De todos modos, funcionan exactamente igual en el caso de StringBuffer.

• apéndice público de StringBuilder (booleano b)
• apéndice público de StringBuilder (char c)
• apéndice público de StringBuilder (char[] str)
• public StringBuilder append(char[] str, int offset, int len)
• apéndice público de StringBuilder (CharSequence cs)
• apéndice público de StringBuilder (CharSequence cs, int start, int end)
• apéndice público de StringBuilder (doble d)
• anexo public StringBuilder (float f)
• apéndice público de StringBuilder (int i)
• apéndice público de StringBuilder (largo largo)
• apéndice público de StringBuilder (Objeto obj)
• anexo público de StringBuilder (String str)
• apéndice público de StringBuilder (StringBuffer sb)

Repasemos algunos de ellos y expliquemos con ejemplos qué hace exactamente el método append() .

Java.lang.StringBuilder.append(int i)

java.lang.StringBuilder.append(int i) es un método que permite agregar un número entero a un objeto StringBuilder existente. Echemos un vistazo a los ejemplos del uso de Java.lang.StringBuilder.append(int i) :

StringBuilder s = new StringBuilder(“I love Java ”);  
int i = 14;
//the method appends StringBuilder and integer   
s.append(i); 
System.out.println(s); 

La salida aquí será: ¿Que pasó aquí? Primero, creamos un StringBuilder llamado s con el valor "Me encanta Java". Luego le agregó un número entero 14 usando append(int) . Estrictamente hablando, no agregamos un número entero, sino la cadena "14" y obtuvimos un valor de StringBuilder actualizado a "Me encanta Java 14". Por lo tanto, el método convierte el argumento en un objeto StringBuilder, lo vincula a un objeto StringBuilder existente y devuelve uno actualizado.

Ejemplo de StringBuilder append() para objeto, int, booleano y argumento de cadena

La misma historia ocurrirá con todos los demás métodos sobrecargados con elementos numéricos, de cadena, de caracteres o de matrices. Vamos a crear una enumeración LegoBrick Class and Color para demostrar el método público StringBuilder append(Object obj) .

//enum with colors 
 public enum Color {
   RED, YELLOW, BLUE;
}
//LegoBrick Class code 
public class LegoBrick {
   Color color;
   boolean isConnected;

   public void connect() {
       System.out.println("This brick is connected");
       this.isConnected = true;
   }

   public void disconnect() {
       System.out.println("Disconnected");
       isConnected = false;
   }

   public LegoBrick(Color color, boolean isConnected) {
       this.color = color;
       this.isConnected = isConnected;
   }

   public Color getColor() {
       return color;
   }

   public boolean isConnected() {
       return isConnected;
   }

   @Override
   public String toString() {
       return "LegoBrick{" +
              "color=" + color +
              ", isConnected=" + isConnected +
              '}';
   }
}

Ahora vamos a crear una clase AppendDemo donde mostraremos la adición de un StringBuilder básico con String, int, LegoBrick y boolean. Suena raro, ¡pero funciona!

public class AppendDemo {

   public static void main(String[] args) {
       StringBuilder s = new StringBuilder("I love");
System.out.println(s)
//the method appends StringBuilder and String
       s.append(" Java");
       System.out.println(s);
//the method appends StringBuilder and int
       s.append(14);
       System.out.println(s);
       LegoBrick legoBrick = new LegoBrick(Color.RED, false);
//the method appends StringBuilder and LegoBrick 
       s.append(legoBrick);
       System.out.println(s);
//the method appends StringBuilder and boolean
       System.out.println(s.append(5<7));
   }
}

La salida es: Primero, creamos y mostramos StringBuilder "Me encanta", luego Primero, lo agregamos secuencialmente usando el método append () una Cadena, un número int, una representación de Cadena de un Objeto y un valor booleano.

StringBuilder append(char[] cstr, int set, int length)

Veamos el método append() con tres parámetros. Agrega una representación de un subarreglo de un arreglo de caracteres dado a la cadena. Así que aquí:

• cstr es una matriz de caracteres que se agregarán
• configúrelo como el índice del primer carácter que se agregará
• longitud es la cantidad de caracteres a añadir.

De manera similar a otros métodos append() , este devuelve un objeto StringBuilder expandido. Este es un ejemplo del uso de append(char[], cstr, int set, int length) como parte del código de la aplicación Java.

public class AppendDemo {
   // an example of using append(char[], cStr, int set, int length)

   public static void main(String[] args) {
       StringBuilder s = new StringBuilder("I love ");
      //here is a char's array, part of which we are going to append to s
       char[] cStr = new char[]
               {'c', 'o', 'd', 'e', 'J', 'a', 'v', 'a', '1', '4'};
       //we append 4 elements of cStr from the 4th element "J"
       s.append(cStr, 4, 4);
       System.out.println(s);
   }
}

La salida es:

Métodos append() de StringBuilder con argumento CharSequence

Es posible que haya notado dos métodos que tienen CharSequence como argumentos.

• apéndice público de StringBuilder (CharSequence cs)
• apéndice público de StringBuilder (CharSequence cs, int start, int end)

No todos los principiantes saben que CharSequence es una interfaz. De acuerdo con la documentación, CharSequence es una secuencia legible de valores char y proporciona acceso uniforme de solo lectura a muchos tipos diferentes de secuencias char. La interfaz se implementa mediante clases Java como String, StringBuffer, StringBuilder y más. Entonces, si no sabe qué es mejor usar en su programa, String, StringBuffer o StringBuilder, puede usar CharSequence. StringBuilder append (CharSequence cs, int start, int end) funciona casi como append (char[] cstr, int set, int length)discutimos arriba. Sin embargo, este método especifica el primer elemento de la subsecuencia y el último. Es importante recordar que el inicio está incluido en la subsecuencia, pero el final no (es decir, el último elemento de la subsecuencia es el elemento que precede al final). ¿Porqué es eso? Es solo la forma en que está en Java. Demostremos qué es CharSequence y los métodos append(CharSequence cs) y append(CharSequence cs, int start, int end) .

public class CharSequenceDemo {

   public static void printCharSequence(CharSequence ch) {
       System.out.println(ch);
   }
       public static void main(String[] args) {
           CharSequence myString = new String("This is String ");
           printCharSequence(myString);
           CharSequence myStringBuilder = new StringBuilder("This is StringBuilder ");
           printCharSequence(myStringBuilder);
           StringBuilder s = new StringBuilder("my StringBuilder ");
//StringBuilder.append           
s.append(myStringBuilder);
           System.out.println(s);
//StringBuilder.append
           s.append(myString);
           System.out.println(s);
           s.append(myString, 5,7);
           System.out.println(s);
       }
   }

La salida es: Creamos dos CharSequences, les vinculamos String y StringBuilder y los imprimimos. No podemos aplicar el método append() directamente a myStringBuilder, ya que CharSequence no tiene este método (si no entiende por qué, debe averiguar acerca de la herencia, así como la expansión y reducción de los tipos de referencia). Por lo tanto, creamos un StringBuilder con y concatenamos usando el método de agregar secuencialmente con ambos CharSequence. Al final, agregamos nuestro StringBuilder con la subsecuencia "es" ("i" es un quinto elemento de myStringBuilder y s es el sexto. Recuerde que en el método, el elemento especificado como final se excluye de la subsecuencia.

¿Qué pasa con StringBuffer append ()?

StringBuffer.append también tiene 13 variantes del método y funcionan exactamente de la misma manera que StringBuilder.

• anexo public StringBuffer (booleano b)
• anexo public StringBuffer (char c)
• anexo de StringBuffer público (char[] str)
• anexo de StringBuffer público (char[] str, int offset, int len)
• anexo public StringBuffer (doble d)
• anexo public StringBuffer (float f)
• apéndice de StringBuffer público (int i)
• anexo de StringBuffer público (largo largo)
• apéndice de StringBuffer público (CharSequence s)
• anexo public StringBuffer (CharSequence s, int start, int end)
• anexo public StringBuffer (Objeto obj)
• anexo public StringBuffer (String str)
• apéndice público de StringBuffer (StringBuffer sb)

Veamos un ejemplo de StringBuffer.append para unir una subcadena. Simplemente tomamos el ejemplo de StringBuilder y cambiamos todos los StringBuilders en el código a StringBuffers.

public class AppendDemo {
   // an example of using append(char[], cStr, int set, int length)

   public static void main(String[] args) {
       StringBuffer s = new StringBuffer("I love ");
      //here is a char's array, part of which we are going to append to s
       char[] cStr = new char[]
               {'c', 'o', 'd', 'e', 'J', 'a', 'v', 'a', '1', '4'};
       //we append 4 elements of cStr from the 4th element "J"
//with StringBuffer.append
       s.append(cStr, 4, 4);
       System.out.println(s);
//StringBuffer.append adds int 14 to s
s.append(14); 
System.out.println(s);
   }
}

La salida es: Puedes hacerlo con cada ejemplo de este artículo. ¡Van a trabajar!

Conclusión

Dado que StringBuilder y StringBuffer comparten la mayoría de las funciones, no sorprende que ambas clases tengan formas similares de usar el método append() . Esas son buenas noticias para los desarrolladores: no es necesario que aprenda métodos separados para cada clase. Habiendo dicho eso, considerando la variedad de formas de usar append() , asegúrese de dedicar algunas horas a la práctica para agregar las representaciones de diferentes tipos de datos a una cadena.