Reverse a string in Java

Question

I have "Hello World" kept in a String variable named hi.

I need to print it, but reversed.

How can I do this? I understand there is some kind of a function already built-in into Java that does that.

Related: Reverse each individual word of "Hello World" string with Java

• Matthew Farwell: @JRL should really be String ih = "dlroW olleH"; System.out.println(ih)
• Rob Hruska: I wish I could retract my close vote (as a duplicate). I re-read the other question and realized it's subtly different than this. However, this question is still duplicated many times over across the site. Probably ought to just find a different question to mark this a dupe of.

Answer 1

You can use this:

new StringBuilder(hi).reverse().toString()

StringBuilder was added in Java 5. For versions prior to Java 5, the StringBuffer class can be used instead — it has the same API.

• ha9u63a7: "Thanks commentators for pointing out that StringBuilder is preferred nowadays"? There is a clear statement that StringBuffer if thread-safety is a concern. otherwise, StringBuilder can be used. StringBuilder is not a replacement for StringBuffer.
• xehpuk: @ha9u63ar For this scenario with a local throwaway StringBuilder concurrency is not a concern (and I think that's what he meant).
• Vishnu Narang: Here's the link to know the exact difference between the two: javatpoint.com/… in short: StringBuilder is more efficient than StringBuffer. It's not thread safe i.e. multiple threads can simultaneously call methods of StringBuilder.
• nau: This won't work for Unicode characters outside of BMP, as long as for combining characters.
• Mahesh Sharma: Hi Sir, Subject: Request to Update Broken Link – Javatpoint.com to TpointTech.com I hope you’re doing well. I recently noticed that your website contains links to Javatpoint.com, which has now moved to TpointTech.com. Would it be possible to replace the broken links to Javatpoint.com with the corresponding pages on TpointTech.com? I’d be happy to provide the updated URLs if needed. Looking forward to your response. Best regards, Mahesh Sharma [email protected] TpointTech.com

Answer 2

For Online Judges problems that does not allow StringBuilder or StringBuffer, you can do it in place using char[] as following:

public static String reverse(String input){
 char[] in = input.toCharArray();
 int begin=0;
 int end=in.length-1;
 char temp;
 while(end>begin){
 temp = in[begin];
 in[begin]=in[end];
 in[end] = temp;
 end--;
 begin++;
 }
 return new String(in);
}

• Minas Mina: Just a note though. This will fail horribly for "characters" that occupy two bytes.
• Stephen C: Actually, it typically works fine for most characters that occupy 2 bytes. What it actually fails for is Unicode codepoints that occupy 2 x 16 bit codeunits (in UTF-16).

Answer 3

public static String reverseIt(String source) {
 int i, len = source.length();
 StringBuilder dest = new StringBuilder(len);
 for (i = (len - 1); i >= 0; i--){
 dest.append(source.charAt(i));
 }
 return dest.toString();
}

http://www.java2s.com/Code/Java/Language-Basics/ReverseStringTest.htm

• Michał Šrajer: Good solution (1+). One enhancement - StringBuilder (since java5) will be faster than StringBuffer. Regards.
• Ian Fairman: This won't work in the general case as it doesn't take into account that some "characters" in unicode are represented by a surrogate pair i.e. two Java chars, and this solution results in the pair being in the wrong order. The reverse method of StringBuilder should be fine according to the JavaDoc: docs.oracle.com/javase/7/docs/api/java/lang/…
• rogerdpack: Does it reverse unicode diacriticals in the right order?

Answer 4

String string="whatever";
String reverse = new StringBuffer(string).reverse().toString();
System.out.println(reverse);

• Mukit09: What is the complexity of it? O(N) or more ? N is equal to length of the string.
• PlsWork: O(n) since it has to iterate through the chars of the string at least once.

Answer 5

I am doing this by using the following two ways:

Reverse string by CHARACTERS:

public static void main(String[] args) {
 // Using traditional approach
 String result="";
 for(int i=string.length()-1; i>=0; i--) {
 result = result + string.charAt(i);
 }
 System.out.println(result);
 // Using StringBuffer class
 StringBuffer buffer = new StringBuffer(string);
 System.out.println(buffer.reverse()); 
}

Reverse string by WORDS:

public static void reverseStringByWords(String string) {
 StringBuilder stringBuilder = new StringBuilder();
 String[] words = string.split(" ");
 for (int j = words.length-1; j >= 0; j--) {
 stringBuilder.append(words[j]).append(' ');
 }
 System.out.println("Reverse words: " + stringBuilder);
}

• Ehsan Mashhadi: better to use StringBuilder/StringBuffer for the result variable to avoid multiple object creation!

Answer 6

Take a look at the Java 6 API under StringBuffer

String s = "sample";
String result = new StringBuffer(s).reverse().toString();

• CamHart: is this better than StringBuilder?
• jcsahnwaldt Reinstate Monica: @CamHart No, it's slower, but probably only a tiny little bit.
• jcsahnwaldt Reinstate Monica: A little benchmark with almost 100 million method calls showed a significant difference between StringBuffer and StringBuilder: stackoverflow.com/questions/355089/… But in this case, there are only two calls (reverse() and toString()), so the difference probably won't even be measurable.

Answer 7

Here is an example using recursion:

public void reverseString() {
 String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 String reverseAlphabet = reverse(alphabet, alphabet.length()-1);
}
String reverse(String stringToReverse, int index){
 if(index == 0){
 return stringToReverse.charAt(0) + "";
 }
 char letter = stringToReverse.charAt(index);
 return letter + reverse(stringToReverse, index-1);
}

• Willi Mentzel: There are already far better answers, especially @DanielBrockman's. If an algorithm already exists in a standard library, there is no need to handcraft it and reinvent the wheel.
• C0D3LIC1OU5: A "far better answer" concept is subjective. This may be exactly what someone is looking for.
• Willi Mentzel: The OP already stated that "there is some kind of a function already built-in into Java that does that" so his goal was to know exactly which "function" this is. Just posting an answer that has little to do with the actual question asked is non-sense. If someone was to ask for a custom implementation your answer would be justified, in this case it is not.
• jcsahnwaldt Reinstate Monica: Downvote. Most other solutions are O(n) and can handle strings of pretty much any length, this one is O(n^2) and tends to crash with a StackOverflowError for strings longer than about 5000 chars (on JDK 8 VM, default config).
• jcsahnwaldt Reinstate Monica: Well, maybe you didn't read jonskeet.uk/csharp/stringbuilder.html , or maybe you didn't understand it. Hint: String concatenation is fine if you create a string in one fell swoop, but not if you build a string in a loop (and in this case, recursion is a loop). Yeah, I do get a bit personal when people post bad code on SO and don't even understand what's bad about it. Good bye.

Answer 8

Using charAt() method

String name = "gaurav";
String reversedString = "";
 
for(int i = name.length() - 1; i >= 0; i--){
 reversedString += name.charAt(i);
}
System.out.println(reversedString);

Using toCharArray() method

String name = "gaurav";
char [] stringCharArray = name.toCharArray();
String reversedString = "";
 
for(int i = stringCharArray.length - 1; i >= 0; i--) {
 reversedString += stringCharArray[i];
}
System.out.println(reversedString);

Using reverse() method of the StringBuilder

String name = "gaurav";
 
String reversedString = new StringBuilder(name).reverse().toString();
 
System.out.println(reversedString);

Check https://coderolls.com/reverse-a-string-in-java/

Answer 9

Since the below method (using XOR) to reverse a string is not listed, I am attaching this method to reverse a string.

The Algorithm is based on :

1.(A XOR B) XOR B = A

2.(A XOR B) XOR A = B

Code snippet:

public class ReverseUsingXOR {
 public static void main(String[] args) {
 String str = "prateek";
 reverseUsingXOR(str.toCharArray());
 } 
 /*Example:
 * str= prateek;
 * str[low]=p;
 * str[high]=k;
 * str[low]=p^k;
 * str[high]=(p^k)^k =p;
 * str[low]=(p^k)^p=k;
 * 
 * */
 public static void reverseUsingXOR(char[] str) {
 int low = 0;
 int high = str.length - 1;
 while (low < high) {
 str[low] = (char) (str[low] ^ str[high]);
 str[high] = (char) (str[low] ^ str[high]); 
 str[low] = (char) (str[low] ^ str[high]);
 low++;
 high--;
 }
 //display reversed string
 for (int i = 0; i < str.length; i++) {
 System.out.print(str[i]);
 }
 }
}

Output:

keetarp

Answer 10

Here is a low level solution:

import java.util.Scanner;
public class class1 {
 public static void main(String[] args) {
 Scanner in = new Scanner(System.in);
 String inpStr = in.nextLine();
 System.out.println("Original String :" + inpStr);
 char temp;
 char[] arr = inpStr.toCharArray();
 int len = arr.length;
 for(int i=0; i<(inpStr.length())/2; i++,len--){
 temp = arr[i];
 arr[i] = arr[len-1];
 arr[len-1] = temp;
 }
 System.out.println("Reverse String :" + String.valueOf(arr));
 }
}

Answer 11

I tried, just for fun, by using a Stack. Here my code:

public String reverseString(String s) {
 Stack<Character> stack = new Stack<>();
 StringBuilder sb = new StringBuilder();
 for (int i = 0; i < s.length(); i++) {
 stack.push(s.charAt(i));
 }
 while (!stack.empty()) {
 sb.append(stack.pop());
 }
 return sb.toString();
}

Answer 12

As others have pointed out the preferred way is to use:

new StringBuilder(hi).reverse().toString()

But if you want to implement this by yourself, I'm afraid that the rest of responses have flaws.

The reason is that String represents a list of Unicode points, encoded in a char[] array according to the variable-length encoding: UTF-16.

This means some code points use a single element of the array (one code unit) but others use two of them, so there might be pairs of characters that must be treated as a single unit (consecutive "high" and "low" surrogates).

public static String reverseString(String s) {
 char[] chars = new char[s.length()];
 boolean twoCharCodepoint = false;
 for (int i = 0; i < s.length(); i++) {
 chars[s.length() - 1 - i] = s.charAt(i);
 if (twoCharCodepoint) {
 swap(chars, s.length() - 1 - i, s.length() - i);
 }
 twoCharCodepoint = !Character.isBmpCodePoint(s.codePointAt(i));
 }
 return new String(chars);
}
private static void swap(char[] array, int i, int j) {
 char temp = array[i];
 array[i] = array[j];
 array[j] = temp;
}
public static void main(String[] args) throws Exception {
 FileOutputStream fos = new FileOutputStream("C:/temp/reverse-string.txt");
 StringBuilder sb = new StringBuilder("Linear B Syllable B008 A: ");
 sb.appendCodePoint(65536); //http://unicode-table.com/es/#10000
 sb.append(".");
 fos.write(sb.toString().getBytes("UTF-16"));
 fos.write("\n".getBytes("UTF-16"));
 fos.write(reverseString(sb.toString()).getBytes("UTF-16"));
}

• René: Good solution, only part missing is now handling of combining diacritics :-D

Answer 13

It is very simple in minimum code of lines

public class ReverseString {
 public static void main(String[] args) {
 String s1 = "neelendra";
 for(int i=s1.length()-1;i>=0;i--)
 {
 System.out.print(s1.charAt(i));
 }
 }
}

• Jency: I was going to write this now.. Found you have already written it !

Answer 14

System.out.print("Please enter your name: ");
String name = keyboard.nextLine();
String reverse = new StringBuffer(name).reverse().toString();
String rev = reverse.toLowerCase();
System.out.println(rev);

I used this method to turn names backwards and into lower case.

Answer 15

One natural way to reverse a String is to use a StringTokenizer and a stack. Stack is a class that implements an easy-to-use last-in, first-out (LIFO) stack of objects.

String s = "Hello My name is Sufiyan";

Put it in the stack frontwards

Stack<String> myStack = new Stack<>();
StringTokenizer st = new StringTokenizer(s);
while (st.hasMoreTokens()) {
 myStack.push(st.nextToken());
}

Print the stack backwards

System.out.print('"' + s + '"' + " backwards by word is:\n\t\"");
while (!myStack.empty()) {
 System.out.print(myStack.pop());
 System.out.print(' ');
}
System.out.println('"');

Answer 16

This did the trick for me

public static void main(String[] args) {
 String text = "abcdefghijklmnopqrstuvwxyz";
 for (int i = (text.length() - 1); i >= 0; i--) {
 System.out.print(text.charAt(i));
 }
}

Answer 17

1. Using Character Array:

public String reverseString(String inputString) {
 char[] inputStringArray = inputString.toCharArray();
 String reverseString = "";
 for (int i = inputStringArray.length - 1; i >= 0; i--) {
 reverseString += inputStringArray[i];
 }
 return reverseString;
}

2. Using StringBuilder:

public String reverseString(String inputString) {
 StringBuilder stringBuilder = new StringBuilder(inputString);
 stringBuilder = stringBuilder.reverse();
 return stringBuilder.toString();
}

OR

return new StringBuilder(inputString).reverse().toString();

Answer 18

 public String reverse(String s) {
 String reversedString = "";
 for(int i=s.length(); i>0; i--) {
 reversedString += s.charAt(i-1);
 } 
 return reversedString;
 }

• hyperneutrino: Again, surrogate pairs will become corrupted with this way.
• Dom Shahbazi: @JamesSmith could you expand on this please?
• hyperneutrino: Some unicode characters consist of two characters; if these two are switched around, the string is corrupted. Also, one commonly overlooked error is regex.

Answer 19

You can also try this:

public class StringReverse {
 public static void main(String[] args) {
 String str = "Dogs hates cats";
 StringBuffer sb = new StringBuffer(str);
 System.out.println(sb.reverse());
 }
}

• Anurag Goel: there are many method to reverse a string.this is one of them using stringbuffer class of java.accepted answer is using diff class to reverse which is not available in older version of JDK.

Answer 20

public class Test {
public static void main(String args[]) {
 StringBuffer buffer = new StringBuffer("Game Plan");
 buffer.reverse();
 System.out.println(buffer);
 } 
}

• Ryan: This doesn't answer the question.

Answer 21

All above solution is too good but here I am making reverse string using recursive programming.

This is helpful for who is looking recursive way of doing reverse string.

public class ReversString {
public static void main(String args[]) {
 char s[] = "Dhiral Pandya".toCharArray();
 String r = new String(reverse(0, s));
 System.out.println(r);
}
public static char[] reverse(int i, char source[]) {
 if (source.length / 2 == i) {
 return source;
 }
 char t = source[i];
 source[i] = source[source.length - 1 - i];
 source[source.length - 1 - i] = t;
 i++;
 return reverse(i, source);
}
}

Answer 22

Procedure :

We can use split() to split the string .Then use reverse loop and add the characters.

---

Code snippet:

class test
{
 public static void main(String args[]) 
 {
 String str = "world";
 String[] split= str.split("");
 String revers = "";
 for (int i = split.length-1; i>=0; i--)
 {
 revers += split[i];
 }
 System.out.printf("%s", revers);
 } 
}
 //output : dlrow

---

Answer 23

Sequence of characters (or) String^{String's Family} :

String testString = "Yashwanth@777"; // ~1 1⁄4→D80016«220

Using Java 8 Stream API

First we convert String into stream by using method CharSequence.chars(), then we use the method IntStream.range to generate a sequential stream of numbers. Then we map this sequence of stream into String.

public static String reverseString_Stream(String str) {
 IntStream cahrStream = str.chars();
 final int[] array = cahrStream.map( x -> x ).toArray();
 int from = 0, upTo = array.length;
 IntFunction<String> reverseMapper = (i) -> ( Character.toString((char) array[ (upTo - i) + (from - 1) ]) );
 String reverseString = IntStream.range(from, upTo) // for (int i = from; i < upTo ; i++) { ... }
 .mapToObj( reverseMapper ) // array[ lastElement ]
 .collect(Collectors.joining()) // Joining stream of elements together into a String.
 .toString(); // This object (which is already a string!) is itself returned.
 System.out.println("Reverse Stream as String : "+ reverseString);
 return reverseString;
}

Using a Traditional for Loop

If you want to reverse the string then we need to follow these steps.

• Convert String into an Array of Characters.
• Iterate over an array in reverse order, append each Character to temporary string variable until the last character.

public static String reverseString( String reverse ) {
 if( reverse != null && reverse != "" && reverse.length() > 0 ) {
 char[] arr = reverse.toCharArray();
 String temp = "";
 for( int i = arr.length-1; i >= 0; i-- ) {
 temp += arr[i];
 }
 System.out.println("Reverse String : "+ temp);
 }
 return null;
}

Easy way to Use reverse method provided form StringBuffer or StringBuilder Classes

StringBuilder and StringBuffer are mutable sequence of characters. That means one can change the value of these object's.

StringBuffer buffer = new StringBuffer(str);
System.out.println("StringBuffer - reverse : "+ buffer.reverse() );
String builderString = (new StringBuilder(str)).reverse().toString;
System.out.println("StringBuilder generated reverse String : "+ builderString );

StringBuffer has the same methods as the StringBuilder, but each method in StringBuffer is synchronized so it is thread safe.

Answer 24

public static String revString(String str){
 char[] revCharArr = str.toCharArray();
 for (int i=0; i< str.length()/2; i++){
 char f = revCharArr[i];
 char l = revCharArr[str.length()-i-1];
 revCharArr[i] = l;
 revCharArr[str.length()-i-1] = f;
 }
 String revStr = new String(revCharArr);
 return revStr;
}

Answer 25

Simple For loop in java

 public void reverseString(char[] s) {
 int length = s.length;
 for (int i = 0; i < s.length / 2; i++) {
 // swaping character
 char temp = s[length - i - 1];
 s[length - i - 1] = s[i];
 s[i] = temp;
 }
}

Answer 26

The short answer is that Java does not provide a general solution to reversing a String due to the "surrogate pairs" problem, which you have to allow for.

If the requirement is that it is guaranteed to work for all Unicode and in all languages (including Welsh :), then you have to roll your own. Just do an in-place array swap of the string as its code points:

public static String reverse(String str)
{
 // You get what you ask for ;)
 if (str == null) return null;
 // str.length() is equal to the number of unicode code points in a string
 if (str.isEmpty() || str.length() == 1) return str;
 final int[] codePoints = str.codePoints().toArray();
 final int len = codePoints.length;
 // swap in place
 for(int i = 0; i < codePoints.length/2; i++)
 {
 int tmp = codePoints[i];
 codePoints[i] = codePoints[len-i-1];
 codePoints[len-i-1] = tmp;
 }
 return new String(codePoints,0,len);
}

If you do this by using String.getBytes(), then all the bytes will be reversed, which will reverse all UTF-8 encodings, and any attempt using a Character that isn't an int code point will fail with any "astral plane" code points (those outside the BMP).

As a general solution this is reasonably efficient, but it is extremely simple and guaranteed to work for any string, which is probably want you want from a "general solution".

The only gotcha is if you read the String out of a UTF8/16 encoded file, you might have a BOM at the start, but that's outside the scope of the question.

-Blue

Answer 27

Using apache.commons.lang3

StringUtils.reverse(hi)

Answer 28

 String str = "Hello World";
 char[] strCharArr = str.toCharArray();
 for(int i = 0, k= strCharArr.length-1;i != k; i++, k--) {
 char temp = strCharArr[i];
 strCharArr[i] = strCharArr[k];
 strCharArr[k] = temp;
 }
 System.out.println(String.valueOf(strCharArr));

Answer 29

The following Solution worked for me

public class ReverseString {
public static void reverseString(char[] s) {
 int i = 0;
 int j = s.length - 1;
 while (i < j) {
 char temp = s[i];
 s[i] = s[j];
 s[j] = temp;
 i++;
 j--;
 }
}
public static void main(String[] args) {
 char[] input = {'h', 'e', 'l', 'l', 'o'};
 reverseString(input);
 System.out.println(new String(input)); // Output: "olleh"
}

Answer 30

It gets the value you typed and returns it reversed ;)

public static String reverse (String a){
 char[] rarray = a.toCharArray();
 String finalvalue = "";
 for (int i = 0; i < rarray.length; i++)
 {
 finalvalue += rarray[rarray.length - 1 - i];
 } 
return finalvalue;

}