Why is the String class immutable and marked as final?

Immutability of the String class and its finalization ensure:

• Safety in multithreading: Immutable objects can be safely used by multiple threads simultaneously without the need for synchronization.
• Efficiency of the String Pool: Since strings are immutable, Java can optimize memory by storing identical string literals in a single instance in the string pool. This reduces memory consumption.
• Security in hash tables (e.g., in HashMap): Hash codes of immutable strings are computed once and cached. If strings were mutable, their hash codes could change over time, which would break the operation of hash-based hash tables.
• Security: Strings are often used to store important information such as passwords, file paths, and network addresses. Modifying this data after creation can lead to vulnerabilities. Immutability prevents accidental or malicious modification of the string's contents.
• Finalization: Prevents inheritance from the String class. This is important to ensure immutability and the correctness of optimizations, as subclasses could violate these guarantees.

Example:

String s1 = "Hello"; // Creates a "Hello" object in the string pool
String s2 = "Hello"; // Returns a reference to the same object from the pool

s1 = s1 + " World"; // Does not modify the original "Hello" object, but creates a new "Hello World" object

System.out.println(s1); // "Hello World"
System.out.println(s2); // "Hello" - s2 still references the original object