Strings, the string pool, and StringBuilder

A String is immutable: no method changes it. toUpperCase, trim, replace and concat all return a new string, and the original is untouched — so name.trim(); on its own line does nothing useful.

Immutability is what makes the rest of the design safe. A string can be shared between threads without locking, used as a HashMap key without its hash code ever changing (String caches it after the first call), and handed to a security check without the caller changing it afterwards.

The string pool, and why == is a trap

String literals are interned: every occurrence of the literal "java" in a program refers to one shared object in the string pool. new String("java") deliberately makes a separate object, and a string built at runtime (by concatenating variables, reading input, calling substring) is a new object too. Concatenation of two literals, though, is done by the compiler, so "ja" + "va" is the pooled "java".

1import java.util.*;2 3public class Solution {4    public static List<String> describe() {5        String literal = "java";6        String other = "java";7        String made = new String("java");8        String ja = "ja";9        String built = ja + "va";            // built at runtime10        String folded = "ja" + "va";          // folded by the compiler11 12        return List.of(13            "literal == other: " + (literal == other),14            "literal == made: " + (literal == made),15            "literal.equals(made): " + literal.equals(made),16            "literal == built: " + (literal == built),17            "literal == folded: " + (literal == folded),18            "literal == built.intern(): " + (literal == built.intern()));19    }20}

== compares references, so it is true exactly when two expressions happen to reach the same object — which depends on how each string was produced, not on its text. equals compares the characters, always. intern() returns the pooled copy, which is why it makes == work again; it is not a reason to use ==.

StringBuilder

Because each += on a String creates a new string and copies every character so far into it, building an n-character result one piece at a time costs O(n²) copying. StringBuilder keeps one growable buffer and appends into it, and has the editing operations String lacks.

1import java.util.*;2 3public class Solution {4    public static String describe() {5        StringBuilder sb = new StringBuilder();6        for (int i = 1; i <= 5; i++) {7            sb.append(i).append(',');8        }9        sb.setLength(sb.length() - 1);   // drop the trailing comma10        String joined = sb.toString();11        sb.insert(0, '[').append(']');12        String wrapped = sb.toString();13        StringBuilder word = new StringBuilder("color");14        word.insert(4, 'u').replace(0, 1, "C");      // edits in the middle and at the front15        return joined + " | " + wrapped + " | " + word;16    }17}

StringBuilder is not thread-safe; StringBuffer is the old synchronized twin, and is almost never what you want today. A single expression such as a + ":" + b is fine — the compiler already turns it into one efficient concatenation; the cost is in the loop.

length() counts UTF-16 units

A String is a sequence of UTF-16 chars. Characters outside the Basic Multilingual Plane — most emoji, for example — take two chars (a surrogate pair). length() counts chars; codePointCount counts the characters a reader sees.

Common mistakes

• Comparing strings with ==. It passes for literals (the pool) and fails for anything read or built at runtime.
• Ignoring the return value: s.toLowerCase(); changes nothing.
• split(".") or split("|"). The argument is a regular expression: "." matches every character, so splitting "a.b.c" on it yields an empty array. Escape it: split("\\.").
• in a loop over thousands of pieces, where a (or / ) does the same in linear time.

1import java.util.*;2 3public class Solution {4    public static List<String> describe() {5        String version = "21.0.2";6        String[] wrong = version.split(".");7        String[] right = version.split("\\.");8 9        String word = "café😀";   // "café" followed by an emoji10        return List.of(11            "split(\".\") parts: " + wrong.length,12            "split(\"\\\\.\") parts: " + Arrays.toString(right),13            "length: " + word.length(),14            "codePointCount: " + word.codePointCount(0, word.length()));15    }16}

What interviewers ask

• Why is String immutable in Java? Safe sharing via the pool, thread safety without locks, a hash code that can be cached and never changes, and values that cannot be altered after a security check.
• String, StringBuilder, StringBuffer — which and when? String for values; StringBuilder for building in a loop on one thread; StringBuffer only for legacy APIs that require it.
• How many objects does new String("hi") create? One new String on the heap each time it runs, plus the pooled "hi" literal, which exists once per JVM.