strings, the basics

the picture

a String is not a primitive. it's an object on the heap, and your variable holds a reference to it, exactly like the Point in stack and heap. it just gets special treatment: literals in quotes, + to glue, and a shared pool for literals.

String a = "hi";
String b = "hi";
String c = new String("hi");

== vs equals

you know how == on two strings sometimes works and sometimes doesn't? kinda cursed. here's why: == on references asks "same object?", not "same text?". literals share a pooled object, so == happens to say yes. strings built at runtime are new objects, so it says no, even when the text is identical.

void main() {
    String a = "hi";
    String b = "hi";
    String c = new String("hi");
    String d = "h" + "i";
    String h = "h";
    String e = h + "i";
    IO.println((a == b) + " " + (a == c) + " " + a.equals(c) + " " + (a == d) + " " + (a == e) + " " + (a == e.intern()));
}

true false true true false true

"h" + "i" is folded into "hi" by the compiler, so it's a literal and lands in the pool. h + "i" happens at runtime and makes a new object. intern() looks a string up in the pool and returns the pooled copy. none of that is something you want your program's correctness to depend on.

String name = IO.readln("name? ");   // you type: duke
if (name == "duke") IO.println("same");
else IO.println("different");

immutable means new objects

no String method ever changes the string you call it on. toUpperCase, replace, trim, +: each one builds a new string and returns it. if you don't store the result, it's gone.

·

so s.toUpperCase(); on its own line is a bug: it does the work and throws it away. you meant s = s.toUpperCase();.

the methods you'll use all the time (the full tour is in the string api):

void main() {
    String s = "  Hello, Duke!  ";
    String t = s.strip();
    IO.println(t.length() + " " + t.charAt(0) + " " + t.indexOf("Duke") + " " + t.substring(7, 11));
    IO.println(t.toUpperCase() + " " + t.replace('l', 'L') + " " + t.contains("Duke") + " " + t.startsWith("Hell"));
    IO.println(String.join("|", "a", "b", "c") + " " + "ab".repeat(3) + " " + "   ".isBlank() + " " + "".isEmpty());
}

12 H 7 Duke
HELLO, DUKE! HeLLo, Duke! true true
a|b|c ababab true true

indexes start at 0, and substring(7, 11) means "from index 7 up to, but not including, 11". that half-open range is everywhere in java.

gluing strings together

+ with a String on either side means concatenation, and it reads left to right: 1 + 2 + "3" is "33" but "1" + 2 + 3 is "123" (more in operators). careful with chars: 'a' + 'b' is the int 195, because two chars add as numbers. "" + 'a' + 'b' is "ab".

in a loop, + gets expensive, because every round copies the whole string so far into a new one:

String csv = "";
for (int i = 0; i < 10_000; i++) {
    csv += i + ",";
}

var sb = new StringBuilder();
for (int i = 0; i < 10_000; i++) {
    sb.append(i).append(',');
}
String csv = sb.toString();

outside loops, just use +. the compiler makes it fast.

text blocks

for multi-line text (json, sql, html), a text block opens with """ and a line break, and closes with """ java 15+. no \n, no escaping quotes. the clever part is the indentation: java strips the spaces that are only there because your code is indented, and keeps the rest.

void main() {
    String html = """
        <ul>
        ··<li>tea</li>
        </ul>
        """;
}

<ul>⏎
··<li>tea</li>⏎
</ul>⏎

the rule: java finds the smallest indentation among the content lines (counting the closing """ line if it's on its own), and removes exactly that much from every line. trailing spaces on each line are stripped too. two escapes help: \s is a space that won't be stripped, and a \ at the end of a line joins it with the next one.