Append() metódus Java-ban: StringBuilder és StringBuffer

Az append() a StringBuilder és StringBuffer osztályok Java metódusa, amely értéket fűz hozzá egy aktuális sorozathoz. Még ha nem is tudta, mi az append() metódus, valószínűleg implicit módon már használta. Ez akkor történt, amikor a stringeket Javaban a + operátorral fűzte össze. A lényeg az, hogy a String összefűzést a Java nyelvben a StringBuilder vagy StringBuffer osztály és az append() metódus segítségével valósítják meg .

Nagyon röviden a Stringről, a StringBufferről és a StringBuilderről

Amint azt valószínűleg tudod, a String osztály végleges (nincs gyermekosztálya) és megváltoztathatatlan (az osztály példányai nem módosíthatók a létrehozás után). Valójában a String osztály megváltoztathatatlansága miatt minden egyes művelet eredményeként új karakterlánc-példányok jönnek létre, a régieket pedig eldobják, sok szemetet generálva. A String objektum módosításai miatti ideiglenes szemét generálásához használhatja a StringBuffer vagy StringBuilder osztályokat. A fő különbség az utóbbi kettő között az, hogy a StringBuffer szinkronizált, míg a StringBuilder nem. Ezért használja a StringBuffer-t a többszálú környezetben gyakran módosítandó karakterláncokhoz, egyszálú környezetben pedig a StringBuilder-t.

Append() a StringBuilderben és a StringBufferben

Az append() a StringBuilder és StringBuffer osztályok egyik legnépszerűbb metódusa. Új értéket fűz az aktuális sorozathoz. Mind a StringBuffer, mind a StringBuilder osztályban 13 különböző túlterhelt append() metódus található . Nézzük meg a StringBuilder hozzáfűzési módszerét. Amúgy a StringBuffer esetében is pontosan ugyanúgy működnek.

• public StringBuilder append(boolean b)
• public StringBuilder append(char c)
• public StringBuilder append(char[] str)
• public StringBuilder append(char[] str, int offset, int len)
• nyilvános StringBuilder hozzáfűzés(CharSequence cs)
• public StringBuilder append(CharSequence cs, int kezdet, int vége)
• nyilvános StringBuilder hozzáfűzés(double d)
• public StringBuilder append(float f)
• public StringBuilder append(int i)
• nyilvános StringBuilder hozzáfűzés (hosszú lng)
• public StringBuilder hozzáfűzés(Object Obj)
• public StringBuilder hozzáfűzés(String str)
• public StringBuilder append(StringBuffer sb)

Nézzünk meg néhányat, és magyarázzuk el példákkal, hogy pontosan mit is csinál az append() metódus.

Java.lang.StringBuilder.append(int i)

A java.lang.StringBuilder.append(int i) egy olyan metódus, amely lehetővé teszi egész szám hozzáfűzését egy meglévő StringBuilder objektumhoz. Vessünk egy pillantást a Java.lang.StringBuilder.append(int i) használatára :

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

A kimenet itt a következő lesz: Mi történt itt? Először létrehoztunk egy s nevű StringBuilder-t "I love Java" értékkel. Ezután adjunk hozzá egy 14-et az append(int) segítségével . Szigorúan véve nem egy egész számot adtunk hozzá, hanem a "14" karakterláncot, és frissített StringBuilder értéket kaptunk az "I love Java 14"-hez. Így a metódus az argumentumot StringBuilder objektummá alakítja, egy meglévő StringBuilder objektumhoz köti, és egy frissített objektumot ad vissza.

StringBuilder append() példa az Object, int, logikai érték és a String argumentumhoz

Ugyanez a történet lesz az összes többi túlterhelt metódussal, szám-, karakterlánc-, karakter- vagy tömbelemekkel. Hozzunk létre egy LegoBrick osztály és szín enumot a nyilvános StringBuilder append(Object obj) metódus bemutatására .

//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 +
              '}';
   }
}

Most hozzunk létre egy AppendDemo osztályt, ahol megmutatjuk egy alapvető StringBuilder hozzáfűzését String, int, LegoBrick és logikai értékekkel. Furcsán hangzik, de működik!

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 kimenet a következő: Először létrehoztuk és megjelenítettük a StringBuilder "I love"-t, majd először az append() metódussal szekvenciálisan hozzáadtunk hozzá egy karakterláncot, egy int számot, egy objektum karakterlánc-ábrázolását és egy logikai értéket.

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

Nézzük az append() metódust három paraméterrel. Hozzáadja a karakterlánchoz egy adott char tömb altömbjének reprezentációját. Ezért itt:

• A cstr a hozzáfűzendő karakterek tömbje
• állítsa be az első hozzáfűzendő karakter indexét
• A hossz a hozzáfűzendő karakterek száma.

Más append() metódusokhoz hasonlóan ez is egy kiterjesztett StringBuilder objektumot ad vissza. Íme egy példa az append(char[], cstr, int set, int long) használatára a Java alkalmazáskód részeként.

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 kimenet a következő:

StringBuilder append() metódusok CharSequence argumentummal

Lehet, hogy észrevett két olyan módszert, amelyeknek a CharSequence az argumentuma.

• nyilvános StringBuilder hozzáfűzés(CharSequence cs)
• public StringBuilder append(CharSequence cs, int kezdet, int vége)

Nem minden kezdő tudja, hogy a CharSequence egy interfész. A dokumentáció szerint a CharSequence char értékek olvasható sorozata, és egységes, csak olvasható hozzáférést biztosít számos különféle karaktersorozathoz. Az interfészt olyan Java osztályok valósítják meg, mint a String, StringBuffer, StringBuilder és így tovább. Tehát ha nem tudja, mi a jobb a programban, a String, a StringBuffer vagy a StringBuilder, használhatja a CharSequence-t. A StringBuilder append(CharSequence cs, int start, int end) majdnem úgy működik, mint az append(char[] cstr, int set, int long)fentebb tárgyaltuk. Ez a metódus azonban megadja a részsorozat első és az utolsó elemét. Fontos megjegyezni, hogy a kezdet benne van a részsorozatban, de a vége nem (vagyis az utolsó elem a részsorozatban az az elem, amely a vég előtt áll). Miert van az? Ez pont olyan, mint a Java-ban. Mutassuk meg, mi az a CharSequence, és az append(CharSequence cs) és append(CharSequence cs, int start, int end) metódusokat.

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 kimenet a következő: Létrehoztunk két CharSequence-t, hozzájuk kötöttük a Stringet és a StringBuildert, és kinyomtattuk őket. Az append() metódus nem alkalmazható közvetlenül a myStringBuilder-re, mivel a CharSequence nem rendelkezik ezzel a metódussal (ha nem érted, miért, akkor az öröklődésről, valamint a referenciatípusok bővítéséről és szűkítéséről kell tájékozódnia). Ezért létrehozunk egy StringBuilder-t, és az append metódussal összefűzzük, szekvenciálisan mindkét CharSequence-szel. A végén hozzáfűztük a StringBuilder-ünket az „is” részszekvenciával (az „i” a myStringBuilder 5. eleme, az s pedig a 6. elem. Ne feledje, hogy a metódusban az endként megadott elem ki van zárva az alsorozatból.

Mi a helyzet a StringBuffer append()-vel?

A StringBuffer.append a metódus 13 változatával is rendelkezik, és pontosan ugyanúgy működnek, mint a StringBuilder.

• public StringBuffer hozzáfűzés (logikai b)
• nyilvános StringBuffer hozzáfűzés (c karakter)
• public StringBuffer append​(char[] str)
• public StringBuffer append​(char[] str, int offset, int len)
• nyilvános StringBuffer hozzáfűzés (dupla d)
• nyilvános StringBuffer hozzáfűzés (float f)
• nyilvános StringBuffer hozzáfűzés (i.
• nyilvános StringBuffer hozzáfűzés (hosszú lng)
• nyilvános StringBuffer hozzáfűzés (CharSequence s)
• public StringBuffer append​(CharSequence s, int start, int end)
• nyilvános StringBuffer hozzáfűzés(Object Obj)
• public StringBuffer append​(String str)
• public StringBuffer append​(StringBuffer sb)

Nézzünk egy példát a StringBuffer.append függvényre , amely egy részkarakterlánchoz csatlakozik. Vegyük a StringBuilder példát, és az összes StringBuildert a kódban StringBuffersre változtatjuk.

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 kimenet a következő: Ezt a cikk minden példájával megteheti. Működni fognak!

Következtetés

Mivel a StringBuilder és a StringBuffer a legtöbb függvényt megosztja, nem meglepő, hogy mindkét osztály hasonló módon használja az append() metódust. Ez jó hír a fejlesztők számára – nem kell külön módszereket tanulnia minden osztályhoz. Ennek ellenére, figyelembe véve az append() használatának sokféle módját , ne felejtsen el néhány órát gyakorolni a különböző adattípusok reprezentációinak egy karakterlánchoz való hozzáadásával.