String Methods and StringBuilder

Why + in a loop is so slow

A String cannot change. So result += "x" cannot add anything to result. It has to:

Look at step two. On pass one you copy 1 character. On pass two, 2. On pass 40,000, you copy 40,000 characters just to add one more.

Add all of that up and you have copied about 800 million characters to build a 40,000 character String. You also created 40,000 String objects, and threw away 39,999 of them.

What StringBuilder does instead

StringBuilder is a mutable String. It keeps one char array and writes into it.

StringBuilder sb = new StringBuilder();
sb.append("hello");        // writes into the array. No new object.
sb.append(" world");       // writes further along the same array.
String result = sb.toString();   // one String, made once, at the end.

When the array fills up, it makes a bigger one and copies across. That happens a handful of times, not 40,000, because each new array is roughly double the last.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. Why is joining 40,000 pieces of text with `+` so much slower than using a `StringBuilder`?

   Show the answer

   Because a String cannot change. Every + builds a brand new String and copies both sides into it.

   On pass one you copy 1 character. On pass two, 2. On pass 40,000, you copy 40,000. The total work grows with the square of the number of pieces, and every one of those Strings becomes garbage a moment later.

   A StringBuilder keeps one array and writes into it. When the array fills up it makes a bigger one and copies over, the same doubling you built by hand in the Section 4.2 exercises. That happens a handful of times, not 40,000.

   Measured on a normal machine: about 71 ms against about 1 ms.

2. `" ".isEmpty()` is false but `" ".isBlank()` is true. What is the difference?

   Show the answer

   isEmpty() asks one question: is the length zero? Three spaces have a length of three, so the answer is no.

   isBlank() asks a different question: is there anything here other than whitespace? Three spaces are all whitespace, so the answer is yes, it is blank.

   This matters for real input. A user who presses space and then Enter has given you something that is not empty and is not useful. isBlank() catches that. isEmpty() does not.

   isBlank() arrived in Java 11. Before that people wrote s.trim().isEmpty(), which does the same job with an extra object.

3. `StringBuilder` and `StringBuffer` have the same methods. When would you pick the second one?

   Show the answer

   Almost never, and the reason is worth knowing.

   The only difference is that every StringBuffer method is synchronized, which makes it safe when several threads use the same object at once. StringBuilder is not, and is faster because of it.

   The catch is that sharing one text builder across threads is rare. Almost always a builder is a local variable inside one method, used by one thread, and the locking is pure cost.

   Modern code that does need thread safety usually controls it deliberately, with locks around the section that needs them, rather than hoping a single class handles it. So the practical rule is: use StringBuilder. Reach for StringBuffer only when a builder is genuinely shared, which is a design you should question first.

Write each solution in VS Code, predict its result, and then run the checks. Reading an example does not replace implementing it.

4 exercises85 pointsabout 100 minutes

public class Joining {
    static long withPlus(int n) {
        long t0 = System.nanoTime();
        String s = "";
        for (int i = 0; i < n; i++) s += "x";
        if (s.length() == -1) System.out.print("");
        return (System.nanoTime() - t0) / 1_000_000;
    }

    static long withBuilder(int n) {
        long t0 = System.nanoTime();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) sb.append("x");
        String s = sb.toString();
        if (s.length() == -1) System.out.print("");
        return (System.nanoTime() - t0) / 1_000_000;
    }

    public static void main(String[] args) {
        for (int warm = 0; warm < 2; warm++) { withPlus(5000); withBuilder(5000); }
        for (int n : new int[]{10_000, 20_000, 40_000}) {
            System.out.printf("%6d pieces  +=%5d ms   builder=%3d ms%n",
                    n, withPlus(n), withBuilder(n));
        }
    }
}

import java.util.Scanner;

public class Blank {
    static void report(String label, String s) {
        System.out.printf("%-12s length=%d  isEmpty=%-5s  isBlank=%-5s  trim().isEmpty()=%s%n",
                label, s.length(), s.isEmpty(), s.isBlank(), s.trim().isEmpty());
    }

    public static void main(String[] args) {
        report("empty", "");
        report("spaces", "   ");
        report("tab", "\t");
        report("text", "atlas");
        report("padded", "  atlas  ");

        // TODO: read a unit name and reject it if the user gave nothing useful
        // TODO: store the name trimmed, and show the difference
    }
}

import java.util.Arrays;

public class Splitting {
    public static void main(String[] args) {
        String csv = "Atlas,101,88.5,true";
        System.out.println(Arrays.toString(csv.split(",")));

        String version = "1.2.3";
        System.out.println("split(\".\")  -> " + Arrays.toString(version.split(".")));
        // TODO: make this one work

        String messy = "a,b,,c,,";
        System.out.println("trailing gaps -> " + Arrays.toString(messy.split(",")));
        // TODO: keep the trailing empty pieces too

        // TODO: split a line on one or more spaces, however many there are
        String spaced = "Atlas    Beacon  Cipher";
    }
}

public class Report {
    record Unit(String name, int id, double readiness, boolean active) { }

    static Unit[] roster() {
        Unit[] units = new Unit[2000];
        for (int i = 0; i < units.length; i++)
            units[i] = new Unit("Unit-" + i, 100 + i, (i * 37) % 101, i % 3 != 0);
        return units;
    }

    // TODO: build a formatted report of every unit, using StringBuilder
    // TODO: then write the same thing with += and time both

    public static void main(String[] args) {
        Unit[] units = roster();
        // print a header, one line per unit, and a summary
    }
}