feat: demonstrate immutability of String vs mutability of StringBuffer and StringBuilder

WHAT was added:
- Implemented `StringBufferBuilder` to compare `String`, `StringBuffer`, and `StringBuilder`.
- Showed how `concat()` on `String` creates a new object (ignored in this case).
- Demonstrated `append()` on `StringBuffer` and `StringBuilder`, which directly modify the same object.

WHY this matters:
- Highlights the **core difference**:
  - `String` → immutable (operations create new objects).
  - `StringBuffer` → mutable + thread-safe (synchronized).
  - `StringBuilder` → mutable + faster (non-synchronized).
- Helps choose the right class depending on **immutability, performance, and concurrency needs**.

PROGRAM OUTPUT:
- String → `Hello` (unchanged, since concat() result was not stored).
- StringBuffer → `Hello World` (append modifies original).
- StringBuilder → `Hello World` (append modifies original).

REAL-WORLD APPLICATIONS:
- **String** → Constants, configuration values, keys where immutability ensures safety.
- **StringBuilder** → Efficient text manipulation in single-threaded apps (e.g., report generation, JSON building).
- **StringBuffer** → Safe for concurrent modifications in multi-threaded contexts (e.g., shared logging systems).

KEY TAKEAWAYS:
1. `String` is immutable → safe but slower for repeated modifications.
2. `StringBuffer` is mutable & synchronized → safer in multi-threaded use.
3. `StringBuilder` is mutable & non-synchronized → fastest in single-threaded use.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section20JAVA.lang.Package/src/StringBufferBuilder.java

@@ -1,21 +1,42 @@
 public class StringBufferBuilder {
     public static void main(String[] args) {
-        String s1 =new String("Hello");
 
+        String s1 =new String("Hello");
         StringBuffer s2 = new StringBuffer("Hello");
-
         StringBuilder s3 = new StringBuilder("Hello");
 
         s1.concat(" World");
-
         s2.append(" World");
-
         s3.append(" World");
 
         System.out.println(s1);
-
         System.out.println(s2);
-
         System.out.println(s3);
     }
-}
+}
+
+/*
+1. String (Immutable):
+   - Jab bhi hum concat(), replace(), etc. use karte hain,
+     ek naya String object ban jata hai.
+   - Purana string object modify nahi hota.
+   - Example: "Hello" + " World" → naya object create hoga.
+
+2. StringBuffer (Mutable + Thread-safe):
+   - append(), insert(), delete() → directly existing object me changes karta hai.
+   - Synchronization ki wajah se multi-threaded environment me safe hai,
+     but performance thoda slow hota hai.
+
+3. StringBuilder (Mutable + Faster):
+   - Almost same as StringBuffer but NOT synchronized.
+   - Isliye ye single-threaded use case me fastest option hai.
+
+4. Output of this program:
+   - s1 → "Hello" (kyunki String immutable hai aur concat() ka result ignore kiya gaya)
+   - s2 → "Hello World" (append ne existing object update kar diya)
+   - s3 → "Hello World" (append ne existing object update kar diya)
+
+- Use String → jab value kabhi change nahi hogi.
+- Use StringBuilder → jab frequent modifications single-threaded environment me karne hain.
+- Use StringBuffer → jab multi-threaded environment me modifications karne hain.
+*/