Reverse a string

• Immutability – Java String cannot be reversed in place; a new character sequence must be created.
• StringBuilder approach – new StringBuilder(s).reverse().toString() is concise, correct, and handles surrogate pairs.
• Manual approach – convert to char[] and swap with two pointers, then build a new String from the array.
• O(n) time – every character is visited once.
• O(n) space – a new string of the same length must be allocated.

What is the problem?

Given a string, produce a new string with the characters in reversed order. In a banking context, Rajesh's transaction reference "TXN123" at National Bank of India is reversed to "321NXT" as a lightweight verification code printed on the receipt.

Why can you not reverse a String in place in Java?

Java's String class is immutable. Once created, its characters cannot be changed. Any "reversal" must create a new String. This is a design choice that makes strings safe for use as HashMap keys, thread-safe by default, and suitable for the string pool.

How do you reverse using StringBuilder?

StringBuilder is a mutable character buffer. Its reverse() method flips the characters in place inside the builder, and toString() produces the final String.

package com.bank.service;

public class ReferenceCodeGenerator {

    public static String reverseWithBuilder(String input) {
        if (input == null) {
            throw new IllegalArgumentException("Input cannot be null");
        }
        return new StringBuilder(input).reverse().toString();
    }

    public static void main(String[] args) {
        String txnId = "TXN123";
        String reversed = reverseWithBuilder(txnId);
        System.out.println("Original:  " + txnId);
        System.out.println("Reversed:  " + reversed);
    }
}

Original:  TXN123
Reversed:  321NXT

How do you reverse manually with a char array?

Convert the string to a char[], apply the two-pointer swap technique from both ends, and build a new String from the modified array.

public static String reverseManual(String input) {
    if (input == null) {
        throw new IllegalArgumentException("Input cannot be null");
    }
    char[] chars = input.toCharArray();
    int left = 0;
    int right = chars.length - 1;
    while (left < right) {
        char temp = chars[left];
        chars[left] = chars[right];
        chars[right] = temp;
        left++;
        right--;
    }
    return new String(chars);
}

How do the two approaches compare?

| Aspect | StringBuilder.reverse() | Manual char[] swap |
|---|---|---|
| Code length | One line | 10+ lines |
| Surrogate pairs | Handled correctly | Broken by naive swap |
| Performance | Same O(n) | Same O(n) |
| Interview value | Shows API knowledge | Shows pointer control |

What is the Unicode surrogate pair problem?

A single visible character outside the Basic Multilingual Plane (like certain emoji or rare scripts) is stored as two char values called a surrogate pair. Naive char-by-char reversal splits the pair, producing a corrupted string. StringBuilder.reverse detects surrogate pairs and keeps them intact, which is one reason to prefer it in production.

// Surrogate pair example
String emoji = "A\uD83D\uDE00B"; // A😀B
String broken = reverseManual(emoji);  // may corrupt the emoji
String correct = reverseWithBuilder(emoji); // keeps emoji intact

What is the time and space complexity?

• Time: O(n) because every character is visited once.
• Space: O(n) because a new string of the same length must be allocated. The original string is immutable and unchanged.

What are common mistakes?

The most common mistake is trying to use recursion, which creates O(n) stack frames and O(n^2) string concatenation if done naively. Another mistake is forgetting that String is immutable and expecting in-place modification.

// Wrong: O(n^2) recursive approach
public static String reverseRecursive(String s) {
    if (s.isEmpty()) return s;
    return reverseRecursive(s.substring(1)) + s.charAt(0);
    // Each + creates a new String, total work is O(n^2)
}

// Correct: use StringBuilder or char[] swap for O(n)

What should a senior engineer know?

A senior engineer prefers StringBuilder.reverse in production for surrogate pair safety and recommends the char-array approach only in an interview to demonstrate two-pointer mechanics. The senior also knows that for very large strings, the char-array approach avoids the overhead of StringBuilder's internal capacity management, but in practice the difference is negligible. If the reversed string is only needed for comparison, such as a palindrome check, the senior avoids creating the reversed string at all and instead compares characters from both ends directly.