Reverse String in Java | Fresher Interview Question

Direct Answer

Convert the string to a char[] and swap with two pointers - one at the start, one at the end - moving inward until they meet. This is O(n) time and O(n) space for the char array (or O(1) extra if you reverse the array in place). Strings are immutable in Java, so you build a new string from the reversed characters.

Deep Dive & Architecture

A Java String is immutable, so its characters cannot be swapped in place. A simple manual solution first calls toCharArray(), swaps matching positions, and builds a new String from the changed array.

Worked example: java

Put left at index 0 and right at index 3. Swap j and a, giving aavj. Move both pointers inward and swap the middle a and v, giving avaj. The pointers have now crossed, so the reverse is complete.

The invariant is that everything outside [left, right] is already in its final position. Each swap settles two characters, which is why the loop only needs to reach the center. A one-character or empty string needs no swap.

The loop is O(n) and the character array uses O(n) space. That extra array is unavoidable when the input is a String, because the original object cannot be modified. If the method receives a mutable char[], the same two-pointer loop uses O(1) extra space.

For interview-sized ASCII examples this is enough. For full Unicode text, one visible symbol may use more than one UTF-16 char; reversing code points is safer when emoji or supplementary characters must remain intact.

Code Example

String reverse(String s) {
    char[] c = s.toCharArray();
    int i = 0, j = c.length - 1;
    while (i < j) {
        char tmp = c[i];        // swap ends
        c[i] = c[j];
        c[j] = tmp;
        i++; j--;               // move inward
    }
    return new String(c);
}

// "java" -> c = [j,a,v,a]
// i=0,j=3: swap -> [a,a,v,j]; i=1,j=2: swap -> [a,v,a,j]; i=2,j=1 stop
// result: "avaj"

Without the manual rule, new StringBuilder(s).reverse().toString() does the same in one line - but interviewers usually want the loop.

Common Mistakes & Pitfalls

• Mutating the String: s.charAt(i) = x doesn't compile - strings are immutable; use a char[].
• Swapping past the middle: looping while i <= j (or to the end) re-swaps and un-reverses.
• Concatenation in a loop: building the reversed string with result += c is O(n^2); use a char array or StringBuilder.
• Unicode: surrogate pairs (emoji) need care - per-char reversal can split them.