feat: add example demonstrating StringBuffer usage and mutability

WHAT was added:
- Implemented `SBClass` with a simple example of `StringBuffer`.
- Created a `StringBuffer` initialized with `"Hello"`, appended `" World!"`, and printed the result.
- Included explanatory comments on `StringBuffer` properties.

WHY this matters:
- Demonstrates the difference between immutable `String` and mutable `StringBuffer`.
- Highlights thread-safety of `StringBuffer` compared to `StringBuilder`.
- Shows practical usage of `append()` method for efficient string concatenation.

KEY LEARNINGS DEMONSTRATED:
1. **Mutability of StringBuffer**
   - Unlike `String`, which is immutable, `StringBuffer` allows modification of the same object.
   - Example:
     ```java
     StringBuffer str = new StringBuffer("Hello");
     str.append(" World!");
     // str now contains "Hello World!" without creating a new object
     ```

2. **Thread-safety**
   - All public methods in `StringBuffer` are synchronized.
   - Safe for use in multithreaded environments where multiple threads modify the same buffer.

3. **Performance trade-off**
   - Synchronization introduces overhead, making `StringBuffer` slower than `StringBuilder`.
   - For single-threaded use cases, `StringBuilder` is preferred.

4. **Important methods of StringBuffer**
   - `append(String s)` → concatenates string.
   - `insert(int offset, String s)` → inserts string at given position.
   - `delete(int start, int end)` → removes characters from buffer.
   - `reverse()` → reverses the sequence.
   - `capacity()` → returns current buffer capacity.

REAL-WORLD APPLICATIONS:
- **Multithreaded logging systems**: Safe string concatenation from multiple threads.
- **Data processing pipelines**: Efficient manipulation of large text streams in concurrent environments.
- **Legacy codebases**: Commonly found where thread-safe mutable strings were needed before `StringBuilder` became standard.

LIMITATIONS:
- Slower than `StringBuilder` in single-threaded scenarios due to synchronization overhead.
- Overkill for simple immutable string operations.

KEYWORDS:
StringBuffer, mutable string, append, thread-safe string manipulation, Java concurrency.

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

Author: Someshdiwan

Section20JAVA.lang.Package/src/SBClass.java

@@ -1,23 +1,51 @@
+public class SBClass {
+    public static void main(String args[]) {
+        // Creating a new StringBuffer
+        StringBuffer str = new StringBuffer("Hello");
+        str.append(" World!");
+        System.out.println(str);
+    }
+}
+
 /*
-StringBuffer Class
-StringBuffer is a class that allows us to create and modify a flexible, expandable sequence of characters. It is thread-safe. Thismeans that it can be safely used when multiple threads are accessing or modifying the string concurrently. But due to synchronization, it is slower than StringBuilder.
+StringBuffer is a class that allows us to create and modify a flexible, expandable sequence of characters.
+
+It is thread-safe.
+This means that it can be safely used when multiple threads are accessing or modifying the string concurrently.
+
+But due to synchronization, it is slower than StringBuilder. StringBuffer str = new StringBuffer();
 
-StringBuffer str = new StringBuffer();
 Example:
+Above is an example which implements the StringBuffer class. Java program to demonstrate the StringBuffer class
 
-Below is an example which implements the StringBuffer class.
+1. StringBuffer ek mutable sequence of characters hai.
+   Matlab ek baar object create karne ke baad bhi uske andar ke content ko
+   change (modify) kiya ja sakta hai bina naye object create kiye.
 
- Java program to demonstrate
- the StringBuffer class
-*/
+2. Thread-safety:
+   - StringBuffer synchronized hoti hai.
+   - Matlab multiple threads agar ek hi object ko access/modify karein
+     to ye safe rehti hai.
+   - Downside: synchronization ke wajah se ye thoda slow hoti hai.
 
-public class SBClass {
-    public static void main(String args[])
-    {
+3. StringBuilder vs StringBuffer:
+   - StringBuilder → NOT synchronized, faster, single-threaded use case ke liye best.
+   - StringBuffer → Synchronized, thread-safe, multi-threaded use case ke liye best.
 
-        // Creating a new StringBuffer
-        StringBuffer str = new StringBuffer("Hello");
-        str.append(" World!");
-        System.out.println(str);
-    }
-}
+4. Commonly used methods:
+   - append() → end me add karne ke liye
+   - insert() → beech me insert karne ke liye
+   - delete() → characters remove karne ke liye
+   - reverse() → pura string ulta karne ke liye
+   - capacity() → buffer capacity check karne ke liye
+   - ensureCapacity() → minimum capacity set karne ke liye
+
+5. Example flow:
+   StringBuffer str = new StringBuffer("Hello");
+   str.append(" World!");
+   Output: Hello World!
+
+Real-life use case:
+Jab tumhe string ke upar **bahut saare modifications** karne hain (like append, insert, delete in loops)
+aur multi-threaded environment hai, tab StringBuffer ek solid choice hai.
+*/