Java String Performance: Concatenation, Interning & Best Practices

// Immutability means every "modification" allocates a new object
String s = "Hello";
s.toUpperCase();      // returns NEW String "HELLO"; s is still "Hello"
s = s.toUpperCase();  // now s points to the new object; old "Hello" becomes garbage

// Safe as HashMap key — hash is cached, contents never change
Map<String, Integer> map = new HashMap<>();
map.put(s, 1);        // hash computed once, then cached inside the String object

// Safe across threads — no synchronization needed for reads
// Multiple threads can share the same String reference without risk

// Single-expression concatenation — optimized by JVM, leave as-is
String greeting = "Hello, " + name + "! You have " + count + " messages.";

// Java 9+ compiles this to:
// invokedynamic makeConcatWithConstants("Hello, \u0001! You have \u0001 messages.")
// The JVM pre-computes the exact buffer size and fills it in one pass

// BAD: O(n^2) — each iteration copies the entire accumulated string
String result = "";
for (int i = 0; i < 100_000; i++) {
    result += i + ",";  // allocates new String every iteration
}

// GOOD: O(n) amortized — single mutable buffer
StringBuilder sb = new StringBuilder(600_000); // pre-size if you can estimate
for (int i = 0; i < 100_000; i++) {
    sb.append(i).append(',');
}
String result = sb.toString();

// String.join — clean API for delimiter-separated strings
List<String> items = List.of("apple", "banana", "cherry");
String csv = String.join(", ", items); // "apple, banana, cherry"

// Collectors.joining — for stream pipelines
String csv2 = items.stream()
    .collect(Collectors.joining(", ", "[", "]")); // "[apple, banana, cherry]"

// StringJoiner — for incremental building with delimiter
StringJoiner sj = new StringJoiner(", ", "{", "}");
sj.add("one").add("two").add("three");
String result = sj.toString(); // "{one, two, three}"

// Default capacity: 16
StringBuilder sb = new StringBuilder();       // capacity = 16
StringBuilder sb2 = new StringBuilder(512);   // capacity = 512 — avoids early regrowth
StringBuilder sb3 = new StringBuilder("Hi");  // capacity = 16 + 2 = 18

// Growth pattern: (current + 1) * 2
// 16 -> 34 -> 70 -> 142 -> 286 -> 574 -> ...

// Pre-sizing for known workloads
int lineCount = 10_000;
int avgLineLength = 80;
StringBuilder log = new StringBuilder(lineCount * avgLineLength);

// String.format — convenient but slow in hot paths
// Parses the format pattern on EVERY call
String msg = String.format("User %s has %d items", name, count);

// MessageFormat — can pre-compile the pattern
MessageFormat fmt = new MessageFormat("User {0} has {1,number,integer} items");
String msg2 = fmt.format(new Object[]{name, count});

// StringBuilder — fastest for structured string assembly
String msg3 = new StringBuilder(64)
    .append("User ").append(name)
    .append(" has ").append(count).append(" items")
    .toString();

// Java 21+ String templates (preview) — compiler-optimized formatting
// String msg4 = STR."User \{name} has \{count} items";

// Literals are automatically interned
String a = "hello";       // goes into the string pool
String b = "hello";       // reuses the SAME object from the pool
System.out.println(a == b);             // true — same reference

// new String() creates a separate heap object
String c = new String("hello");
System.out.println(a == c);             // false — different object
System.out.println(a.equals(c));        // true  — same content

// intern() returns the pooled instance
String d = c.intern();
System.out.println(a == d);             // true — d points to the pooled "hello"

// Practical use: deduplicating parsed data
Map<String, List<Record>> grouped = new HashMap<>();
for (Record r : records) {
    String country = r.getCountry().intern(); // thousands of records, few unique countries
    grouped.computeIfAbsent(country, k -> new ArrayList<>()).add(r);
}

// Java 9+ compact strings — automatic, no code changes needed
String latin1 = "Hello World";      // stored as byte[] with 1 byte/char (LATIN1)
String utf16  = "Hello \u4e16\u754c"; // contains non-Latin1 chars, stored as 2 bytes/char (UTF16)

// Compact strings are enabled by default
// To disable (rare): -XX:-CompactStrings

// Memory savings example:
// Java 8:  "Hello" = char[5] = 10 bytes payload
// Java 9+: "Hello" = byte[5] = 5 bytes payload (Latin-1)
// ~50% savings on the character data for Latin-1 strings

// JVM flags for string pool tuning
// -XX:StringTableSize=120011    (increase bucket count for heavy interning)
// -XX:+PrintStringTableStatistics  (print pool stats at shutdown)

// Diagnostic: print string table statistics at JVM exit
// java -XX:+PrintStringTableStatistics MyApp
// Output shows: Number of buckets, entries, average chain length, max chain length

// Enable G1 string deduplication
// java -XX:+UseG1GC -XX:+UseStringDeduplication MyApp

// How it works:
// 1. G1 GC identifies String objects during young-gen collection
// 2. It hashes their byte[] content
// 3. If two Strings have identical byte[] content, they are made
//    to share the same byte[] reference
// 4. The duplicate byte[] becomes garbage and is reclaimed

// Key points:
// - Only works with G1 GC (default GC since Java 9)
// - Deduplicates the backing byte[], not the String objects themselves
// - a == b is still false (different String objects)
// - a.equals(b) is true (same content)
// - No code changes required — purely a GC optimization

// Control the minimum age of strings considered for dedup:
// -XX:StringDeduplicationAgeThreshold=3  (default: 3 GC cycles)

// Text block — NO runtime overhead
String json = """
        {
            "name": "%s",
            "age": %d
        }
        """;

// Compiles to the EXACT same constant as:
String json2 = "{\n    \"name\": \"%s\",\n    \"age\": %d\n}\n";

// Text blocks are interned just like regular string literals
String a = """
        hello""";
String b = "hello";
System.out.println(a == b); // true — same pooled constant

// formatted() convenience method (Java 15+)
String result = """
        {
            "name": "%s",
            "age": %d
        }
        """.formatted(name, age);
// Note: formatted() has the same overhead as String.format() at runtime

// ANTI-PATTERN: O(n^2) concatenation
String sql = "";
for (String col : columns) {
    sql += col + ", ";
}

// FIX: use String.join or StringBuilder
String sql = String.join(", ", columns);

// Or with StringBuilder for conditional logic
StringBuilder sb = new StringBuilder(columns.size() * 20);
for (String col : columns) {
    if (sb.length() > 0) sb.append(", ");
    sb.append(col);
}
String sql = sb.toString();

// ANTI-PATTERN: redundant toString()
String s = someString.toString();           // already a String
System.out.println("Value: " + obj.toString()); // + calls toString() automatically
log.info("Count: " + Integer.valueOf(n).toString()); // boxing + redundant toString()

// FIX: let the JVM handle conversions
String s = someString;                      // no-op, it's already a String
System.out.println("Value: " + obj);        // + invokes toString() implicitly
log.info("Count: {}", n);                   // SLF4J parameterized — no concatenation

// ANTI-PATTERN: recompiles the regex pattern on every iteration
for (String line : lines) {
    String[] parts = line.split("\\|");           // compiles Pattern each time
    if (line.matches("\\d{4}-\\d{2}-\\d{2}")) {  // compiles Pattern each time
        // ...
    }
}

// FIX: pre-compile the Pattern
private static final Pattern PIPE = Pattern.compile("\\|");
private static final Pattern DATE = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");

for (String line : lines) {
    String[] parts = PIPE.split(line);
    if (DATE.matcher(line).matches()) {
        // ...
    }
}

// Historical issue (Java 6 and earlier):
// substring() shared the original char[] — could prevent GC of large strings
// String small = hugeString.substring(0, 10); // held reference to huge char[]

// Java 7u6+ fix: substring() creates a new backing array
// No longer a memory leak concern in modern Java

// But still be aware of:
// ANTI-PATTERN: creating substrings you don't need
String first3 = input.substring(0, 3);  // allocates new String + byte[]
char c = input.charAt(0);               // zero allocation — prefer if you need a single char

// ANTI-PATTERN: concatenation happens even when log level is disabled
log.debug("Processing user " + user.getName() + " with id " + user.getId());

// FIX: parameterized logging — no string building if DEBUG is off
log.debug("Processing user {} with id {}", user.getName(), user.getId());

// FIX for expensive toString: use a lambda (Log4j2) or guard
if (log.isDebugEnabled()) {
    log.debug("Full state: {}", expensiveObject.toDetailedString());
}

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(2)
@State(Scope.Thread)
public class StringConcatBenchmark {

    @Param({"10", "100", "1000"})
    int size;

    @Benchmark
    public String plusInLoop() {
        String result = "";
        for (int i = 0; i < size; i++) {
            result += i;
        }
        return result;
    }

    @Benchmark
    public String stringBuilder() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < size; i++) {
            sb.append(i);
        }
        return sb.toString();
    }

    @Benchmark
    public String stringBuilderPreSized() {
        StringBuilder sb = new StringBuilder(size * 4);
        for (int i = 0; i < size; i++) {
            sb.append(i);
        }
        return sb.toString();
    }

    @Benchmark
    public String stringJoin() {
        List<String> list = new ArrayList<>(size);
        for (int i = 0; i < size; i++) {
            list.add(String.valueOf(i));
        }
        return String.join(",", list);
    }

    @Benchmark
    public String stringFormat() {
        return String.format("Item %d costs %d in %s", 42, 100, "USD");
    }

    @Benchmark
    public String concatOperator() {
        return "Item " + 42 + " costs " + 100 + " in " + "USD";
    }
}