Reverse a string in Java
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
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.
35 Answers 35
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.
«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.
@ha9u63ar For this scenario with a local throwaway StringBuilder concurrency is not a concern (and I think that’s what he meant).
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.
@Daniel Brockman, Thank you for your nice and concise answer. Here OP said, I have «Hello World» kept in a String variable named hi . That means String hi = «Hello World»; . So I think in your answer there should not be any double quotes around hi . I mean it should be like this new StringBuilder(hi).reverse().toString()
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); > 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).
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(); > Good solution (1+). One enhancement — StringBuilder (since java5) will be faster than StringBuffer. Regards.
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/…
String string="whatever"; String reverse = new StringBuffer(string).reverse().toString(); System.out.println(reverse); 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); > Take a look at the Java 6 API under StringBuffer
String s = "sample"; String result = new StringBuffer(s).reverse().toString(); 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.
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); > 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.
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.
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).
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.
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; iSystem.out.println("Reverse String :" + String.valueOf(arr)); > > I tried, just for fun, by using a Stack. Here my code:
public String reverseString(String s) < Stackstack = 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(); > 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
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]); >> > 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")); >Using charAt() method
String name = "gaurav"; String reversedString = ""; for(int i = name.length()-1; i>=0; i--) < reversedString = 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 = 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); 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)); >> > 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)); >> 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)
return new StringBuilder(inputString).reverse().toString(); 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.
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 myStack = new Stack<>(); StringTokenizer st = new StringTokenizer(s); while (st.hasMoreTokens())
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('"'); public String reverse(String s) < String reversedString = ""; for(int i=s.length(); i>0; i--) < reversedString += s.charAt(i-1); >return reversedString; > Some unicode characters consist of two characters; if these two are switched around, the string is corrupted. Also, one commonly overlooked error is regex.
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); > > public class StringReverse < public static void main(String[] args) < String str = "Dogs hates cats"; StringBuffer sb = new StringBuffer(str); System.out.println(sb.reverse()); >> 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.
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 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; public String reverseWords(String s)
String reversedWords = ""; if(s.length()<=0) < return reversedWords; >else if(s.length() == 1) < if(s == " ")< return ""; >return s; > char arr[] = s.toCharArray(); int j = arr.length-1; while(j >= 0 )< if( arr[j] == ' ')< reversedWords+=arr[j]; >else< String temp=""; while(j>=0 && arr[j] != ' ') < temp+=arr[j]; j--; >j++; temp = reverseWord(temp); reversedWords+=temp; > j--; > String[] chk = reversedWords.split(" "); if(chk == null || chk.length == 0) < return ""; >return reversedWords; > public String reverseWord(String s) < char[] arr = s.toCharArray(); for(int i=0,j=arr.length-1;i<=j;i++,j--)< char tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; >return String.valueOf(arr); > public static void main(String[] args) < String str = "Prashant"; int len = str.length(); char[] c = new char[len]; for (int j = len - 1, i = 0; j >= 0; j--, i++) < c[i] = str.charAt(j); >str = String.copyValueOf(c); System.out.println(str); > Any answer to this question that doesn’t use a built-in reverse() method is basically a wrong answer.
Agreed, especially as these «simple» solutions don’t take into account surrogate pairs and can actually corrupt the string — see my comment above.
public void reverString()< System.out.println("Enter value"); BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); try< String str=br.readLine(); char[] charArray=str.toCharArray(); for(int i=charArray.length-1; i>=0; i--) < System.out.println(charArray[i]); >> catch(IOException ex) public String stringReverse(String string) < if (string == null || string.length() == 0) < return string; >return stringReverse(string.substring(1)) + string.charAt(0); > Sequence of characters (or) String String’s Family :
String testString = "Yashwanth@777"; // ~1 1⁄4→D800₁₆«2²⁰ 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 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.