Which String Methods Come Up in Interviews?

The set is smaller than people expect, and knowing exactly what each one returns is worth more than memorising the whole API. length() counts UTF-16 code units, so an emoji counts as two. charAt(int) returns a char and throws StringIndexOutOfBoundsException out of range. isEmpty() tells you whether there are no characters at all. equals compares contents and is null-safe on the receiver; equalsIgnoreCase folds case using the default locale rules. compareTo returns the lexicographic difference and is what sorting uses.

The searching methods split into two families. indexOf, lastIndexOf, contains, startsWith and endsWith work on literal characters and substrings. matches works on a regular expression and must match the entire input, which is why "abc123".matches("[a-z]+") is false. replaceAll and replaceFirst also take regular expressions, while replace takes literal text.

The transforming methods — trim, strip, toUpperCase, toLowerCase, substring, concat — all return new Strings because Strings are immutable. strip is Unicode-aware, unlike the older trim which only removes characters below U+0020.

Finally the parsing family: split with its overloads, String.join, valueOf, and the boxed-type parsers such as Integer.parseInt. Knowing that split takes a regular expression and that valueOf(null) means the word "null" are the two details that separate a candidate who has used these in anger from one who has only read the list.

Count first, then scan. Build a frequency map of the characters, walk the string a second time, and return the first character whose count is one. The second pass matters: the map alone tells you which characters are unique but not which one came first in the original text.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        System.out.println("swiss -> " + firstUnique("swiss"));   // w
        System.out.println("aabb -> " + firstUnique("aabb"));     // nothing

        // The same idea with a fixed-size array for ASCII input.
        System.out.println("aabb -> " + firstUniqueArray("aabb"));
    }

    static Character firstUnique(String text) {
        Map<Character, Integer> counts = new HashMap<>();
        for (char c : text.toCharArray()) {
            counts.merge(c, 1, Integer::sum);
        }
        for (char c : text.toCharArray()) {
            if (counts.get(c) == 1) {
                return c;
            }
        }
        return null;
    }

    static Character firstUniqueArray(String text) {
        int[] counts = new int[256];
        for (char c : text.toCharArray()) {
            counts[c]++;
        }
        for (char c : text.toCharArray()) {
            if (counts[c] == 1) {
                return c;
            }
        }
        return null;
    }
}

In "swiss" the counts are s equals three, w equals one and i equals one, so the scan returns w — the first character in the string with a count of one, even though i is also unique. In "aabb" every character appears twice, so both methods return nothing.

The HashMap version works for any character and is the general answer. The array version is faster because it avoids hashing and boxing, but it only works for characters in the Latin-1 range, and indexing an array with a char above 255 would throw ArrayIndexOutOfBoundsException — so use the map unless you know the input is ASCII.

Two refinements worth mentioning in an interview. If you need the count of every character, a Map with merge as above is the idiomatic modern form. And if the same question comes up with case insensitivity, normalise with toLowerCase before counting, remembering that Java's default locale can turn a Turkish dotted capital I into something unexpected, which is why Locale.ROOT is the safe argument.

substring(int) and substring(int, int) take plain index positions and return the characters between them. The end index is exclusive. Calling substring with an out-of-range index throws StringIndexOutOfBoundsException, and there is a subtlety in older releases where the end index could silently wrap around — that behaviour was changed and the current contract is a clean exception.

replace takes two literal strings and replaces every occurrence of the first with the second. replaceAll takes a regular expression and a replacement, and replaceFirst replaces only the first match. The distinction bites when the search text contains regex metacharacters: replace(".", "-") turns "a.b" into "a-b", while replaceAll(".", "-") turns it into "---" because the dot matches every character.

split takes a regular expression and returns an array of the pieces. Two details cause constant confusion. Trailing empty strings are removed by default, so "a,b,,".split(",") does not end with an empty string; passing a limit of -1 keeps them. And because the argument is a regex, splitting on a literal dot requires "\\." or Pattern.quote.

public class Main {
    public static void main(String[] args) {
        System.out.println("substring    : " + "hello world".substring(0, 5));
        System.out.println("replace      : " + "a-b-c".replace("-", "+"));
        System.out.println("replaceAll   : " + "a1b2c3".replaceAll("[0-9]", ""));
        System.out.println("dot literal  : " + "a.b.c".replace(".", "-"));
        System.out.println("dot regex    : " + "a.b.c".replaceAll("\\.", "-"));
        System.out.println("split default: " + java.util.Arrays.toString("a,b,,".split(",")));
        System.out.println("split limit-1: " + java.util.Arrays.toString("a,b,,".split(",", -1)));
    }
}

The output shows both split behaviours side by side: the default call drops the trailing empty piece, while the negative limit preserves every piece including the trailing empty string. If you are parsing CSV-like data and need to know about empty fields, always pass the negative limit — otherwise the last field silently disappears.