How Do split() and String.join() Work?

They are mirror images, with one asymmetry that catches everyone out. String.join takes a separator and a sequence of pieces and produces one String. String.split takes a pattern and a String and produces the pieces. The asymmetry is that split takes a regular expression while join takes a literal separator, so a dot in the separator behaves completely differently in the two methods.

Inside split, a dot matches any character. To split on a literal dot you must escape it, or wrap it in Pattern.quote. The same applies to a pipe, which is a regex alternation operator. A comma, a space and a hyphen are not metacharacters, so they work unescaped and are usually what you want.

The second subtlety is empty strings. By default, split removes trailing empty strings produced by the split, so "a,b,,".split(",") does not end with an empty piece. Passing a negative limit keeps every piece. A leading empty string is kept by default, because it is not trailing.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        System.out.println("join           : " + String.join(", ", "a", "b", "c"));
        System.out.println("join list      : " + String.join("-", Arrays.asList("x", "y", "z")));

        // split takes a regex, so a dot means "any character".
        System.out.println("split on dot   : " + Arrays.toString("a.b.c".split("\\.")));
        System.out.println("split on pipe  : " + Arrays.toString("a|b|c".split("\\|")));

        // Trailing empty strings are removed unless you pass a negative limit.
        System.out.println("split default  : " + Arrays.toString("a,b,,c,".split(",")));
        System.out.println("split limit -1 : " + Arrays.toString("a,b,,c,".split(",", -1)));

        // A leading empty string is kept by default.
        System.out.println("leading comma  : " + Arrays.toString(",a,b".split(",")));
    }
}

The output makes the behaviours concrete: the default split drops the trailing empty piece while the negative limit keeps every piece including the trailing empty one, and the leading comma produces an empty first element.

One more thing to know about split: it has a fast path. If the pattern is a single character that is not a regex metacharacter, the JVM uses a specialised implementation that avoids compiling a pattern. That is why split(",") is markedly faster than split(",\\s*"), and it is also why splitting on a single metacharacter such as split("|") behaves strangely — the pipe is alternation with an empty left side, so it matches at every position.

Use String.split. StringTokenizer predates generics and the Collections Framework, and it has two weaknesses that ended its usefulness. It is not a general regular-expression splitter — it only recognises a fixed set of delimiter characters, so you cannot split on a pattern or on a multi-character delimiter. And it has no stream-friendly API, so you end up looping over it manually instead of writing a pipeline.

String.split accepts a regular expression, so the question becomes how to express a literal delimiter. If the delimiter contains no regex metacharacters — a comma, a space, a hyphen, a colon — you can pass it directly and the JVM takes a fast path that avoids compiling a pattern. If it does contain metacharacters, either escape them with a backslash, or wrap the delimiter in Pattern.quote, which produces a safely escaped pattern without you having to think about which characters are special.

A third option, and often the best one, is to avoid splitting altogether when the input is well structured. Scanner with a delimiter pattern, or a proper CSV parser, will handle quoted fields, embedded separators and escaped characters that a naive split will mangle. Splitting on a comma is fine for a list of numbers; it is wrong for a CSV file where a field can legitimately contain a comma inside quotes.

Two small habits that pay off. Pass a negative limit when you need to know about empty trailing fields, because the default drops them silently. And if you are splitting a large body of text repeatedly, compile the pattern once into a Pattern and call pattern.split, rather than letting each call recompile the expression.