Reverse A String In Java Without Using Inbuilt Function

When manipulating strings in programming, reversing their order is a common task. While many languages provide convenient built-in methods, understanding how to achieve this manually is fundamental for deeper comprehension of string operations, algorithm design, and is often a popular interview question.

In this article, you will learn how to reverse a string in Java without relying on its built-in reverse() methods, exploring different manual approaches.

Problem Statement

The problem is to take a given string (e.g., "Java") and produce a new string where the order of its characters is inverted (e.g., "avaJ"). This task requires iterating through the original string and constructing the reversed string character by character. We aim to achieve this without using high-level utility functions that perform the reversal directly.

Example

Let's consider a simple example to illustrate the desired outcome:

• Input String: "Hello"
• Expected Output: "olleH"

Background & Knowledge Prerequisites

To effectively understand the solutions, a basic familiarity with the following Java concepts is beneficial:

• String Basics: Understanding that String objects are immutable in Java.
• char Data Type: How to work with individual characters.
• Loops: for loops for iteration.
• Arrays: Basic understanding of char[] arrays.
• StringBuilder: Awareness of its mutability for efficient string building.

Use Cases or Case Studies

Reversing a string manually has several practical applications and helps solidify core programming concepts:

• Palindrome Checking: Determining if a word or phrase reads the same forwards and backward (e.g., "madam"). Reversing the string allows for easy comparison.
• Data Transformation: In specific data processing scenarios, parts of a string might need to be reversed to match a particular format or encryption scheme.
• Text Processing Algorithms: Some custom text search or pattern matching algorithms might incorporate string reversal as a sub-step.
• Educational and Interview Contexts: It's a classic problem used to assess a candidate's understanding of string manipulation, loops, and array handling without relying on library functions.

Solution Approaches

We will explore three distinct approaches to reverse a string in Java without using built-in reverse() functions.

Approach 1: Using a for loop and charAt()

This approach iterates through the original string from the last character to the first, appending each character to a new string.

// String Reversal using charAt()
public class Main {
    public static void main(String[] args) {
        String originalString = "programming";
        String reversedString = "";

        // Step 1: Iterate from the last character to the first
        for (int i = originalString.length() - 1; i >= 0; i--) {
            // Step 2: Get the character at the current index
            char c = originalString.charAt(i);
            // Step 3: Append the character to the reversed string
            reversedString += c;
        }

        System.out.println("Original String: " + originalString);
        System.out.println("Reversed String: " + reversedString);
    }
}

Run

Sample Output:

Original String: programming
Reversed String: gnimmargorp

Stepwise Explanation:

1. Initialize an empty string reversedString which will store the result.
2. Start a for loop that iterates from the last index of the originalString (which is length() - 1) down to 0.
3. In each iteration, use originalString.charAt(i) to retrieve the character at the current index i.
4. Concatenate this character to reversedString. Since String objects are immutable, each concatenation actually creates a new String object, which can be inefficient for very long strings.

Approach 2: Using toCharArray() and a for loop

This method first converts the string into a character array. Then, it iterates through this array in reverse order, appending characters to a StringBuilder for efficient string construction.

// String Reversal using toCharArray() and StringBuilder
public class Main {
    public static void main(String[] args) {
        String originalString = "development";
        
        // Step 1: Convert the string to a character array
        char[] charArray = originalString.toCharArray();
        
        // Step 2: Use StringBuilder for efficient appending
        StringBuilder reversedBuilder = new StringBuilder();

        // Step 3: Iterate through the char array from end to beginning
        for (int i = charArray.length - 1; i >= 0; i--) {
            // Step 4: Append each character to the StringBuilder
            reversedBuilder.append(charArray[i]);
        }
        
        // Step 5: Convert StringBuilder back to a String
        String reversedString = reversedBuilder.toString();

        System.out.println("Original String: " + originalString);
        System.out.println("Reversed String: " + reversedString);
    }
}

Run

Sample Output:

Original String: development
Reversed String: tnempoevelled

Stepwise Explanation:

1. Convert the originalString into a char[] array using toCharArray().
2. Create an instance of StringBuilder. This mutable class is more efficient for building strings character by character as it avoids creating new String objects with each append operation.
3. Loop through the charArray from the last index (length - 1) down to 0.
4. In each iteration, append the character charArray[i] to the reversedBuilder.
5. Finally, convert the reversedBuilder back to a String using toString().

Approach 3: Using toCharArray() and Two Pointers (In-place Swap)

This approach is more memory-efficient as it performs the reversal "in-place" within a character array. It uses two pointers, one starting from the beginning and one from the end, swapping characters until they meet in the middle.

// String Reversal using Two Pointers
public class Main {
    public static void main(String[] args) {
        String originalString = "interview";
        
        // Step 1: Convert the string to a character array
        char[] charArray = originalString.toCharArray();
        
        // Step 2: Initialize two pointers
        int left = 0;
        int right = charArray.length - 1;

        // Step 3: Swap characters until pointers meet or cross
        while (left < right) {
            // Step 3a: Swap charArray[left] and charArray[right]
            char temp = charArray[left];
            charArray[left] = charArray[right];
            charArray[right] = temp;

            // Step 3b: Move pointers towards the center
            left++;
            right--;
        }
        
        // Step 4: Convert the modified char array back to a String
        String reversedString = new String(charArray);

        System.out.println("Original String: " + originalString);
        System.out.println("Reversed String: " + reversedString);
    }
}

Run

Sample Output:

Original String: interview
Reversed String: weivretni

Stepwise Explanation:

1. Convert the originalString into a char[] array.
2. Initialize two integer pointers: left to 0 (start of the array) and right to charArray.length - 1 (end of the array).
3. Enter a while loop that continues as long as left is less than right. This ensures characters are swapped only once and the pointers don't cross over unnecessarily.
4. Inside the loop, swap the characters at charArray[left] and charArray[right] using a temporary char variable.
5. Increment left and decrement right to move the pointers closer to the center of the array.
6. Once the loop finishes, the charArray now contains the reversed sequence of characters.
7. Finally, construct a new String object from the modified charArray.

Conclusion

Reversing a string without built-in functions is a practical exercise that reinforces fundamental programming concepts. We've explored three different manual approaches: character concatenation using charAt(), efficient building with StringBuilder after toCharArray(), and the memory-efficient in-place swap using two pointers on a char[] array. Each method has its own trade-offs regarding performance and memory usage, with the StringBuilder and two-pointer approaches generally being more efficient than repeated string concatenation.

Summary

• Problem: Reverse a string's character order without using String.reverse() or similar library functions.
• Approach 1 (Loop + charAt()): Iterates backward, concatenating characters to a new string. Simple but less efficient due to String immutability.
• Approach 2 (toCharArray() + StringBuilder): Converts to char[], then iterates backward appending to a StringBuilder. More efficient for string building.
• Approach 3 (toCharArray() + Two Pointers): Converts to char[], uses left and right pointers to swap characters in place, then converts back to String. Most memory-efficient as it modifies the array directly.
• Understanding these manual techniques is crucial for algorithmic thinking and common in technical interviews.