Reverse a String in Java

Reversing a string is a common task in Java programming, and there are several ways to accomplish this. In this tutorial, we’ll explore four different methods for reversing a string in Java, using the StringBuilder class, the for loop, recursion, and a character array. We’ll provide examples of each method and explain how they work. By the end of this tutorial, you’ll have a solid understanding of how to reverse a string in Java using a variety of different techniques.

Reverse a String in Java using the StringBuilder class

To reverse a string in Java, we can create a new StringBuilder object using the original string as input and then call the reverse() method on the StringBuilder object. Finally, we can convert the StringBuilder object back to a string using the toString() method.

Example:

public class Test {

  public static void main(String[] args) {

    String stringToReverse = "Hello World of Java!";

    StringBuilder stringBuilder = new StringBuilder(stringToReverse);

    String result = stringBuilder.reverse().toString();

    System.out.println(result);

  }
}

!avaJ fo dlroW olleH

Reverse a String using the for loop

The following example shows how we can reverse a String using a for loop:

public class Test {

  public static void main(String[] args) {
    String reversedString = "";

    String stringToReverse = "Hello World of Java!";

    char[] array = stringToReverse.toCharArray();

    // reversed iteration
    for (int i = array.length - 1; i >= 0; i--) {
      reversedString += array[i];
    }

    System.out.println(reversedString);

  }
}

Output: 

!avaJ fo dlroW olleH

Reverse a String using Recursion

In Java, you can also reverse a String using recursion. Recursion is a process where a method calls itself repeatedly until a base case is reached. The base case is the point at which the method stops calling itself and returns a value.

To reverse a String using recursion, you can create a method that takes in a String as input and calls itself recursively, removing one character from the String at each recursive call until the String is empty. At each recursive call, you can concatenate the removed character with the result of the previous recursive call. Once the String is empty, you can return the concatenated String as the reversed String.

Here’s an example of a Java method that reverses a String using recursion:

public static String reverseStringRecursive(String str) {
    if (str.isEmpty()) {
        return str;
    }
    return reverseStringRecursive(str.substring(1)) + str.charAt(0);
}

In this method, the base case is when the String is empty, at which point the method returns the empty String. Otherwise, the method calls itself recursively with the substring of the original String starting from index 1, and concatenates the first character of the original String to the result of the recursive call.

Here’s an example of how to call this method and print the reversed String:

String original = "hello world";
String reversed = reverseStringRecursive(original);
System.out.println("Original String: " + original);
System.out.println("Reversed String: " + reversed);

Output:

Original String: hello world
Reversed String: dlrow olleh

One advantage of the recursion method is its simplicity and elegance, making it easier to read and understand. However, this method may not be as efficient as other methods for large strings, as each recursive call creates a new String object.

Reverse a String using the Char Array

Another way to reverse a string in Java is to convert it to a character array, reverse the order of the characters in the array, and then convert the array back to a string. Here’s how you can do it:

public static String reverseStringCharArray(String str) {
    char[] charArray = str.toCharArray();
    int i = 0;
    int j = str.length() - 1;
    while (i < j) {
        char temp = charArray[i];
        charArray[i] = charArray[j];
        charArray[j] = temp;
        i++;
        j--;
    }
    return new String(charArray);
}

In this code, we start by converting the string to a character array using the toCharArray() method. We then use two pointers, i and j, to traverse the array from both ends. We swap the characters at positions i and j, and continue traversing until the pointers meet in the middle of the array. Finally, we convert the character array back to a string using the String(char[] value) constructor.

Here’s an example of how to use this method to reverse a string:

String original = "Hello, world!";
String reversed = reverseStringCharArray(original);
System.out.println(reversed); 

Output:

!dlrow ,olleH

One advantage of this approach is that it doesn’t require any additional classes or methods, and can be implemented using basic Java operations. However, it does require creating a new character array, which can be inefficient for very large strings.

Conclusion

Reversing a string is a fundamental task in Java programming, and it’s important to understand the different methods that are available for accomplishing this task. In this tutorial, we’ve explored four different approaches to reverse a string in Java, including using the StringBuilder class, the for loop, recursion, and a character array. Each method has its own advantages and disadvantages, and choosing the right method for your specific use case will depend on factors such as the size of the string and the performance requirements of your program. By mastering these techniques, you’ll be well-equipped to handle a wide range of string reversal tasks in your Java programs.