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

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.

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);
}

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

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();

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);
}

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));
	}
}

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();

}

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

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);

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

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) {
    StringBuilder stringBuilder = new StringBuilder(inputString);
    stringBuilder = stringBuilder.reverse();
    return stringBuilder.toString();
}

OR

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<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('"');

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

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());
	}
}

public class Test {

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

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);

}

}

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

---

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);
}

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 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){
  }

recursion:

 public String stringReverse(String string) {
    if (string == null || string.length() == 0) {
        return string;
    }
    return stringReverse(string.substring(1)) + string.charAt(0);
 }

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;
}

import java.util.Scanner;

public class Test {

    public static void main(String[] args){
	    Scanner input = new Scanner (System.in);
		String word = input.next();
    	String reverse = "";
	    for(int i=word.length()-1; i>=0; i--)
		    reverse += word.charAt(i);
		System.out.println(reverse);		
    }
}

If you want to use a simple for loop!

package logicprogram;
import java.io.*;

public class Strinrevers {
public static void main(String args[])throws IOException
{
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	System.out.println("enter data");
	String data=br.readLine();
	System.out.println(data);
	String str="";
	char cha[]=data.toCharArray();
	
	int l=data.length();
	int k=l-1;
	System.out.println(l);
	
	
	for(int i=0;k>=i;k--)
	{
		
		str+=cha[k];
		
		
	}
	//String text=String.valueOf(ch);
	System.out.println(str);
	
}

}

Just For Fun..:)

Algorithm (str,len):
  char reversedStr[] =new reversedStr[len]
  Traverse i from 0 to len/2 and then
    reversedStr[i]=str[len-1-i]  
    reversedStr[len-1=i]=str[i]
  return reversedStr;

Time Complexity:O(n) Space Complexity :O(n)

 public class Reverse {
    static char reversedStr[];    
	public static void main(String[] args) {
		System.out.println(reversestr("jatin"));
	}        
	private static String reversestr(String str) {
		int strlen = str.length();
		reversedStr = new char[strlen];
		
		for (int i = 0; i <= strlen / 2; i++) {
			reversedStr[i] = str.charAt(strlen - 1 - i);
			reversedStr[strlen - 1 - i] = str.charAt(i);

		}
		return new String(reversedStr);
	}

}

StringBuilder s = new StringBuilder("racecar");
	for (int i = 0, j = s.length() - 1; i < (s.length()/2); i++, j--) {
		char temp = s.charAt(i);
		s.setCharAt(i, s.charAt(j));
		s.setCharAt(j, temp);
	}
	
	System.out.println(s.toString());

There are many ways to reverse a string.

1. Converting String into Bytes: getBytes() method is used to convert the input string into bytes[].

import java.lang.*;
import java.io.*;
import java.util.*;
class ReverseString{
public static void main(String[] args)
{
    String input = "GeeksforGeeks";
    byte [] strAsByteArray = input.getBytes();
    byte [] result =  new byte [strAsByteArray.length];

    for (int i = 0; i<strAsByteArray.length; i++)
        result[i] = 
         strAsByteArray[strAsByteArray.length-i-1];

    System.out.println(new String(result));
}
}

2.Converting String to character array: The user input the string to be reversed. (Personally suggested)

import java.lang.*;
import java.io.*;
import java.util.*;


class ReverseString{
public static void main(String[] args)
{
    String input = "GeeksForGeeks";

    // convert String to character array
    // by using toCharArray
    char[] try1 = input.toCharArray();

    for (int i = try1.length-1; i>=0; i--)
        System.out.print(try1[i]);
}
}

3.Using ArrayList object: Convert the input string into the character array by using toCharArray() built in method. Then, add the characters of the array into the ArrayList object. Java also has built in reverse() method for the Collections class. Since Collections class reverse() method takes a list object , to reverse the list , we will pass the LinkedList object which is a type of list of characters.

import java.lang.*;
import java.io.*;
import java.util.*;

 class ReverseString{

public static void main(String[] args)
{
    String input = "Geeks For Geeks";
    char[] hello = input.toCharArray();
    List<Character> trial1 = new ArrayList<>();

    for (char c: hello)
        trial1.add(c);

    Collections.reverse(trial1);
    ListIterator li = trial1.listIterator();
    while (li.hasNext())
        System.out.print(li.next());
}
}

> Everybody proposes a way to reverse string here. If you, the reader of > the answer, are interested in, my way using \u202E unicode is here.

public static String reverse(String s) {
        return "\u202E" + s;
}

It can be tested from here.

It is just to print. If your aim is to pass a string in a reversed manner, you need to do it using loop or recursion.

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<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.

    public static void reverseString(String s){
        System.out.println("---------");
        for(int i=s.length()-1; i>=0;i--){
            System.out.print(s.charAt(i));    
        }
        System.out.println(); 
        
    }

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;
    }
}

    //Solution #1 -- Using array and charAt()
    String name = "reverse"; //String to reverse
    Character[] nameChar =  new Character[name.length()]; // Declaring a character array with length as length of the String which you want to reverse.
    for(int i=0;i<name.length();i++)// this will loop you through the String
    nameChar[i]=name.charAt(name.length()-1-i);// Using built in charAt() we can fetch the character at a given index. 
    for(char nam:nameChar)// Just to print the above nameChar character Array using an enhanced for loop
    System.out.print(nam);


    //Solution #2 - Using StringBuffer and reverse ().
    StringBuffer reverseString = new StringBuffer("reverse");
    System.out.println(reverseString.reverse()); //reverse () Causes the character sequence to be replaced by the reverse of the sequence.

package ThingsInArray;

public class MagicWithSelectionSort {

	public static void main(String[] arg) {
		isSort("uhsnamiH");
	}

	private static void isSort(String name) {
		String revName="";
		for (int i = name.toCharArray().length-1; i >0 ; i--) {
			revName=revName+name.charAt(i);
		}
		System.out.println(revName);
	}

}

Without Using Arrays, you can store the Characters and concatenate them in reverse order.

public static String reverseString(String inpt) {
	
	String sb = "";
	for(int i = inpt.length()-1; i>=0; i--) {
		
		sb = sb.concat(""+inpt.charAt(i));
	}
	
	return sb;
}

Here is the code that can be used to reverse a String.

public static void main(String[] args) {

        String aString = "noun";

        int size = aString.length();
        String reversed = "";

        for (int i=size-1;i>=0;i--){
            reversed = reversed+ aString.charAt(i);
            if (i == 0)
                System.out.println(reversed);
        }
}

you can also watch the video to better understand the concepts that are needed https://www.youtube.com/watch?v=KaoA0o2Tfi4

Having surrogate pairs in input string, you have to leave them not reversed, so good and generic way of reversing the string is using StringBuilder.reverse as it handles extended character set correctly. So called supplementary characters consisting of surrogate pairs are unicode values up to U+10FFFF encoded as two consecutive chars.

Here is my solution:

String aString = "abc🌉def";
String reversedString = aString
       .codePoints()
       .boxed()
       .map(Character::toString)
       .collect(Collectors.collectingAndThen(Collectors.toList(), aList -> {
           Collections.reverse(aList);
           return String.join("", aList);
       }));

• String.codepoints returns stream of integers surrogate pair (double chars) packed in one integer, this is different that String.chars for which one integer = one char
• as of Java 11 Character.toString also accepts codepoint, and returns either String of length 1 or 2 if there is surrogate pair

You can use a for statement too:

      for (int y = 0; y < phrase.length(); y--){
      char ch = phrase.charAt(y-1);
      System.out.print(ch);
      }

Just another method

private void revByFor() {
            String str="google";
    		StringBuilder revStr= new StringBuilder();
    		char[] str1= str.toCharArray();
    		for (char c : str1) {
    			revStr.insert(0, c);	
    		}
    		System.out.println(revStr);	
    	}

public class StringReverse1 {

public static void main(String[] args) {
	String name = "Vaquar khan";

	char array[] = name.toCharArray();
	System.out.println(name);
	System.out.println(reverseString(array));
}

private static String reverseString(char[] array) {
	String reverse = "";
	///
	for (int i = array.length - 1; i >= 0; i--) {
		//System.out.println(array[i]);
		//
		reverse += array[i];
	}
	return reverse;

}

}

Results :

      Vaquar khan

      nahk rauqaV

Yet another way is to use org.apache.commons.lang3.StringUtils#reverse

you can write without StringBuilder or with StringBuilder as follows:

private static boolean isPalindrome(int number){
    boolean isPalindrome = false;
    String original="", reversed="";
    original = String.valueOf(number);
        for(int y=original.length() -1; y >= 0; y--){
            reversed += original.charAt(y);
        }
        if(original.equals(reversed)){
            isPalindrome=true;
        }
        return isPalindrome;
}

private static boolean isPalindrome(String original){
    boolean isPalindrome = false;
    StringBuilder reversed=new StringBuilder(original).reverse();
    if(original.equals(reversed.toString())){
        isPalindrome=true;
    }
    return isPalindrome;
}

first method checks for a palindrome for an int and the other for a String.

fun reverse(original: String): String {
    val toReserve = String(original.toByteArray(Charset.forName("UTF-16")), Charset.forName("UTF-16"))
    return StringBuilder(toReserve).reverse().toString()
}

Should work in Java/Kotlin with surrogate pairs.

import java.util.Scanner;
public class StringReverseExample
{
    public static void main(String[] args)
    {
        String str,rev;
        Scanner in = new Scanner(System.in);
        System.out.print("Enter the string : ");
        str = in.nextLine();
        rev = new StringBuffer(str).reverse().toString();
        System.out.println("\nString before reverse:"+str);
        System.out.println("String after reverse:"+rev);
    }
}
/* Output : 
Enter the string : satyam

String before reverse:satyam
String after reverse:maytas */

Maybe using new StringBuilder(str).reverse.toString() is convenient and efficient enough. But if you wanna do it yourself, try this one:

public static String reverse(String str) {
    StringBuilder sb = new StringBuilder(str.length());
    for (int i = str.length() - 1; i >= 0; i--) {
        sb.append(str.charAt(i));
    }
    return sb.toString();
}

Some answers use str.toCharArray() to get this string's char array, this will result to allocate new memory to store these chars, which is not efficient.

StringBuffer is thread safe, but StringBuilder is not. So StringBuffer is less efficient than StringBuilder. If not necessary, use StringBuilder is a better practice.