StringBuilder and StringBuffer

StringBuilder and StringBuffer are two classes in Java that provide an alternative to the immutable String class by creating a mutable sequence of characters. While both classes are similar in functionality, there are some differences between the two.

The StringBuilder class creates a mutable sequence of characters that is not synchronized, meaning that it provides no guarantee of synchronization. On the other hand, the StringBuffer class creates a mutable sequence of characters that is synchronized, meaning that it provides a guarantee of synchronization.

Because of the synchronization, the StringBuffer class is designed for use in multi-threaded environments, while the StringBuilder class is designed for use in single-threaded environments. The StringBuilder class is faster and preferred over StringBuffer for the single-threaded program. If thread safety is needed, then StringBuffer is used. Where possible, it is recommended that StringBuilder class be used in preference to StringBuffer as it will be faster under most implementations.

In the example code provided, we can see the difference between the two classes. In the case of the String class, s2 points to the same location as s1, but when we create a new location to store s1, s1 and s2 refer to different locations. On the other hand, when we use the StringBuilder class, sb2 refers to the same location as sb1, and when we modify sb1 using the append operation, both sb1 and sb2 refer to the same location.

Here is an improved version of the code with comments to explain each step:

java
public class StringBuilderVsStringBuffer {

    public static void main(String[] args) {
        
        // String class
        String s1 = "geeks";
        
        // s2 points to the same location as s1
        String s2 = s1;

        // Creates a new location to store s1
        s1 = s1 + "forgeeks";
        
        // s1 and s2 refer to different locations
        if(s1 == s2)
            System.out.println("Same");
        else
            System.out.println("Not Same");

        // StringBuilder class
        StringBuilder sb1 = new StringBuilder("geeks");
        
        // sb2 points to the same location as sb1
        StringBuilder sb2 = sb1;
        
        // Append operation modifies the same object
        // as it is mutable in nature
        sb1 = sb1.append("forgeeks");
        
        // Both sb1 and sb2 refer to the same location
        if(sb1 == sb2)
            System.out.println("Same");
        else
            System.out.println("Not Same");
    }
}

In summary, the StringBuilder and StringBuffer classes in Java provide a mutable sequence of characters as an alternative to the immutable String class. While both classes have similar functionality, the StringBuilder class is faster and designed for use in single-threaded environments, while the StringBuffer class is designed for use in multi-threaded environments where thread safety is required.