Metoda append() w Javie: StringBuilder i StringBuffer

append() jest metodą Javy w klasach StringBuilder i StringBuffer, która dodaje pewną wartość do istniejącego ciągu. Nawet jeśli nie wiedziałeś, czym jest metoda append(), prawdopodobnie już jej nieświadomie użyłeś. Dzieje się tak, gdy łączysz ciągi znaków w Javie za pomocą operatora +. Chodzi o to, że łączenie ciągów w Javie jest zaimplementowane przy użyciu klas StringBuilder lub StringBuffer i ich metod append().

Kilka słów o klasach String, StringBuffer i StringBuilder

Jak zapewne wiesz, klasa String jest ostateczna (nie posiada klas potomnych) i niezmienna (instancje tej klasy nie mogą być modyfikowane po utworzeniu). W rzeczywistości niezmienność klasy String oznacza, że w wyniku każdej operacji tworzone są nowe obiekty String, a stare są odrzucane. Wszystko to generuje mnóstwo śmieci. Aby poradzić sobie z problemem generowania tymczasowych nieużytków podczas modyfikacji obiektu String, można użyć klas StringBuffer lub StringBuilder. Główną różnicą między nimi jest to, że StringBuffer jest synchronizowany, a StringBuilder nie. W związku z tym używaj StringBuffer dla ciągów, które będą często modyfikowane w środowisku wielowątkowym, a StringBuilder w środowisku jednowątkowym.

append() w StringBuilder i StringBuffer (Java append)

append() jest jedną z najważniejszych metod klas StringBuilder i StringBuffer. Java string append oznacza więc dołączenie nowej wartości do bieżącego ciągu. Istnieje 13 różnych przeciążonych metod append() w klasach StringBuffer i StringBuilder. Przyjrzyjmy się metodzie StringBuilder append. Tak czy inaczej, metody działają dokładnie tak samo w przypadku 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)

Przyjrzyjmy się niektórym z nich i użyjmy przykładów, aby wyjaśnić, co dokładnie robi metoda append().

Java.lang.StringBuilder.append(int i)

java.lang.StringBuilder.append(int i) jest metodą umożliwiającą dołączanie liczby całkowitej do istniejącego obiektu StringBuilder. Spójrzmy na przykłady użycia 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); 

Wynikiem będzie: Co się tutaj stało? Najpierw utworzyliśmy StringBuilder o nazwie s z wartością „Uwielbiam Javę”. Następnie dodaliśmy do niego liczbę całkowitą 14 za pomocą append(int). Cóż, ściśle rzecz biorąc, nie dodaliśmy liczby całkowitej. W rzeczywistości dodaliśmy ciąg „14” i otrzymaliśmy zaktualizowany StringBuilder z wartością „Uwielbiam Javę 14”. Metoda zamienia więc argument na obiekt StringBuilder, powiązuje go z istniejącym obiektem StringBuilder i zwraca obiekt zaktualizowany.

Przykład StringBuilder.append() dla argumentów Object, int, boolean i String

Historia jest taka sama dla wszystkich innych przeciążonych metod zawierających liczby, ciągi, znaki czy tablice. Utwórzmy klasę LegoBrick i enum Color, aby zademonstrować publiczną metodę 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 +
              '}';
   }
}

Teraz utwórzmy klasę AppendDemo, której użyjemy do zademonstrowania dołączania podstawowego obiektu StringBuilder do obiektu typu String, int, LegoBrick i boolean. Brzmi dziwnie, ale działa!

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

Wydrukiem będzie: Najpierw utworzyliśmy i wyświetliliśmy StringBuilder z wartością „Uwielbiam”. Następnie użyliśmy metody append(), aby kolejno dodać String, int i reprezentację obiektu i boolean w formie ciągu.

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

Przyjrzyjmy się metodzie append() z trzema parametrami. Dodaje ciąg reprezentujący podzbiór danej tablicy znaków do ciągu. W tym przypadku:

• cstr to tablica znaków do dołączenia
• set to indeks pierwszego znaku do dołączenia
• length to liczba znaków do dołączenia.

Podobnie jak inne metody append(), zwraca ona rozszerzony obiekt StringBuilder. Oto przykład użycia append(char[], cstr, int set, int length) jako część kodu aplikacji 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);
   }
}

Wydrukiem będzie:

Metody StringBuilder append() z argumentem CharSequence

Być może zauważyłeś dwie metody, które mają CharSequence jako argumenty.

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

Nie każdy początkujący wie, że CharSequence to interfejs. Zgodnie z dokumentacją CharSequence jest czytelną sekwencją wartości char i zapewnia jednolity, tylko do odczytu dostęp do wielu różnych rodzajów sekwencji char. Interfejs ten jest implementowany przez takie klasy Javy jak String, StringBuffer, StringBuilder i inne. Jeżeli więc nie wiesz, czy w twoim programie lepiej użyć String, StringBuffer, czy StringBuilder, możesz użyć CharSequence. StringBuilder append(CharSequence cs, int start, int end) działa prawie jak metoda append(char[] cstr, int set, int length), o której mówiliśmy powyżej. Jednak ta metoda przyjmuje pierwszy element podciągu i ostatni. Należy pamiętać, że indeks początkowy zawarty jest w podciągu, ale nie zawiera indeksu końcowego (innymi słowy ostatni element w podciągu to element znajdujący się przed indeksem końcowym). Dlaczego? Po prostu tak to już jest w Javie. Zademonstrujmy więc, czym jest CharSequence wraz z metodami append(CharSequence cs) i 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);
       }
   }

Wydrukiem będzie: Stworzyliśmy dwa CharSequences, powiązaliśmy z nimi String i StringBuilder, a następnie wszystko to wydrukowaliśmy. Nie możemy zastosować metody append() bezpośrednio na myStringBuilder, ponieważ CharSequence nie posiada tej metody (jeśli nie rozumiesz dlaczego, to musisz zagłębić się zarówno w dziedziczenie, jak i rozszerzanie i zawężanie typów referencyjnych). W związku z tym tworzymy StringBuilder i używamy metody append do sekwencyjnego łączenia obu CharSequences. Na koniec dodaliśmy podciąg „jest” do naszego StringBuildera: „j” to trzeci element myStringBuilder, „e” to element czwarty itd. Pamiętaj, że metoda wyklucza element określony przez indeks końcowy.

A co ze StringBuffer.append()?

Metoda The StringBuffer.append również ma 13 wariantów i działają one dokładnie tak samo, jak 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 (double 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 (Object obj)
• public StringBuffer append (String str)
• public StringBuffer append (StringBuffer sb)

Spójrzmy na przykład użycia StringBuffer.append do połączenia podciągu. Rozpatrzymy przykład StringBuilder i zmienimy wszystkie StringBuildery w kodzie na StringBuffery.

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

Wydrukiem będzie: Możesz to zrobić z każdym przykładem w tym artykule. Zadziałają!

Wniosek

Ponieważ StringBuilder i StringBuffer mają większość funkcji taką samą, nie jest niespodzianką, że obie klasy oferują podobne sposoby użycia metody append(). To dobra wiadomość dla programistów - nie trzeba uczyć się osobnych metod dla każdej klasy. Biorąc pod uwagę różnorodność sposobów używania append(), upewnij się, że poświęcisz kilka godzin na ćwiczenie dołączania reprezentacji ciągów różnych typów danych do ciągu.