Immutable String

// ── String methods return NEW objects — original unchanged ───────────
String original = "Hello World";

String upper    = original.toUpperCase();    // new object
String lower    = original.toLowerCase();    // new object
String trimmed  = "  Hello  ".trim();        // new object
String replaced = original.replace("World", "Java"); // new object
String sub      = original.substring(6);     // new object

System.out.println(original);  // "Hello World" — completely unchanged
System.out.println(upper);     // "HELLO WORLD"
System.out.println(lower);     // "hello world"
System.out.println(replaced);  // "Hello Java"
System.out.println(sub);       // "World"

// ── Variable reassignment vs object mutation ──────────────────────────
String s = "hello";
String original_ref = s;    // save reference to original object

s = s.toUpperCase();        // s now points to new object "HELLO"

System.out.println(s);             // "HELLO" — s points to new object
System.out.println(original_ref);  // "hello" — original object unchanged

// ── Consequence: long chains create many temporary objects ─────────────
String result = "  Hello World  "
    .trim()              // new object: "Hello World"
    .toLowerCase()       // new object: "hello world"
    .replace(" ", "_")   // new object: "hello_world"
    .concat("!");        // new object: "hello_world!"
// Four intermediate String objects created, three immediately unreachable

// ── Immutability enforced by three mechanisms ─────────────────────────
// 1. private final byte[]/char[] value — no external access
// 2. final class — no subclass can expose or modify value
// 3. no mutating methods — String's own API never modifies value
//
// class String {                      (simplified)
//     private final byte[] value;     ← private, final
//     private final byte coder;
//     private int hash;               ← only mutable field, and it's safe
//     ...
// }

// ── Reason 1: String pool requires immutability ──────────────────────
// If String were mutable (hypothetical broken design):
// String a = "hello"; // pool entry
// String b = "hello"; // same pool entry (shared object!)
// a.setChar(0, 'J');  // mutating a would also change b!
// System.out.println(b); // "jello" — unexpected!
// Immutability prevents this sharing hazard

// ── Reason 2: Thread safety without synchronization ───────────────────
String config = loadFromFile("config.properties");

// Multiple threads can safely read config simultaneously
Thread t1 = new Thread(() -> process(config));  // no sync needed
Thread t2 = new Thread(() -> validate(config)); // no sync needed
Thread t3 = new Thread(() -> log(config));      // no sync needed
t1.start(); t2.start(); t3.start();
// No race conditions — config can never change

// ── Reason 3: Security — TOCTOU prevention ────────────────────────────
// Mutable string vulnerability (hypothetical):
// class FileManager {
//     public void open(MutableString path) {
//         securityCheck(path);   // path = "/safe/file.txt" — approved
//         // Attacker mutates path on another thread:
//         // path → "/etc/passwd"
//         openFile(path);        // now opens restricted file!
//     }
// }
//
// With immutable String:
public void open(String path) {
    securityCheck(path);   // path = "/safe/file.txt" — approved
    openFile(path);        // guaranteed SAME value — no race possible
}

// ── Reason 4: Reliable hash map keys ─────────────────────────────────
Map<String, Integer> wordCount = new HashMap<>();
String key = "hello";
wordCount.put(key, 1);

// key's hash code cannot change → map lookup always works
System.out.println(wordCount.get("hello"));  // 1
System.out.println(wordCount.get(key));      // 1 — always finds it

// If String were mutable (hypothetical):
// key.setChar(0, 'J');  // key is now "jello"
// wordCount.get("jello") would not find it (stored under "hello" hash)
// wordCount.get("hello") would not find it either (key changed)
// The entry would be permanently lost in the map!

// ── Object creation cost of chained operations ───────────────────────
String input = " Hello, World! ";

// Each method creates a new String object:
String result = input
    .strip()          // object 1: "Hello, World!"
    .toLowerCase()    // object 2: "hello, world!"
    .replace(",", "") // object 3: "hello world!"
    .replace("!", "");// object 4: "hello world"

// Objects 1, 2, 3 immediately unreachable — GC fodder

// ── String building patterns ──────────────────────────────────────────
List<String> items = List.of("alpha", "beta", "gamma", "delta");

// WRONG — O(n²) object creation:
String joined = "";
for (String item : items) {
    joined += item + ", ";   // new String each iteration
}

// CORRECT — one StringBuilder, one final String:
StringBuilder sb = new StringBuilder();
for (String item : items) {
    sb.append(item).append(", ");
}
String efficient = sb.toString();

// BEST for this case — purpose-built method:
String best = String.join(", ", items);

// ── Java 11+ String methods ───────────────────────────────────────────
// strip() uses Unicode whitespace definition (broader than trim())
" 	 Hello 
 ".strip();          // "Hello" — removes all Unicode whitespace
" 	 Hello 
 ".stripLeading();   // "Hello 
 "
" 	 Hello 
 ".stripTrailing();  // " 	 Hello"
"  	  ".isBlank();               // true — empty after stripping

// lines() — lazy stream of lines, any line separator
"line1
line2
line3".lines()
    .forEach(System.out::println);  // line1, line2, line3

// repeat() — repetition
"ab".repeat(3);   // "ababab"
"-".repeat(40);   // "----------------------------------------"

// ── Sharing substrings — no copying since Java 7 ──────────────────────
// Before Java 7: substring() shared the original char[] with an offset
// Since Java 7: substring() always creates a new String with its own array
// Implication: substring() in a tight loop creates many objects
// For performance-sensitive parsing, consider manual index tracking
// instead of extracting substrings for every token