Método Append() em Java: StringBuilder e StringBuffer

append() é um método Java das classes StringBuilder e StringBuffer que acrescenta algum valor a uma sequência atual. Mesmo que você não saiba o que é o método append() , provavelmente já o usou implicitamente. Isso aconteceu quando você concatenou Strings em Java usando o operador +. O ponto é que a concatenação de String em Java é implementada usando a classe StringBuilder ou StringBuffer e seu método append() .

Muito Resumidamente sobre String, StringBuffer e StringBuilder

Como você provavelmente sabe, a classe String é final (não possui classes filhas) e imutável (as instâncias desta classe não podem ser modificadas após a criação). Na verdade, devido à imutabilidade da classe String, novas instâncias de string são criadas como resultado de cada operação, e as antigas são descartadas, gerando muito lixo. Para lidar com a geração de lixo temporário devido a modificações no objeto String, você pode usar as classes StringBuffer ou StringBuilder. A principal diferença entre os dois últimos é que StringBuffer é sincronizado enquanto StringBuilder não é. Portanto, use StringBuffer para strings que serão modificadas com frequência em um ambiente multiencadeado e StringBuilder no caso de um ambiente de encadeamento único. Método Append() em Java: StringBuilder e StringBuffer - 1

Método Append() em Java: StringBuilder e StringBuffer - 1

Append() em StringBuilder e StringBuffer

append() é um dos principais métodos das classes StringBuilder e StringBuffer. Acrescenta um novo valor à sequência atual. Existem 13 métodos append() sobrecarregados nas classes StringBuffer e StringBuilder. Vejamos o método append para StringBuilder. De qualquer forma, eles funcionam exatamente da mesma forma no caso do StringBuffer.

public StringBuilder append(boolean b)

public StringBuilder append(char c)

public StringBuilder append(char[] str)

public StringBuilder append(char[] str, int offset, int len)

public StringBuilder append(CharSequence cs)

public StringBuilder append(CharSequence cs, int start, int end)

public StringBuilder append(double d)

public StringBuilder append(float f)

public StringBuilder append(int i)

public StringBuilder append(long lng)

public StringBuilder append(Object obj)

public StringBuilder append(String str)

public StringBuilder append(StringBuffer sb)

Vamos examinar alguns deles e explicar com exemplos o que exatamente o método append() faz.

Java.lang.StringBuilder.append(int i)

java.lang.StringBuilder.append(int i) é um método que permite anexar um inteiro a um objeto StringBuilder existente. Vamos dar uma olhada nos exemplos de 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);

A saída aqui será:

Eu amo o Java 14

O que aconteceu aqui? Primeiro, criamos um StringBuilder chamado s com o valor "I love Java". Em seguida, adicione a ele um inteiro 14 usando append(int) . Estritamente falando, adicionamos não um número inteiro, mas a string "14" e obtivemos um valor StringBuilder atualizado para "I love Java 14". Assim, o método transforma o argumento em um objeto StringBuilder, vincula-o a um objeto StringBuilder existente e retorna um objeto atualizado.

StringBuilder append() exemplo para Object, int, boolean e argumento String

A mesma história será com todos os outros métodos sobrecarregados com elementos number, string, char ou arrays. Vamos criar uma classe LegoBrick e uma enumeração de cores para demonstrar o 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 +
              '}';
   }
}

Agora vamos criar uma Classe AppendDemo onde mostraremos a anexação de um StringBuilder básico com String, int, LegoBrick e boolean. Parece estranho, mas 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));
   }
}

A saída é:

Eu amo Eu amo Java Eu amo Java14 Eu amo Java14LegoBrick{color=RED, isConnected=false} Eu amo Java14LegoBrick{color=RED, isConnected=false}true

Primeiro, criamos e exibimos o StringBuilder "I love", depois First, então adicionamos sequencialmente a ele usando o método append() uma String, um número int, uma representação String de um Objeto e um booleano.

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

Vejamos o método append() com três parâmetros. Ele adiciona uma representação de um subarray de um determinado array de caracteres à string. Então aqui:

cstr é uma matriz de caracteres a serem anexados
defina o índice do primeiro caractere a ser anexado
comprimento é a quantidade de caracteres a serem anexados.

Da mesma forma que outros métodos append() , este retorna um objeto StringBuilder expandido. Aqui está um exemplo de uso de append(char[], cstr, int set, int length) como parte do código do aplicativo 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);
   }
}

A saída é:

eu amo java

StringBuilder append () métodos com argumento CharSequence

Você deve ter notado dois métodos que possuem CharSequence como seus argumentos.

public StringBuilder append(CharSequence cs)

public StringBuilder append(CharSequence cs, int start, int end)

Nem todos os iniciantes sabem que CharSequence é uma interface. De acordo com a documentação , CharSequence é uma sequência legível de valores de caracteres e fornece acesso uniforme e somente leitura a muitos tipos diferentes de sequências de caracteres. A interface é implementada por classes Java como String, StringBuffer, StringBuilder e muito mais. Então se você não sabe o que é melhor usar em seu programa, String, StringBuffer ou StringBuilder você pode usar CharSequence. StringBuilder append(CharSequence cs, int start, int end) funciona quase como append(char[] cstr, int set, int length)discutimos acima. No entanto, esse método especifica o primeiro elemento da subsequência e o último. É importante lembrar que o início está incluído na subsequência, mas o fim não (ou seja, o último elemento na subsequência é o elemento que vem antes do fim). Por que é que? É assim que é em Java. Vamos demonstrar o que é CharSequence e os métodos append(CharSequence cs) e 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);
       }
   }

A saída é:

Este é String Este é StringBuilder meu StringBuilder Este é StringBuilder meu StringBuilder Este é StringBuilder Este é String meu StringBuilder Este é StringBuilder Este é String é

Criamos duas CharSequences, vinculamos String e StringBuilder a elas e as imprimimos. Não podemos aplicar o método append() diretamente em myStringBuilder, pois CharSequence não possui esse método (se você não entender o porquê, precisará descobrir sobre herança, bem como expandir e restringir tipos de referência). Portanto, criamos um StringBuilder com e concatenamos usando o método append sequencialmente com CharSequence. No final, anexamos nosso StringBuilder com a subsequência “is” (“i” é o 5º elemento de myStringBuilder e s é o 6º. Lembre-se que no método, o elemento especificado como end é excluído da subsequência.

E quanto ao StringBuffer append ()?

StringBuffer.append também possui 13 variantes do método e funcionam exatamente da mesma forma que StringBuilder.

public StringBuffer append(boolean b)

public StringBuffer append(char c)

public StringBuffer append(char[] str)

public StringBuffer append(char[] str, int offset, int len)

public StringBuffer append(d duplo)

public StringBuffer append(float f)

public StringBuffer append(int i)

public StringBuffer append(long lng)

public StringBuffer append(CharSequence s)

public StringBuffer append(CharSequence s, int start, int end)

public StringBuffer append(Object obj)

public StringBuffer append(String str)

public StringBuffer append(StringBuffer sb)

Vamos dar um exemplo de StringBuffer.append para juntar uma substring. Apenas pegamos o exemplo StringBuilder e alteramos todos os StringBuilders no código para 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);
   }
}

A saída é:

Eu amo Java Eu amo Java14

Você pode fazer isso com todos os exemplos deste artigo. Eles vão trabalhar!

Conclusão

Como StringBuilder e StringBuffer compartilham a maioria das funções, não é surpresa que ambas as classes tenham maneiras semelhantes de usar o método append() . Isso é uma boa notícia para os desenvolvedores — você não precisa aprender métodos separados para cada classe. Tendo dito isso, considerando a variedade de maneiras de usar append() , certifique-se de colocar algumas horas de prática adicionando as representações de diferentes tipos de dados a uma string.