Differences between String, StringBuilder, and StringBuffer in Java

Description
In Java, String, StringBuilder, and StringBuffer are three commonly used classes for handling strings. Their core distinctions lie in mutability, thread safety, and performance. Understanding these differences is crucial for writing efficient and correct Java programs.

Explanation

1. String (String Constant)

   • Core Feature: Immutability. This is the key to understanding String. Once a String object is created, the sequence of characters it contains cannot be changed. Any operation that appears to modify a String (like concatenation or replacement) actually creates a brand new String object.
   • Memory Mechanism: Let's understand through code.

     String str = "Hello";
     str = str + " World"; // Seems to modify str
     

     In the first line, the JVM creates a "Hello" object in the string constant pool, and the variable str points to it.
     In the second line, the JVM first creates a new String object with the content "Hello World", and then makes the variable str point to this new object. The original "Hello" object remains in memory, waiting for garbage collection.
   • Thread Safety: Because String objects are immutable, they are inherently thread-safe. Multiple threads can read the same String object simultaneously without causing data inconsistency.
   • Performance: Due to immutability, in scenarios where strings are frequently modified (like concatenation within loops), a large number of temporary objects are generated, increasing GC (Garbage Collection) pressure and resulting in poorer performance.

2. StringBuffer (String Variable)

   • Core Feature: Mutable and Thread-Safe. StringBuffer represents a string whose character sequence can be modified. It provides a series of methods (like append, insert, delete) to directly modify the content of the object itself, without creating a new object each time.
   • Thread Safety: The key methods of StringBuffer (like append) are synchronized using the synchronized keyword, meaning only one thread can call these methods at any given time. Therefore, it is thread-safe and suitable for use in multi-threaded environments.
   • Performance: Since the object itself can be modified, performance is far superior to String in scenarios involving frequent string modifications. However, due to the use of synchronization locks, it incurs unnecessary performance overhead in single-threaded environments.

3. StringBuilder (String Variable)

   • Core Feature: Mutable but Not Thread-Safe. StringBuilder is a class added in JDK 1.5. It is almost identical to StringBuffer and also provides a series of methods to modify string content.
   • Thread Safety: StringBuilder does not use the synchronized keyword to modify its methods, therefore it is not thread-safe. If multiple threads operate on a single StringBuilder instance simultaneously, it may lead to data inconsistency.
   • Performance: By removing the overhead of synchronization locks, StringBuilder offers the highest performance among the three in single-threaded environments.

Summary and Selection Strategy

How to Choose?

• Use String: When your string does not require frequent modification, or when you explicitly need its immutable nature (e.g., as a key in a Map).
• Use StringBuilder: When you need to perform a large number of string concatenation or modification operations in a single-threaded environment. This is the most common scenario today.
• Use StringBuffer: When you are in a multi-threaded environment where multiple threads might modify the same string object concurrently.

Simple Verification Example

// Performance comparison: String concatenation vs. StringBuilder append
int n = 100000;

// 1. Using String concatenation (Poor performance)
long startTime1 = System.currentTimeMillis();
String result1 = "";
for (int i = 0; i < n; i++) {
    result1 += i; // May create a new object each loop
}
long endTime1 = System.currentTimeMillis();
System.out.println("String concatenation time: " + (endTime1 - startTime1) + " ms");

// 2. Using StringBuilder concatenation (Good performance)
long startTime2 = System.currentTimeMillis();
StringBuilder result2 = new StringBuilder();
for (int i = 0; i < n; i++) {
    result2.append(i); // Always modifies the same object
}
long endTime2 = System.currentTimeMillis();
System.out.println("StringBuilder concatenation time: " + (endTime2 - startTime2) + " ms");

Running this code will visually demonstrate the performance advantage of StringBuilder in scenarios involving a large number of concatenation operations.