Metodo Append() in Java: StringBuilder e StringBuffer

append() è un metodo Java delle classi StringBuilder e StringBuffer che aggiunge un valore a una sequenza corrente. Anche se non sapevi cosa sia il metodo append() , probabilmente lo hai già usato implicitamente. Questo è successo quando hai concatenato le stringhe in Java usando l'operatore +. Il punto è che la concatenazione di stringhe in Java è implementata utilizzando la classe StringBuilder o StringBuffer e il loro metodo append() .

Molto brevemente su String, StringBuffer e StringBuilder

Come probabilmente saprai, la classe String è definitiva (non ha classi figlie) e immutabile (le istanze di questa classe non possono essere modificate dopo la creazione). Infatti, a causa dell'immutabilità della classe String, vengono create nuove istanze di stringa come risultato di ogni operazione e quelle vecchie vengono scartate, generando molta spazzatura. Per gestire la generazione di spazzatura temporanea dovuta a modifiche all'oggetto String, è possibile utilizzare le classi StringBuffer o StringBuilder. La differenza principale tra gli ultimi due è che StringBuffer è sincronizzato mentre StringBuilder no. Quindi, usa StringBuffer per le stringhe che verranno modificate frequentemente in un ambiente multi-thread e StringBuilder in caso di un ambiente a thread singolo.

Append() in StringBuilder e StringBuffer

append() è uno dei migliori metodi delle classi StringBuilder e StringBuffer. Aggiunge un nuovo valore alla sequenza corrente. Ci sono 13 diversi metodi append() sovraccaricati in entrambe le classi StringBuffer e StringBuilder. Diamo un'occhiata al metodo append per StringBuilder. Ad ogni modo, funzionano esattamente allo stesso modo in caso di StringBuffer.

• public StringBuilder append(booleano 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(doppia d)
• public StringBuilder append(float f)
• public StringBuilder append(int i)
• public StringBuilder append(long lng)
• public StringBuilder append(Oggetto obj)
• public StringBuilder append(String str)
• public StringBuilder append(StringBuffer sb)

Esaminiamone alcuni e spieghiamo con esempi cosa fa esattamente il metodo append() .

Java.lang.StringBuilder.append(int i)

java.lang.StringBuilder.append(int i) è un metodo che consente di aggiungere un numero intero a un oggetto StringBuilder esistente. Diamo un'occhiata agli esempi di utilizzo di 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);

L'output qui sarà: Cos'è successo qua? Innanzitutto, abbiamo creato uno StringBuilder denominato s con il valore "I love Java". Quindi aggiunto ad esso un numero intero 14 usando append(int) . A rigor di termini, non abbiamo aggiunto un numero intero, ma la stringa "14" e ottenuto un valore StringBuilder aggiornato a "I love Java 14". Pertanto, il metodo trasforma l'argomento in un oggetto StringBuilder, lo associa a un oggetto StringBuilder esistente e ne restituisce uno aggiornato.

StringBuilder append() esempio per Object, int, boolean e argomento String

La stessa storia sarà con tutti gli altri metodi sovraccaricati con elementi number, string, char o array. Creiamo una LegoBrick Class e Color enum per dimostrare il metodo pubblico 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 +
              '}';
   }
}

Ora creiamo una classe AppendDemo in cui mostreremo l'aggiunta di uno StringBuilder di base con String, int, LegoBrick e boolean. Sembra strano, ma funziona!

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));
   }
}

L'uscita è: Innanzitutto, abbiamo creato e visualizzato StringBuilder "I love", quindi First, quindi aggiunto in sequenza ad esso utilizzando il metodo append() una stringa, un numero int, una rappresentazione String di un oggetto e un valore booleano.

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

Diamo un'occhiata al metodo append() con tre parametri. Aggiunge alla stringa una rappresentazione di un sottoarray di un dato array di caratteri. Ecco:

• cstr è un array di caratteri da aggiungere
• impostalo come indice del primo carattere da aggiungere
• length è la quantità di caratteri da aggiungere.

Analogamente ad altri metodi append() , questo restituisce un oggetto StringBuilder espanso. Ecco un esempio di utilizzo di append(char[], cstr, int set, int length) come parte del codice dell'app 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);
   }
}

L'uscita è:

Metodi StringBuilder append() con argomento CharSequence

Potresti aver notato due metodi che hanno CharSequence come argomenti.

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

Non tutti i principianti sanno che CharSequence è un'interfaccia. Secondo la documentazione , CharSequence è una sequenza leggibile di valori char e fornisce un accesso uniforme e di sola lettura a molti diversi tipi di sequenze di caratteri. L'interfaccia è implementata da classi Java come String, StringBuffer, StringBuilder e altre. Quindi se non sai cosa è meglio usare nel tuo programma, String, StringBuffer o StringBuilder puoi usare CharSequence. StringBuilder append(CharSequence cs, int start, int end) funziona quasi come append(char[] cstr, int set, int length)abbiamo discusso sopra. Tuttavia, questo metodo specifica il primo elemento della sottosequenza e l'ultimo. È importante ricordare che start è incluso nella sottosequenza, ma end non lo è (ovvero, l'ultimo elemento nella sottosequenza è l'elemento che viene prima di end). Perché? È proprio così che è in Java. Dimostriamo cos'è CharSequence e i metodi 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);
       }
   }

L'uscita è: Abbiamo creato due CharSequence, associato String e StringBuilder a loro e li abbiamo stampati. Non possiamo applicare il metodo append() direttamente a myStringBuilder, poiché CharSequence non ha questo metodo (se non capisci perché, devi capire l'ereditarietà così come l'espansione e il restringimento dei tipi di riferimento). Pertanto, creiamo uno StringBuilder con e lo concateniamo utilizzando il metodo append in sequenza con entrambi CharSequence. Alla fine abbiamo aggiunto al nostro StringBuilder la sottosequenza “is” (“i” è un quinto elemento di myStringBuilder e s è il sesto. Ricorda che nel metodo, l'elemento specificato come end è escluso dalla sottosequenza.

Che dire di StringBuffer append()?

StringBuffer.append ha anche 13 varianti del metodo e funzionano esattamente allo stesso modo di StringBuilder.

• public StringBuffer append​(booleano b)
• public StringBuffer append​(char c)
• public StringBuffer append​(char[] str)
• public StringBuffer append​(char[] str, int offset, int len)
• public StringBuffer append​(doppia d)
• 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​(oggetto obj)
• public StringBuffer append​(String str)
• public StringBuffer append​(StringBuffer sb)

Facciamo un esempio di StringBuffer.append per unire una sottostringa. Prendiamo semplicemente l'esempio di StringBuilder e cambiamo tutti gli StringBuilder nel codice in 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);
   }
}

L'uscita è: Puoi farlo con ogni esempio di questo articolo. Funzioneranno!

Conclusione

Poiché StringBuilder e StringBuffer condividono la maggior parte delle funzioni, non sorprende che entrambe le classi abbiano modi simili per utilizzare il metodo append() . Questa è una buona notizia per gli sviluppatori: non devi imparare metodi separati per ogni classe. Detto questo, considerando la varietà di modi per utilizzare append() , assicurati di fare qualche ora di pratica aggiungendo le rappresentazioni di diversi tipi di dati a una stringa.