Append() Methode in Java: StringBuilder en StringBuffer

append() is een Java-methode van StringBuilder- en StringBuffer-klassen die een bepaalde waarde aan een huidige reeks toevoegt. Zelfs als u niet wist wat de methode append() is, heeft u deze waarschijnlijk al impliciet gebruikt. Dit gebeurde toen je Strings in Java samenvoegde met de + operator. Het punt is dat String-aaneenschakeling in Java wordt geïmplementeerd met behulp van de StringBuilder- of StringBuffer-klasse en hun append()- methode.

Heel kort over String, StringBuffer en StringBuilder

Zoals u waarschijnlijk weet, is de String-klasse definitief (het heeft geen onderliggende klassen) en onveranderlijk (exemplaren van deze klasse kunnen niet worden gewijzigd nadat deze is gemaakt). Vanwege de onveranderlijkheid van de String-klasse worden in feite nieuwe tekenreeksinstanties gemaakt als resultaat van elke bewerking en worden oude weggegooid, wat een hoop afval oplevert. Om het genereren van tijdelijke rommel als gevolg van wijzigingen aan het String-object aan te pakken, kunt u de StringBuffer- of StringBuilder-klassen gebruiken. Het belangrijkste verschil tussen de laatste twee is dat StringBuffer wordt gesynchroniseerd terwijl StringBuilder dat niet is. Gebruik daarom StringBuffer voor strings die vaak zullen worden gewijzigd in een multi-threaded omgeving en StringBuilder in het geval van een single-threaded omgeving.

Toevoegen() in StringBuilder en StringBuffer

append() is een van de beste methoden van StringBuilder- en StringBuffer-klassen. Het voegt een nieuwe waarde toe aan de huidige reeks. Er zijn 13 verschillende overbelaste append()- methoden in zowel StringBuffer- als StringBuilder-klassen. Laten we eens kijken naar de toevoegmethode voor StringBuilder. Hoe dan ook, ze werken precies hetzelfde in het geval van StringBuffer.

• openbare StringBuilder append(boolean b)
• openbare StringBuilder append(char c)
• openbare StringBuilder append(char[] str)
• openbare StringBuilder append(char[] str, int offset, int len)
• openbare StringBuilder append (CharSequence cs)
• openbare StringBuilder append (CharSequence cs, int start, int end)
• openbare StringBuilder append (dubbele d)
• openbare StringBuilder append(float f)
• openbare StringBuilder append(int i)
• openbare StringBuilder append (lange lng)
• openbare StringBuilder append (Object-object)
• openbare StringBuilder append(String str)
• openbare StringBuilder append (StringBuffer sb)

Laten we er enkele bekijken en met voorbeelden uitleggen wat de methode append() precies doet.

Java.lang.StringBuilder.append(int i)

java.lang.StringBuilder.append(int i) is een methode waarmee een geheel getal aan een bestaand StringBuilder-object kan worden toegevoegd. Laten we eens kijken naar de voorbeelden van het gebruik van 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);

De uitvoer hier zal zijn: Wat is hier gebeurd? Eerst hebben we een StringBuilder gemaakt met de naam s met de waarde "I love Java". Voeg er vervolgens een geheel getal 14 aan toe met behulp van append(int) . Strikt genomen hebben we geen geheel getal toegevoegd, maar de string "14" en hebben we een bijgewerkte StringBuilder-waarde gekregen voor "I love Java 14". De methode verandert het argument dus in een StringBuilder-object, bindt het aan een bestaand StringBuilder-object en retourneert een bijgewerkt exemplaar.

StringBuilder append() voorbeeld voor Object, int, boolean en String argument

Hetzelfde verhaal zal zijn met alle andere overbelaste methoden met nummer-, string-, char- of arrays-elementen. Laten we een LegoBrick Class en Color-enum maken om de openbare StringBuilder append (Object obj) -methode te demonstreren.

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

Laten we nu een AppendDemo-klasse maken waarin we het toevoegen van een standaard StringBuilder met String, int, LegoBrick en boolean laten zien. Klinkt raar, maar het werkt!

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

De uitvoer is: Eerst hebben we StringBuilder "I love" gemaakt en weergegeven, daarna hebben we er sequentieel aan toegevoegd met behulp van de methode append() een string, een int-nummer, een stringrepresentatie van een object en een booleaanse waarde.

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

Laten we eens kijken naar de methode append() met drie parameters. Het voegt een representatie van een subarray van een bepaalde char-array toe aan de string. Dus hier:

• cstr is een reeks tekens die moet worden toegevoegd
• stel het in als de index van het eerste teken dat moet worden toegevoegd
• lengte is het aantal tekens dat moet worden toegevoegd.

Net als bij andere append()- methoden, retourneert deze een uitgebreid StringBuilder-object. Hier is een voorbeeld van het gebruik van append(char[], cstr, int set, int length) als onderdeel van Java-app-code.

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

De uitvoer is:

StringBuilder append()-methoden met het argument CharSequence

Je hebt misschien twee methoden opgemerkt die CharSequence als argument hebben.

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

Niet alle beginners weten dat CharSequence een interface is. Volgens de documentatie is CharSequence een leesbare reeks tekenwaarden en biedt uniforme, alleen-lezen toegang tot veel verschillende soorten tekenreeksen. De interface wordt geïmplementeerd door Java-klassen als String, StringBuffer, StringBuilder en meer. Dus als je niet weet wat je beter kunt gebruiken in je programma, String, StringBuffer of StringBuilder, kun je CharSequence gebruiken. StringBuilder append(CharSequence cs, int start, int end) werkt bijna zoals append(char[] cstr, int set, int length)we hierboven hebben besproken. Deze methode specificeert echter het eerste element van de subreeks en het laatste. Het is belangrijk om te onthouden dat het begin is opgenomen in de subreeks, maar het einde niet (dat wil zeggen, het laatste element in de subreeks is het element dat vóór het einde komt). Waarom is dat? Het is gewoon zoals het is op Java. Laten we demonstreren wat CharSequence is en append(CharSequence cs) en append(CharSequence cs, int start, int end) methoden.

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

De uitvoer is: We hebben twee CharSequences gemaakt, String en StringBuilder eraan gebonden en afgedrukt. We kunnen de methode append() niet rechtstreeks toepassen op myStringBuilder, aangezien CharSequence deze methode niet heeft (als u niet begrijpt waarom, moet u uitzoeken wat overerving is en hoe u referentietypen kunt uitbreiden en verkleinen). Daarom maken we een StringBuilder met en voegen we deze samen met behulp van de append-methode achtereenvolgens met beide CharSequence. Aan het einde hebben we onze StringBuilder toegevoegd met subreeks "is" ("i" is een 5e element van myStringBuilder en s is de 6e. Onthoud dat in de methode het element gespecificeerd als end wordt uitgesloten van de subreeks.

Hoe zit het met StringBuffer append()?

StringBuffer.append heeft ook 13 varianten van de methode en ze werken op precies dezelfde manier als StringBuilder.

• public StringBuffer append​(boolean b)
• openbare StringBuffer append​(char c)
• openbare StringBuffer append​(char[] str)
• public StringBuffer append​(char[] str, int offset, int len)
• openbare StringBuffer append​(dubbele d)
• openbare StringBuffer append​(float f)
• openbare StringBuffer append​(int i)
• public StringBuffer append​(long lng)
• openbare StringBuffer append​(CharSequence s)
• public StringBuffer append​(CharSequence s, int start, int end)
• openbare StringBuffer append​(Object object)
• openbare StringBuffer append​(String str)
• openbare StringBuffer append​(StringBuffer sb)

Laten we een voorbeeld nemen van StringBuffer.append om deel te nemen aan een subtekenreeks. We nemen gewoon het StringBuilder-voorbeeld en veranderen alle StringBuilders in code 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);
   }
}

De uitvoer is: U kunt het doen met elk voorbeeld van dit artikel. Ze zullen werken!

Conclusie

Aangezien StringBuilder en StringBuffer de meeste functies delen, is het geen verrassing dat beide klassen vergelijkbare manieren hebben om de methode append() te gebruiken . Dat is goed nieuws voor ontwikkelaars: je hoeft niet voor elke klas aparte methodes te leren. Dat gezegd hebbende, gezien de verscheidenheid aan manieren om append() te gebruiken , moet je een paar uur oefenen om de representaties van verschillende gegevenstypen aan een string toe te voegen.