
Baeldung Pro comes with both absolutely No-Ads as well as finally with Dark Mode, for a clean learning experience:
Once the early-adopter seats are all used, the price will go up and stay at $33/year.
Last updated: January 8, 2024
In this quick tutorial, we’re going to see how we can reverse a String in Java.
We’ll start to do this processing using plain Java solutions. Next, we’ll have a look at the options that third-party libraries like Apache Commons provide.
Furthermore, we’ll demonstrate how to reverse the order of words in a sentence.
We know that strings are immutable in Java. An immutable object is an object whose internal state remains constant after it has been entirely created.
Therefore, we cannot reverse a String by modifying it. We need to create another String for this reason.
First, let’s see a basic example using a for loop. We’re going to iterate over the String input from the last to the first element and concatenate every character into a new String:
public String reverse(String input) {
if (input == null) {
return input;
}
String output = "";
for (int i = input.length() - 1; i >= 0; i--) {
output = output + input.charAt(i);
}
return output;
}
As we can see, we need to be careful with the corner cases and treat them separately.
To better understand the example, we can build a unit test:
@Test
public void whenReverseIsCalled_ThenCorrectStringIsReturned() {
String reversed = ReverseStringExamples.reverse("cat");
String reversedNull = ReverseStringExamples.reverse(null);
String reversedEmpty = ReverseStringExamples.reverse(StringUtils.EMPTY);
assertEquals("tac", reversed);
assertNull(reversedNull);
assertEquals(StringUtils.EMPTY, reversedEmpty);
}
Java also offers some mechanisms like StringBuilder and StringBuffer that create a mutable sequence of characters. These objects have a reverse() method that helps us achieve the desired result.
Here, we need to create a StringBuilder from the String input and then call the reverse() method:
public String reverseUsingStringBuilder(String input) {
if (input == null) {
return null;
}
StringBuilder output = new StringBuilder(input).reverse();
return output.toString();
}
The Stream API provides multiple convenient methods to reverse a given string.
Let’s take a close look at each option.
Typically, we can use the IntStream.range() method to reverse a particular string in a more functional style.
So, let’s see it in action:
public static String reverseUsingIntStreamRangeMethod(String str) {
if (str == null) {
return null;
}
char[] charArray = str.toCharArray();
return IntStream.range(0, str.length())
.mapToObj(i -> charArray[str.length() - i - 1])
.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
.toString();
}
As we can see, we used the range() method to return a sequentially ordered IntStream between 0 and the string’s length.
Furthermore, we chained with mapToObj() to get each character starting from the end. Then, we used StringBuilder to build the reversed string.
Now, let’s add a test case to confirm that everything works as expected:
@Test
public void whenReverseStringUsingStreamRangeMethod_ThenCorrectStringIsReturned() {
String reversed = ReverseStringExamples.reverseUsingStreamRangeMethod(STRING_INPUT);
String reversedNull = ReverseStringExamples.reverseUsingStreamRangeMethod(null);
String reversedEmpty = ReverseStringExamples.reverseUsingStreamRangeMethod(StringUtils.EMPTY);
assertEquals(STRING_INPUT_REVERSED, reversed);
assertNull(reversedNull);
assertEquals(StringUtils.EMPTY, reversedEmpty);
}
As we can see, our method works as expected for non-null, null, and empty strings.
Alternatively, we can use the Stream.of() method to achieve the same objective:
public static String reverseUsingStreamOfMethod(String str) {
if (str == null) {
return null;
}
return Stream.of(str)
.map(string -> new StringBuilder(string).reverse())
.collect(Collectors.joining());
}
As shown above, we used StringBuilder.reverse() as a mapper to invert the specified string. Then, we concatenated the result into a new String object using the joining() collector.
Now, let’s confirm this solution using another test:
@Test
public void whenReverseStringUsingStreamOfMethod_ThenCorrectStringIsReturned() {
String reversed = ReverseStringExamples.reverseUsingStreamOfMethod(STRING_INPUT);
String reversedNull = ReverseStringExamples.reverseUsingStreamOfMethod(null);
String reversedEmpty = ReverseStringExamples.reverseUsingStreamOfMethod(StringUtils.EMPTY);
assertEquals(STRING_INPUT_REVERSED, reversed);
assertNull(reversedNull);
assertEquals(StringUtils.EMPTY, reversedEmpty);
}
Another solution would be using the chars() method from the String class.
This method is introduced in Java 9 and returns an IntStream containing the code points of the string’s characters.
Simply put, a code point is a decimal value associated with a character in the Unicode standard.
Let’s exemplify the use of the chars() method:
public static String reverseUsingCharsMethod(String str) {
if (str == null) {
return null;
}
return str.chars()
.mapToObj(c -> (char) c)
.reduce("", (a, b) -> b + a, (a2, b2) -> b2 + a2);
}
In a nutshell, we used mapToObj() to convert each code point into a character. Then, we accumulated the characters in reverse order using the reduce() method.
As always, let’s create a test case to test our method:
@Test
public void whenReverseStringUsingCharsMethod_ThenCorrectStringIsReturned() {
String reversed = ReverseStringExamples.reverseUsingCharsMethod(STRING_INPUT);
String reversedNull = ReverseStringExamples.reverseUsingCharsMethod(null);
String reversedEmpty = ReverseStringExamples.reverseUsingCharsMethod(StringUtils.EMPTY);
assertEquals(STRING_INPUT_REVERSED, reversed);
assertNull(reversedNull);
assertEquals(StringUtils.EMPTY, reversedEmpty);
}
Apache Commons is a popular Java library with a lot of utility classes including string manipulation.
As usual, to get started using Apache Commons, we first need to add the Maven dependency:
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>
The StringUtils class is what we need here because it provides the reverse() method similar to StringBuilder.
One advantage of using this library is that its utility methods perform null-safe operations. So, we don’t have to treat the edge cases separately.
Let’s create a method that fulfills our purpose and uses the StringUtils class:
public String reverseUsingApacheCommons(String input) {
return StringUtils.reverse(input);
}
Now, looking at these three methods, we can certainly say that the third one is the simplest and the least error-prone way to reverse a String.
Now, let’s assume we have a sentence with words separated by spaces and no punctuation marks. We need to reverse the order of words in this sentence.
We can solve this problem in two steps: splitting the sentence by the space delimiter and then concatenating the words in reverse order.
First, we’ll show a classic approach. We’re going to use the String.split() method to fulfill the first part of our problem. Next, we’ll iterate backward through the resulting array and concatenate the words using a StringBuilder. Of course, we also need to add a space between these words:
public String reverseTheOrderOfWords(String sentence) {
if (sentence == null) {
return null;
}
StringBuilder output = new StringBuilder();
String[] words = sentence.split(" ");
for (int i = words.length - 1; i >= 0; i--) {
output.append(words[i]);
output.append(" ");
}
return output.toString().trim();
}
Second, we’ll consider using the Apache Commons library. Once again, it helps us achieve a more readable and less error-prone code. We only need to call the StringUtils.reverseDelimited() method with the input sentence and the delimiter as arguments:
public String reverseTheOrderOfWordsUsingApacheCommons(String sentence) {
return StringUtils.reverseDelimited(sentence, ' ');
}
In this tutorial, we’ve first looked at different ways of reversing a String in Java. We went through some examples using core Java and a popular third-party library like Apache Commons.
Next, we’ve seen how to reverse the order of words in a sentence in two steps. These steps can also help achieve other permutations of a sentence.