Strings basics: interview questions & scenarios

Model answer

== compares references: are these the same object? equals() compares content: do they hold the same characters? Two Strings with identical text can be different objects, so == can be false while equals() is true. For strings you should always use equals() (or Objects.equals when either side can be null).

Model answer

String s1 = "ab";
String s2 = "a" + "b";
String a = "a";
String s3 = a + "b";
final String fa = "a";
String s4 = fa + "b";

System.out.println(s1 == s2);            // true
System.out.println(s1 == s3);            // false
System.out.println(s1 == s4);            // true
System.out.println(s1 == s3.intern());   // true

"a" + "b" is a constant expression, so javac folds it into the literal "ab", which is pooled. fa is a constant variable (final, initialised with a constant), so fa + "b" is folded too. a isn't final, so a + "b" is built at runtime with invokedynamic and is a new object. intern() returns the pooled copy.

Model answer

One or two String objects. The literal "hello" refers to a pooled String, created when the literal is first resolved if it isn't already in the pool. Then new String(...) always allocates one more String on the heap. Since Java 9 the String(String) constructor reuses the original's byte[], so the two String objects share one array.

Model answer

Four reasons, and they reinforce each other:

1. Security: paths, URLs, class names and credentials are Strings; if they could change after a security check, the check would be useless.
2. The string pool: literals can be shared JVM-wide only because nobody can modify them.
3. Hash caching: the hash is computed once and stored, which makes Strings cheap HashMap keys.
4. Thread safety: immutable objects can be shared across threads with no synchronization.

The class is also final, so no subclass can add mutable behaviour.

Model answer

An empty array. split takes a regex, and . matches any character, so every character is a delimiter and every piece is an empty string. Trailing empty strings are removed by default, which removes all of them. Use split("\\.") or split(Pattern.quote(".")) to get [a, b, c].

Model answer

String result = "";
for (String word : words) {
    result += word + " ";
}

Each += creates a new String and copies everything built so far, so total work is O(n²) in the output length. Building a 49,000-character result in 10,000 steps costs around 240 million character copies. Fix it with a single StringBuilder (pre-sized if you can estimate), or String.join(" ", words) / Collectors.joining.

Outside loops, + is fine: since Java 9 (JEP 280), a + b + c compiles to one invokedynamic call to StringConcatFactory, which computes the exact size and allocates once.

Model answer

trim() (Java 1.0) removes leading and trailing characters with a code point up to U+0020: the space and ASCII control characters. strip() (Java 11) removes characters that Character.isWhitespace considers whitespace, which includes Unicode spaces like the em space U+2003. isBlank() (Java 11) is the matching "only whitespace" check. Prefer strip() in new code.

Model answer

length() returns the number of UTF-16 code units, and characters outside the Basic Multilingual Plane, like most emoji, take two (a surrogate pair). codePointCount(0, s.length()) or codePoints().count() returns 1.

Internally, since Java 9 (compact strings), a String stores a byte[] and a coder. Pure Latin-1 text uses one byte per char; anything else, like this emoji, switches the whole string to UTF-16, two bytes per char. length() still reports code units in both cases.

Model answer

Scanner sc = new Scanner(System.in);
int age = sc.nextInt();
String name = sc.nextLine();   // ""

nextInt() reads the token 25 and stops before the newline. nextLine() then returns the rest of the current line, which is empty. Fix it by reading lines and parsing (Integer.parseInt(sc.nextLine().strip())), or by calling sc.nextLine() once to consume the leftover newline.

Model answer

The code formats numbers with String.format("%.2f", price) (or printf/formatted), which uses the JVM's default locale. On a server or user machine with a German or French locale, the decimal separator is a comma. If the output feeds a CSV, SQL or JSON, it breaks the parser. Fix: String.format(Locale.ROOT, "%.2f", price) for machine-readable output, and an explicit user locale (or NumberFormat) for display. For money, BigDecimal with explicit rounding is the right type in the first place.

Model answer

Normalise once at the boundary, then compare with content equality:

enum Status { ACTIVE, SUSPENDED, CLOSED }

static Optional<Status> parse(String raw) {
    if (raw == null || raw.isBlank()) return Optional.empty();
    String key = raw.strip().toUpperCase(Locale.ROOT);
    return switch (key) {               // hashCode + equals under the hood
        case "ACTIVE"    -> Optional.of(Status.ACTIVE);
        case "SUSPENDED" -> Optional.of(Status.SUSPENDED);
        case "CLOSED"    -> Optional.of(Status.CLOSED);
        default          -> Optional.empty();
    };
}

Inside the system you pass the enum, so later comparisons are == on enum constants, which is correct because each constant is a singleton. switch on String compiles to a switch on hashCode() plus equals(), so it's O(1) on average and content-based.