feat: add comparison between StringBuffer and StringBuilder with toString() conversion

WHAT was added:
- Implemented `SBvsSB` to demonstrate differences between `StringBuffer` and `StringBuilder`.
- Showed how to convert both to immutable `String` using `toString()`.
- Highlighted immutability of `String` vs mutability of buffer objects.
- Included comments explaining memory behavior and conversion process.

WHY this matters:
- Clarifies how mutable classes (`StringBuffer`, `StringBuilder`) interact with immutable `String`.
- Demonstrates that changes in buffer objects after conversion do not affect the `String` created.
- Reinforces understanding of when to use `StringBuffer` (thread-safe) vs `StringBuilder` (faster, single-threaded).

KEY LEARNINGS DEMONSTRATED:
1. **Conversion to String**
   - Both `StringBuffer` and `StringBuilder` override `toString()` to create a new immutable `String`.
   - Example:
     ```java
     String s1 = sbr.toString();  // Converts buffer to String
     ```

2. **Immutability of String**
   - Once converted, the new `String` object remains unchanged even if the buffer is modified later.
   - Example:
     ```java
     sbr.append("ForGeeks");
     // sbr -> "GeeksForGeeks"
     // s1  -> "Geeks" (unchanged)
     ```

3. **Thread Safety vs Performance**
   - `StringBuffer`: Synchronized → safe in multithreading but slower.
   - `StringBuilder`: Non-synchronized → faster but not thread-safe.

4. **Memory Behavior**
   - `toString()` allocates a **new String in heap memory**.
   - No shared references → further changes to buffer don’t affect the string.

REAL-WORLD APPLICATIONS:
- **StringBuffer**: Multithreaded loggers, concurrent text processing where synchronization is required.
- **StringBuilder**: Single-threaded string manipulations like XML/JSON building or string concatenation in compilers.
- **String Conversion**: When mutable text structures need to be passed as immutable data (e.g., API responses, DB queries).

LIMITATIONS:
- Frequent conversion between `String` and buffer objects may cause performance overhead due to new object creation.
- Use immutable `String` directly when no modifications are needed.

KEYWORDS:
StringBuffer vs StringBuilder, toString conversion, mutable vs immutable strings, thread safety, performance trade-offs.

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

Author: Someshdiwan

Section20JAVA.lang.Package/src/SBvsSB.java

@@ -1,44 +1,42 @@
-/*
-This conversion can be performed using toString() method which is overridden in both StringBuffer and StringBuilder classes. Below is the Java program to demonstrate the same.
-
-Note: While we use toString() method, a new String object(in Heap area) is allocated and initialized to the character sequence currently represented by the StringBuffer object, which means the subsequent changes to the StringBuffer object do not affect the contents of the String object.
-
-Example:
-Java Program to Demonstrate Conversion from
-String to StringBuffer and StringBuilder
-*/
 public class SBvsSB {
 
     public static void main(String[] args) {
-
-        // Creating objects of 
-        // StringBuffer class
+        // Creating objects of StringBuffer class.
         StringBuffer sbr = new StringBuffer("Geeks");
         StringBuilder sbl = new StringBuilder("Hello");
 
-        // Converting StringBuffer object to String
-        // using toString() method
+        // Converting StringBuffer object to String, using toString() method.
         String s1 = sbr.toString();
 
-        // Printing the above string
-        System.out.println(
-                "StringBuffer object to String: ");
+        System.out.println("StringBuffer object to String: ");
+
         System.out.println(s1);
 
-        // Converting StringBuilder object to String
+        // Converting StringBuilder object to String.
         String s2 = sbl.toString();
 
-        // Printing the above string
-        System.out.println(
-                "StringBuilder object to String: ");
+        System.out.println("StringBuilder object to String: ");
+
         System.out.println(s2);
 
-        // Changing StringBuffer object sbr
-        // but String object(s1) doesn't change
+        // Changing StringBuffer object sbr, but String object(s1) doesn't change
         sbr.append("ForGeeks");
 
-        // Printing the above two strings on console
         System.out.println(sbr);
         System.out.println(s1);
     }
-}
+}
+
+/*
+This conversion can be performed using toString() method which is overridden in both
+StringBuffer and StringBuilder classes.
+
+Above, Java program to demonstrate the same.
+
+Note: While we use toString() method, a new String object(in Heap area) is allocated and
+initialized to the character sequence currently represented by the StringBuffer object,
+which means the subsequent changes to the StringBuffer object do not affect the contents of the String object.
+
+Example:
+Java Program to Demonstrate Conversion from String to StringBuffer and StringBuilder
+*/