What is Append In Java? & its Implementation in StringBuilder and StringBuffer Classes

There will be so many instances in a software development job where you will join strings in an existing string. Although it seems easier than done, strings are immutable in Java. For making them mutable and implementing changes, two classes, StringBuffer and StringBuilder, are used. The StringBuilder and StringBuffer classes have methods such as insert, replace, delete and Append in Java.

The append method is mainly used to append or add data in a file. You can add characters, Booleans, string, integer, float, etc., to the data in a program. We will see each of these with the way append in Java is coded in a program.

Append in Java

Append in Java is a StringBuilder and StringBuffer class method used to append a value to the current sequence. String concatenation in Java is done using the StringBuilder or StringBuffer class and append() method. 

String Classes in Java

String class is final and has no child classes, and its instances cannot be modified after creation. The StringBuilder in Java represents a mutable sequence. The StringBuilder class provides an alternative to String Class.

Source

Due to immutability, new string instances are created after each operation, and old ones are discarded, creating lots of garbage. Thus, StringBuffer or StringBuilder classes deal with the temporary garbage generation due to modifications to the String.

The function of StringBuilder is quite similar to the StringBuffer class. However, both the StringBuilder and StringBuffer class differ in synchronisation. The StringBuffer class is synchronised, whereas the StringBuilder class provides no synchronisation. Hence, StringBuffer will be modified frequently in a multi-threaded environment and StringBuilder in a single-threaded environment.

Append Method Implementation in StringBuilder and StringBuffer Classes

Append in Java is StringBuilder and StringBuffer classes’ method that adds a new value to the current sequence. The appending can be done in 13 forms. 

Syntax

public StringBuffer append()

Let’s see the actual implementations of the append method in all the forms:

1. StringBuffer append(boolean bo): Appending string to the boolean argument.

import java.lang.*;  

public class AB {

    public static void main(String[] args)

    {

        StringBuffer sbd = new StringBuffer (“This is appending boolean “);

        System.out.println(“Input: ” + sbd);

        sbd.append(in Java);

       System.out.println(“Output: “+ sbd);

    }

}

Output

Input: This is appending boolean

Output: This is appending boolean in Java

2. StringBuffer append(char ch): Appending string to the character argument.

import java.lang.*; 

public class CD{

    public static void main(String[] args)

    {

        StringBuffer sbd = new StringBuffer(“This is appending character”);

     sbf.append(‘A’);

        System.out.println(“After appending = ” + sbd);

  }

}

Output:

This is appending a character

After appending = This is appending character A

3. StringBuffer append(char[] string):  Appending string to the character array.

import java.lang.*;

public class EF{  

    public static void main(String[] args)

{

        StringBuffer sbd = new StringBuffer(” This is appending a character string “);

        char[] astr = new char[] { ‘I’, ‘N’, ‘D’, ‘I’, ‘A’ };

        sbd.append(astr);

        System.out.println(“After appending = ” + sbd);

    }

Output:

This is appending a character string

After appending = This is appending a character string INDIA

4. StringBuffer append(char[] string, int offset, int len): Appending string to a character array.

import java.lang.*;  

public class 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(“After appending string = ” + sbd);

    }

}

Output:

Before Appending= Java

After appending string = Javaisawesome

5. StringBuffer append(CharSequence cse): Appending string to a character Sequence.

import java.lang.*;  

public class IJ {

    public static void main(String[] args)

    {

         StringBuffer sbd = new StringBuffer(“Javais”);

        System.out.println(” string = ” + sbd);

        CharSequence chSeq = “Awesome”;   

        sbf.append(chSeq);

        System.out.println(“After appending = ” + sbd);

    }

}

Output:

string = Javais

After appending = JavaisAwesome

6. StringBuffer append(CharSequence cse, int start, int end): Appending Character Sequence to a String.

import java.lang.*;  

public class KL { 

public static void main(String[] args)

{

     StringBuffer sbd = new StringBuffer(“Java is  “);

        System.out.println(” string = ” + sbd);   

        CharSequence chSeq = “awesome”;

        sbf.append(chSeq, 1, 4);  

        System.out.println(“After appending string = ” + sbf);

    }

}

Output:

string = Java is

After appending string = Java is weso

7. StringBuffer append(double do): Appending a double to the string.

Program:

import java.lang.*;

public class MN {  

    public static void main(String[] args)

    {  

        StringBuffer sbd = new StringBuffer(“The main number is: “);

        Double astr = new Double(522.39);

        sbd.append(astr);

        System.out.println(“After appending = ” + sbd);

    }

}

Output:

The main number is:

After appending = 522.39

8. StringBuffer append(float fl): Appending the string to float.

import java.lang.*;  

public class OP {

    public static void main(String[] args)

    {  

        StringBuffer sbd = new StringBuffer(“Java is awesome “);

        Float astr = new Float(1.23);

        sbd.append(astr);

        System.out.println(“After appending = ” + sbd);

    }

}

Output:

Java is awesome

After appending = Java is awesome 1.23

9. StringBuffer append(int i): Append integer to the string.

import java.lang.*;  

public class QR {

    public static void main(String[] args)

    {

        StringBuffer sbd = new StringBuffer(“Java is awesome “);

        Integer astr = new Integer(478);

        sbd.append(astr);

        System.out.println(“After appending = ” + sbd);

    }

Output:

Java is

After appending = Java is awesome 478

10. StringBuffer append(long lng): Appending the string to a long argument.

import java.lang.*;  

public class ST {  

    public static void main(String[] args)

    {

        StringBuffer sbd = new StringBuffer(“Java is Awesome “);  

        Long astr = new Long(1993);

        sbd.append(astr);

        System.out.println(“After appending = ” + sbd);

    }

}

Output:

Java is Awesome

After appending  = Java is Awesome 1993

11. StringBuffer append(Object obj): Appending an Object to a string.

import java.lang.*;  

public class UV{  

    public static void main(String[] args)

    {  

        StringBuffer sbd = new StringBuffer(“Javais”);

        System.out.println(“string = ” + sbd);  

        Object objectvalue = “awesome”;  

        sbd.append(objectvalue);  

        System.out.println(“After appending = ” + sbd);

    }

}

Output:

string = Javais

After appending = Javaisawesome

12. StringBuffer append(String str): Append a string to another string.

import java.lang.*;  

public class WX{  

    public static void main(String[] args)

    {

        StringBuffer sbd = new StringBuffer(“Javais”);

        System.out.println(“string = ” + sbd);   

        String strvalue = “awesome”;

        sbd.append(strvalue);   

        System.out.println(“After appending = ” + sbd);

    }

}

Output:

string = Javais

After appending = Javaisawesome

13. StringBuffer append(StringBuilder sbf): Appending the StringBuilder to StringBuffer

import java.lang.*;

public class 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(“After appending = ” + sbd1);

    }

}

Output:

String 1 = Javais

String 2 = awesome

After appending = Javaisawesome

Conclusion

In this article, we have covered one of the most important concepts, that is, append in Java. It makes an immutable string mutable and can concatenate anything to a string, whether an integer, character, or object. From the programming point of view, it is very useful and widely practised too. We hope we could make you understand every aspect of append along with its practical implementation.

upGrad offers a Unique Master of Science in Computer Science Course for honing your skills and fostering growth in your software development career journey.

Land on Your Dream Job

UPGRAD AND IIIT-BANGALORE'S PG DIPLOMA IN SOFTWARE DEVELOPMENT
LEARN MORE

0 replies on “What is Append In Java? & its Implementation in StringBuilder and StringBuffer Classes”

×