Java String

What Happens When You "Change" a String

When code seems to change a String, the object itself is never touched. A statement like a = a + " 17"; builds a brand-new String and then points the variable a at it; any other variable still holding the old reference keeps seeing the old text. The same is true for every String method — toUpperCase(), replace(), trim() and concat() all return a new String, and calling one without assigning the result changes nothing.

The String class enforces this in three ways: the class is declared final, so no subclass can add methods that modify it; the array holding its characters is private final, so no outside code can reach it; and no method ever writes into that array after construction.

Why Strings Are Immutable

Java's designers made String immutable for several concrete reasons, not just as an arbitrary restriction. Because Strings are used everywhere — as class names in class loading, as keys in HashMap, as file paths, and as network resource identifiers — allowing them to change after creation would open the door to serious bugs and security holes. Each reason below depends on the same guarantee: once a String has been checked, stored or shared, its text stays exactly as it was.

• String pool sharing — multiple references can safely share the same object because no one can modify it out from under another reference.
• Security — sensitive values like file paths, usernames, and class names cannot be altered after being validated and passed to a security-sensitive method.
• Thread safety — an immutable object can be freely shared between threads without synchronization, since no thread can ever see it in a half-changed state.
• Hashcode caching — since the content never changes, String caches its hashCode() the first time it is computed, making repeated use as a HashMap key fast.

Strings and the char[] Underneath

Internally, a String stores its characters (historically in a char[], and since Java 9 often in a more compact byte[] with an encoding flag, via the "Compact Strings" feature). This internal array is private and final, and String never exposes a mutable reference to it, which is exactly what preserves immutability from the outside.

Examples

public class StringImmutabilityDemo {
    public static void main(String[] args) {
        String original = "Java";
        String changed = original.concat(" Rocks");

        System.out.println("original: " + original);
        System.out.println("changed: " + changed);
        System.out.println("same object? " + (original == changed));
    }
}

original: Java
changed: Java Rocks
same object? false

public class StringReferenceDemo {
    public static void main(String[] args) {
        String a = "Java";
        String b = a;          // b points to the same object as a

        a = a + " 17";         // creates a new String; a now points to it

        System.out.println("a: " + a);
        System.out.println("b: " + b);

        String name = "webnest";
        name.toUpperCase();    // result ignored - name is unchanged
        System.out.println("name: " + name);

        name = name.toUpperCase();  // capture the new String
        System.out.println("name: " + name);
    }
}

a: Java 17
b: Java
name: webnest
name: WEBNEST

import java.util.HashMap;
import java.util.Map;

public class StringKeyDemo {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        String key = "apple";
        stock.put(key, 10);

        key = key.toUpperCase();  // a new String; the key inside the map is untouched

        System.out.println("get(\"apple\"): " + stock.get("apple"));
        System.out.println("get(key): " + stock.get(key));
        System.out.println("key now: " + key);
    }
}

get("apple"): 10
get(key): null
key now: APPLE

Exercise

Count the vowels in a piece of text, treating upper and lower case the same.

Expected output: 5 for the text WebNest Studio.

public class VowelCount {
    public static void main(String[] args) {
        String text = "WebNest Studio";
        int count = 0;

        // TODO: look at each character and count a, e, i, o and u in either case

        System.out.println(count);
    }
}

public class VowelCount {
    public static void main(String[] args) {
        String text = "WebNest Studio";
        int count = 0;

        String lower = text.toLowerCase();
        for (int i = 0; i < lower.length(); i++) {
            if ("aeiou".indexOf(lower.charAt(i)) != -1) {
                count++;
            }
        }

        System.out.println(count); // 5
    }
}

Quick quiz

Interview questions