Difference between String and StringBuffer in java

In Java, both String and StringBuffer are used to manipulate strings, but they have important differences in terms of mutability, performance, and usage.

String Class:

1. Immutability:
   • Strings in Java are immutable, which means once a String object is created, its value cannot be changed. Any operation that seems to modify a string actually creates a new string object.
2. Performance:
   • Because strings are immutable, concatenating strings using the + operator in loops can be inefficient. Each concatenation creates a new string object, leading to a lot of object creations.
3. Usage:
   • Strings are suitable for scenarios where the content does not change frequently, such as representing fixed values or constants.

Example using String:

/*
 * Author: Zameer Ali Mohil
 * */
public class StringExample {
    public static void main(String[] args) {
        String str = "Hello";
        str = str + " World"; // Creates a new String object
        System.out.println(str);
    }
}

StringBuffer Class:

1. Mutability:
   • StringBuffer objects are mutable, meaning you can modify their contents without creating a new object. This makes them more efficient for operations that involve frequent modifications, like concatenations in loops.
2. Performance:
   • StringBuffer is more efficient for concatenating strings in loops because it allows you to modify the content of the same object instead of creating new objects.
3. Usage:
   • StringBuffer is suitable for scenarios where the content changes frequently, such as building strings dynamically in loops or methods.

Example using StringBuffer:

/*
 * Author: Zameer Ali Mohil
 * */
public class StringBufferExample {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("Hello");
        buffer.append(" World"); // Modifies the same StringBuffer object
        System.out.println(buffer);
    }
}

In the above examples, the String class concatenation creates new string objects every time, which can be inefficient in performance-critical scenarios. On the other hand, the StringBuffer class allows you to modify the content of the same object, making it more efficient for dynamic string operations.

In modern Java (since Java 5), the StringBuilder class is often preferred over StringBuffer in non-thread-safe scenarios due to its similar mutability but with lower synchronization overhead, making it faster in most cases. The usage of StringBuilder is similar to StringBuffer, and you can switch between them based on the synchronization needs of your application.