Why Java Strings are Immutable?

In Java, strings are immutable, meaning their values cannot be changed once created. If you try to modify a string (e.g., using concat() or replace()), a new string object is created instead of altering the original one.

• Strings are stored in a String Pool, allowing reuse of objects and reducing memory overhead.
• Multiple threads can safely share the same string object without synchronization.
• Immutable strings have a consistent hash code, making them reliable for use in collections like HashMap.

Example Demonstrating Immutability

public class GFG {  public static void main(String[] args) {  // Both s1 and s2 refer to the same  // string literal in the String Pool  String s1 = "Hello";  String s2 = "Hello";  // true, both point to the same object in String Pool  System.out.println("s1 == s2: " + (s1 == s2));   // Concatenation creates a new String  // object in heap, s1 now points to it  s1 = s1.concat(" World");  System.out.println("s1: " + s1);   System.out.println("s2: " + s2);   System.out.println("s1 == s2: " + (s1 == s2));     // Creating a string using new keyword stores it in the heap  String s3 = new String("Hello");  // false, because s2 is from String Pool and s3 is from heap  System.out.println("s2 == s3: " + (s2 == s3));   // true, because equals() compares content  System.out.println("s2.equals(s3): " + s2.equals(s3));  } } 

s1 == s2: true s1: Hello World s2: Hello s1 == s2: false s2 == s3: false s2.equals(s3): true 

Explanation:

• s1 and s2 initially point to the same object in the String Pool.
• After s1.concat(" World"), a new string object is created for "Hello World".
• s3 is created using new String("Hello") and stored in the heap, separate from the String Pool.
• == checks reference equality: s2 == s3 is false.
• .equals() checks content equality, so s2.equals(s3) is true.

Why Strings Are Designed to Be Immutable

• Memory Efficiency: The String Pool allows multiple references to share the same string object safely.
• Thread Safety: Immutable objects are inherently safe for multi-threaded access.
• Hashcode Reliability: Strings are commonly used as keys in HashMap; immutability ensures the hashcode remains consistent.
• Performance Optimization: JVM can optimize immutable strings, including interning, which saves memory and improves speed.