Was ist Anhängen in Java? & seine Implementierung in den Klassen StringBuilder und StringBuffer
Veröffentlicht: 2021-04-09In einem Softwareentwicklungsjob wird es so viele Fälle geben, in denen Sie Zeichenfolgen zu einer vorhandenen Zeichenfolge zusammenfügen. Obwohl es einfacher scheint als getan, sind Strings in Java unveränderlich. Um sie veränderbar zu machen und Änderungen zu implementieren, werden zwei Klassen, StringBuffer und StringBuilder, verwendet. Die Klassen StringBuilder und StringBuffer haben Methoden wie Einfügen, Ersetzen, Löschen und Anhängen in Java.
Die Append-Methode wird hauptsächlich verwendet, um Daten in einer Datei anzuhängen oder hinzuzufügen. Sie können den Daten in einem Programm Zeichen, Boolesche Werte, Strings, Integer, Gleitkommazahlen usw. hinzufügen. Wir werden jedes davon mit der Art und Weise sehen, wie append in Java in einem Programm codiert ist.
Inhaltsverzeichnis
Anhängen in Java
Append in Java ist eine StringBuilder- und StringBuffer-Klassenmethode, die verwendet wird, um einen Wert an die aktuelle Sequenz anzuhängen. Die Stringverkettung in Java erfolgt mit der StringBuilder- oder StringBuffer-Klasse und der append()- Methode.
String-Klassen in Java
Die String-Klasse ist endgültig und hat keine untergeordneten Klassen, und ihre Instanzen können nach der Erstellung nicht geändert werden. Der StringBuilder in Java repräsentiert eine veränderliche Sequenz. Die StringBuilder-Klasse bietet eine Alternative zur String-Klasse.
Quelle
Aufgrund der Unveränderlichkeit werden nach jeder Operation neue Zeichenfolgeninstanzen erstellt und alte verworfen, wodurch viel Müll entsteht. Daher befassen sich StringBuffer- oder StringBuilder-Klassen mit der temporären Garbage-Erzeugung aufgrund von Änderungen an der Zeichenfolge.
Die Funktion von StringBuilder ist der Klasse StringBuffer ziemlich ähnlich. Allerdings unterscheiden sich sowohl die Klasse StringBuilder als auch die Klasse StringBuffer in der Synchronisierung. Die StringBuffer-Klasse wird synchronisiert, während die StringBuilder-Klasse keine Synchronisierung bereitstellt. Daher wird StringBuffer in einer Umgebung mit mehreren Threads und StringBuilder in einer Umgebung mit nur einem Thread häufig geändert.
Lernen Sie Softwareentwicklungskurse online von den besten Universitäten der Welt. Verdienen Sie Executive PG-Programme, Advanced Certificate-Programme oder Master-Programme, um Ihre Karriere zu beschleunigen.
Append-Methodenimplementierung in StringBuilder- und StringBuffer-Klassen
Append in Java ist eine Methode der StringBuilder- und StringBuffer-Klassen, die der aktuellen Sequenz einen neuen Wert hinzufügt. Das Anhängen kann in 13 Formen erfolgen.
Syntax
öffentlicher StringBuffer append()
Sehen wir uns die tatsächlichen Implementierungen der Append-Methode in allen Formen an:
1. StringBuffer append(boolean bo): Anhängen einer Zeichenfolge an das boolesche Argument.
| java.lang.* importieren; öffentliche Klasse AB { public static void main(String[] args) { StringBuffer sbd = new StringBuffer („This is appending boolean“); System.out.println(“Eingabe: ” + sbd); sbd.append (in Java); System.out.println("Ausgabe: "+ sbd); } } |
Ausgabe
Eingabe: Dies ist ein anhängender boolescher Wert
Ausgabe: Dies ist das Anhängen von boolean in Java
2. StringBuffer append(char ch): Anhängen einer Zeichenkette an das Zeichenargument.
| java.lang.* importieren; öffentliche Klassen-CD{ public static void main(String[] args) { StringBuffer sbd = new StringBuffer("Dies ist ein anhängendes Zeichen"); sbf.append('A'); System.out.println(“Nach dem Anhängen = ” + sbd); } } |
Ausgabe:
Dies ist das Anhängen eines Zeichens
Nach dem Anhängen = Dies ist das Anhängen von Zeichen A
3. StringBuffer append(char[] string): Anhängen einer Zeichenfolge an das Zeichenarray.
java.lang.* importieren;
öffentliche Klasse EF{
public static void main(String[] args)
{
StringBuffer sbd = new StringBuffer(“ Dies hängt eine Zeichenkette an“);
char[] astr = new char[] { 'I', 'N', 'D', 'I', 'A' };
sbd.append(astr);
System.out.println(“Nach dem Anhängen = ” + sbd);
}
}
Ausgabe:
Dies ist das Anhängen einer Zeichenfolge
After appending = Dies ist das Anhängen einer Zeichenkette INDIA
4. StringBuffer append(char[] string, int offset, int len): Anhängen einer Zeichenfolge an ein Zeichenarray.
| java.lang.* importieren; öffentliche Klasse GH { public static void main(String[] args) { StringBuffer sbd = new StringBuffer („Java“); System.out.println(” Before Appending= ” + sbd);  char[] cstr = new char[] { 'i', 's', 'a', 'w', 'e', 's', 'o', 'm', 'e' }; sb.append(cstr, 0, 3); System.out.println(“Nach dem Anhängen von string = ” + sbd); } } |
Ausgabe:
Vor Anhängen= Java
Nach dem Anhängen von string = Javaisawesome
5. StringBuffer append(CharSequence cse): Anhängen eines Strings an eine Zeichensequenz.
| java.lang.* importieren; öffentliche Klasse IJ { public static void main(String[] args) { StringBuffer sbd = new StringBuffer("Javais"); System.out.println(” string = ” + sbd); CharSequence chSeq = „Super“; sbf.append(chSeq); System.out.println(“Nach dem Anhängen = ” + sbd); } } |
Ausgabe:
Zeichenfolge = Javais
Nach dem Anhängen von = JavaisAwesome
6. StringBuffer append(CharSequence cse, int start, int end): Zeichensequenz an einen String anhängen.
| java.lang.* importieren; öffentliche Klasse KL { public static void main(String[] args) { StringBuffer sbd = new StringBuffer(“Java ist “); System.out.println(” string = ” + sbd); CharSequence chSeq = „super“; sbf.append(chSeq, 1, 4); System.out.println(“Nach dem Anhängen von string = ” + sbf); } } |
Ausgabe:
string = Java ist
Nach dem Anhängen von string = Java ist weso
7. StringBuffer append(double do): Anhängen eines Double an den String.
Programm :
java.lang.* importieren;
öffentliche Klasse MN {
public static void main(String[] args)
{
StringBuffer sbd = new StringBuffer(“Die Hauptnummer ist: “);
Double astr = new Double(522.39);
sbd.append(astr);
System.out.println(“Nach dem Anhängen = ” + sbd);
}
}
Ausgabe:
Die Hauptnummer ist:
Nach dem Anhängen = 522,39
8. StringBuffer append(float fl): Anhängen des Strings an Float.
java.lang.* importieren;
öffentliche Klasse OP {
public static void main(String[] args)
{
StringBuffer sbd = new StringBuffer(“Java ist genial“);
Float astr = new Float(1.23);
sbd.append(astr);
System.out.println(“Nach dem Anhängen = ” + sbd);
}
}
Ausgabe:
Java ist genial
Nach dem Anhängen = Java ist genial 1.23
9. StringBuffer append(int i): Ganzzahl an die Zeichenfolge anhängen.
java.lang.* importieren;
öffentlicher Klassen-QR {
public static void main(String[] args)
{
StringBuffer sbd = new StringBuffer(“Java ist genial“);
Ganzzahl astr = neue Ganzzahl (478);
sbd.append(astr);
System.out.println(“Nach dem Anhängen = ” + sbd);
}
}
Ausgabe:
Java ist
Nach dem Anhängen von = Java ist großartig 478
10. StringBuffer append(long lng): Anhängen des Strings an ein langes Argument.
| java.lang.* importieren; öffentliche Klasse ST { public static void main(String[] args) { StringBuffer sbd = new StringBuffer(“Java is Awesome“); Lange astr = neu Lange (1993); sbd.append(astr); System.out.println(“Nach dem Anhängen = ” + sbd); } } |
Ausgabe:
Java ist genial
Nach dem Anhängen von = Java is Awesome 1993
11. StringBuffer append(Object obj): Anhängen eines Objekts an einen String.
| java.lang.* importieren; öffentliche Klasse UV{ public static void main(String[] args) { StringBuffer sbd = new StringBuffer("Javais"); System.out.println(“string = ” + sbd); Objekt Objektwert = „fantastisch“; sbd.append (Objektwert); System.out.println(“Nach dem Anhängen = ” + sbd); } } |
Ausgabe:
Zeichenfolge = Javais
Nach dem Anhängen von = Javaisawesome
12. StringBuffer append(String str): Hängt einen String an einen anderen String an.
| java.lang.* importieren; öffentliche Klasse WX{ public static void main(String[] args) { StringBuffer sbd = new StringBuffer("Javais"); System.out.println(“string = ” + sbd); String strvalue = „fantastisch“; sbd.append (strvalue); System.out.println(“Nach dem Anhängen = ” + sbd); } } |
Ausgabe:
Zeichenfolge = Javais
Nach dem Anhängen von = Javaisawesome
13. StringBuffer append(StringBuilder sbf): Anhängen des StringBuilder an StringBuffer
| java.lang.* importieren; öffentliche Klasse YZ{ public static void main(String[] args) { StringBuffer sbd = new StringBuffer("Javais"); System.out.println(“String 1 = ” + sbd1); StringBuffer sbf2 = new StringBuilder(“awesome“); System.out.println(“String 2 = ” + sbd2); Sbd1.append (sbd2); System.out.println ("Nach dem Anhängen = " + sbd1); } } |
Ausgabe:
Zeichenfolge 1 = Javais
Saite 2 = genial
Nach dem Anhängen von = Javaisawesome
Fazit
In diesem Artikel haben wir eines der wichtigsten Konzepte behandelt, nämlich das Anhängen in Java. Es macht einen unveränderlichen String veränderlich und kann alles mit einem String verketten, egal ob es sich um eine ganze Zahl, ein Zeichen oder ein Objekt handelt. Aus Programmiersicht ist es sehr nützlich und auch weit verbreitet. Wir hoffen, dass wir Ihnen jeden Aspekt von append sowie seine praktische Implementierung verständlich machen konnten.
upGrad bietet einen einzigartigen Master of Science in Informatik-Kurs an, um Ihre Fähigkeiten zu verbessern und das Wachstum auf Ihrer Karriere in der Softwareentwicklung zu fördern.