Java Strings, StringBuilder and Text Blocks (OCP Java SE 25)

A String is immutable: once created, its characters can never change, so every method that seems to modify text — toUpperCase(), concat(), replace(), strip(), substring() — returns a new String (or the same one when nothing changes) and leaves the receiver untouched. If you don't assign the result, it is simply lost.

String t = "duke";
t.toUpperCase();              // result discarded
String u = t.toUpperCase();   // result kept
System.out.println(t + " " + u);   // duke DUKE

Chained calls each work on the String returned by the previous call, not on the original. That matters when an index is computed from one String and used on another: an indexOf() taken on the untrimmed original is a position in that text, and applying it to a stripped or lower-cased copy points at a different character.

Immutability also explains how Strings behave as method arguments. Java passes every argument by value — for objects, a copy of the reference. Inside a method, name = name.concat("?") builds a new String and points only the local parameter at it; the caller's variable still refers to the old one. Contrast this with a StringBuilder argument: calling buf.insert(0, "#") mutates the one shared object, so the caller sees the change — but buf = new StringBuilder(...) inside the method again only moves the local copy of the reference.

equals() compares the characters; == compares references — it asks whether two variables point at the same object. Two Strings can be equal in content and still fail ==.

The JVM keeps a string pool of interned Strings. Every String literal is interned, so identical literals anywhere in the program share one object. The compiler also folds compile-time constant expressions into a single literal: "Du" + "ke" becomes "Duke" before the program runs, so it is the pooled object too. For this topic, a constant expression is built from literals, operators and final variables of primitive or String type that are initialized with constant expressions (constant variables); a plain, non-final variable is never part of one.

Concatenation that involves a non-constant value is evaluated at run time and produces a new String object that is not pooled. new String("Duke") always creates a new object. Calling intern() returns the pooled instance with the same content (adding it to the pool first if needed), so the result is == to the matching literal.

String a = "Duke";
String b = "Du" + "ke";        // constant expression: folded
String prefix = "Du";
final String P = "Du";         // constant variable
String c = prefix + "ke";      // run time: new object
String d = P + "ke";           // constant expression: folded
String e = new String("Duke"); // always a new object
System.out.println((a == b) + " " + (a == c) + " " + (a == d)
        + " " + (a == e) + " " + (a == e.intern()));
// true false true false true

Text blocks are String literals too, so a text block whose processed content equals another literal is the same pooled object. The safe rule for real code: compare text with equals() (or equalsIgnoreCase()), and treat == results as a question about object identity.

String positions are zero-based, and ranges are start-inclusive, end-exclusive: substring(b, e) returns the characters from index b up to but not including e, so its length is e - b. substring(b) runs to the end.

• Valid ranges: 0 <= b <= e <= length(). b == e gives the empty String, and substring(length()) is legal and returns "". A start greater than the end, a negative index, or an end past length() throws StringIndexOutOfBoundsException at run time — the compiler never checks these values.
• charAt(i) needs 0 <= i < length(); charAt(length()) throws.
• indexOf(x) returns the first position of a char or String, or -1 if absent. indexOf(x, fromIndex) starts searching at fromIndex (inclusive).
• lastIndexOf(x) searches backwards from the end; lastIndexOf(x, fromIndex) searches backwards starting at fromIndex. The search methods never throw for an out-of-range fromIndex: a negative start is treated as 0 for indexOf, a start past the end is treated as the last index for lastIndexOf, and a search that starts beyond the text (indexOf from length() or more, lastIndexOf from a negative index) returns -1.

String w = "parallel";
System.out.println(w.indexOf('l') + " " + w.indexOf('l', 5) + " "
        + w.lastIndexOf('l') + " " + w.lastIndexOf('l', 6) + " "
        + w.indexOf('z'));                     // 4 5 7 5 -1
System.out.println(w.indexOf('a', -3) + " "
        + w.lastIndexOf('a', 50) + " "
        + w.indexOf('a', 20) + " "
        + w.lastIndexOf('a', -1));             // 1 3 -1 -1
System.out.println("[" + w.substring(8) + "] " + w.substring(2, 5)
        + " " + w.substring(5));               // [] ral lel
w.substring(5, 1);   // StringIndexOutOfBoundsException

The + operator is evaluated left to right, one pair at a time, and each pair decides its own meaning: if either operand is a String, the pair is concatenation; otherwise it is numeric addition. So numbers before the first String are added, and everything after it is appended as text.

System.out.println(4 + 5 + "-" + 4 + 5);   // 9-45
System.out.println('x' + 'y' + "!");       // 241!  (120 + 121, then "!")
System.out.println("!" + 'x' + 'y');       // !xy
char ch = 'x';
System.out.println(ch + 1);                // 121   (char + int is int)

A char is a numeric type: char + char and char + int produce an int, not a character. Only once a String is on one side does a char get appended as a character.

null in concatenation becomes the text "null" — no exception. That includes the compound form: if t is a null String, t += "?" gives "null?". With +=, the right-hand side is evaluated first as its own expression, so in t += m + 2 with char m = 'm', m + 2 is computed as the int 111 and the digits 111 are appended, not the letter o.

Beyond indexing, the exam expects you to predict the exact result of the common String methods.

White space: strip() versus trim(), isBlank() versus isEmpty()

So "\n ".isEmpty() is false while "\n ".isBlank() is true, and for "\u2003ok\u2003" trim() leaves all 4 characters while strip() leaves "ok".

Comparing: equals, equalsIgnoreCase, compareTo

compareTo() orders Strings lexicographically by UTF-16 char values. It returns the difference of the first differing chars; if one String is a prefix of the other, it returns the difference in lengths. Negative means the receiver sorts first, zero means equal content. Because every uppercase ASCII letter (65–90) has a smaller value than every lowercase one (97–122), "Mango".compareTo("kiwi") is negative even though m follows k in the alphabet. compareToIgnoreCase() and equalsIgnoreCase() ignore case differences.

System.out.println("cat".compareTo("Cat") + " "        // 32
        + "cat".compareTo("catalog") + " "             // -4
        + "Mango".compareTo("kiwi") + " "              // -30
        + "Mango".compareToIgnoreCase("kiwi"));        // 2

Building text: format, formatted, repeat, join

String.format(fmt, args...) and the instance form fmt.formatted(args...) are equivalent. Common conversions: %s (any value, via toString), %d (integral types only), %f (floating point; %.2f sets precision), %b (boolean: null is false, a non-null non-Boolean argument is true), %c (a char, or an int code point — 97 prints a), %x (hexadecimal) and %n (platform line separator). Width and flags: a width (%5s right-justifies in five columns), the - flag (left-justify) and the 0 flag (zero-pad, numeric conversions only).

Format strings are checked at run time, not by the compiler: String.format("%d", 7.0) throws IllegalFormatConversionException, and the 0 flag with %s throws FormatFlagsConversionMismatchException.

"xy".repeat(n) returns n copies in total (repeat(0) is ""). String.join(delim, parts) puts the delimiter only between elements — never before the first or after the last.

System.out.println(String.format("%04d|%6s|%-4s|%.1f|%b|%c|%x",
        42, "ok", "ok", 2.75, "no", 'Q', 26));
// 0042|    ok|ok  |2.8|true|Q|1a
System.out.println(String.join("+", "1", "2", "3") + "!".repeat(2));
// 1+2+3!!

split(): a regex split that drops trailing empty Strings

split(regex) treats its argument as a regular expression and is the same as split(regex, 0): empty Strings between delimiters are kept, but trailing empty Strings are removed. A negative limit keeps them all; a positive limit n splits at most n - 1 times and leaves the rest of the input, delimiters included, in the last element. Because . is a regex metacharacter, "1.2.3.4".split(".") produces only empty Strings, all trailing, so the array is empty; escape it as "\\.".

String row = "x;y;;z;;;";
System.out.println(row.split(";").length + " "      // 4  [x, y, , z]
        + row.split(";", -1).length + " "           // 7
        + row.split(";", 2)[1]);                    // y;;z;;;
System.out.println("1.2.3.4".split(".").length + " "
        + "1.2.3.4".split("\\.").length);         // 0 4

StringBuilder is the mutable counterpart of String: its methods change the builder's own character sequence and return this, the same object, which is why calls can be chained. Every call in a chain sees the result of the previous one.

StringBuilder sb = new StringBuilder("planet");
sb.insert(0, "#").delete(3, 5).reverse();
System.out.println(sb);           // telp#
StringBuilder r = new StringBuilder("compile");
r.replace(0, 3, "X");             // Xpile
r.setLength(3);
System.out.println(r + ":" + r.length());   // Xpi:3

Aliasing: the return value is the same object

Because these methods return this, StringBuilder q = p.append("2"); does not copy anything — p and q now name one object, p == q is true, and a later mutation through either variable is visible through both. The distinction to keep straight is mutation versus reassignment: mutating follows the object, while assigning a new builder to one variable (p = new StringBuilder("9")) moves only that variable and leaves every other alias on the old object.

StringBuilder p = new StringBuilder("1");
StringBuilder q = p.append("2");
q.insert(0, "0");
System.out.println(p + " " + (p == q));   // 012 true

A builder's capacity is the size of its internal storage; its length is how many characters it actually holds. new StringBuilder(16) has capacity 16 but length 0, and capacity grows automatically as needed. Index checks are always made against length(), never capacity.

StringBuilder sb = new StringBuilder(16);   // capacity 16, length 0
sb.append("dog");
sb.insert(3, "s");      // ok: offset == length()  -> dogs
sb.delete(2, 40);       // end clamped             -> do
// sb.charAt(2);          StringIndexOutOfBoundsException
// sb.setCharAt(4, '!');  StringIndexOutOfBoundsException

As with String, none of these limits are compile-time errors: bad indexes compile and fail when the statement runs.

StringBuilder does not override equals(), so sb1.equals(sb2) is inherited from Object and is true only for the same object. It does implement Comparable<StringBuilder>: compareTo() compares content lexicographically and returns 0 for equal content.

Comparing across the two types needs care. "node".equals(sb) is always false, because String.equals() returns true only for another String. To compare content, use String.contentEquals(CharSequence) or convert first with sb.toString().

var m = new StringBuilder("node");
var n = new StringBuilder("node");
System.out.println((m == n) + " "                     // false
        + m.compareTo(n) + " "                        // 0
        + "node".equals(m) + " "                      // false
        + "node".contentEquals(n) + " "               // true
        + m.toString().equals(n.toString()));         // true

A text block is a multi-line String literal delimited by three double quotes. It produces an ordinary String — same type, interned like any literal — and the compiler turns its source lines into content in three steps: normalize line terminators to \n, strip incidental white space, then interpret escape sequences.

Rules that decide whether it compiles

• The opening """ must be followed by optional white space and a line terminator; content cannot start on the same line. """Start is a compile error ("illegal text block open delimiter sequence, missing line terminator").
• The closing """ may sit on the last content line or on a line of its own.
• Single and double quotes may appear unescaped. Three quotes in a row must be broken up, for example \""".
• Escape sequences are processed as in ordinary literals, so an invalid one such as \w in D:\work is a compile error ("illegal escape character"); write \\ for a backslash.

Incidental white space and the closing delimiter

The compiler removes the indentation shared by all content lines and the closing-delimiter line (when it is on its own line), and it always strips trailing spaces from each line. That makes the closing delimiter a control: placed level with the content it removes all indentation; moved left of the content it keeps the extra indentation as real spaces. A closing delimiter on its own line gives the content a trailing \n; putting it at the end of the last content line omits it.

static String show(String t) {
    return t.replace(' ', '.').replace("\n", "|");
}

String a = """
    SELECT *
      FROM t
    """;
String b = """
        SELECT *
          FROM t
    """;
String c = """
    SELECT *
      FROM t""";
// show(a): SELECT.*|..FROM.t|
// show(b): ....SELECT.*|......FROM.t|
// show(c): SELECT.*|..FROM.t

The two text-block-only escapes

• \<line-terminator> — a backslash at the very end of a line suppresses that newline, joining the line to the next one (any spaces before the backslash stay).
• \s — a single space. Because escapes are interpreted after trailing white space is stripped, \s at a line's end keeps a trailing space that would otherwise vanish.

String d = """
    tab\s
    wrap \
    me "now" \"""
    """;
// show(d): tab.|wrap.me."now"."""|

Several String methods are designed for multi-line text and pair naturally with text blocks.

• lines() returns a Stream<String> of lines split on \n, \r or \r\n. Empty lines in the middle count; a final line terminator does not create an extra empty line. "one\n\ntwo\n".lines().count() is 3: one, an empty line and two.
• indent(n) adds n spaces to the start of every line (positive n) or removes up to n leading white-space characters (negative n; lines with fewer simply lose all of theirs). It also normalizes line terminators to \n and always ends the result with \n, even if the input had none. indent(0) only normalizes.
• stripIndent() applies the text-block incidental-white-space algorithm at run time: it removes common leading indentation and trailing spaces, but keeps the final line as it was — it does not add a trailing line terminator.
• translateEscapes() interprets escape sequences that exist as literal characters in the String at run time. The source literal "1\\t2\\t3" is seven characters (each \\t is a backslash and a t); translateEscapes() turns it into five (1, tab, 2, tab, 3).
• chars() returns an IntStream of the char values — numbers, not characters ("abc".chars().sum() is 294).

System.out.println(show("p\n  q".indent(1)));       // .p|...q|
System.out.println(show("   m\n n".indent(-2)));    // .m|n|
System.out.println(show("   m\n n".stripIndent())); // ..m|n
String raw = "1\\t2\\t3";
System.out.println(raw.length() + " "
        + raw.translateEscapes().length());       // 7 5