Open In App
Related Articles

Reverse a string in Java

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

This article discusses different ways to reverse a string in Java with examples. 

Examples:  

string-reverse

Prerequisite: String vs StringBuilder vs StringBuffer in Java

Following are some interesting facts about String and StringBuilder classes : 

  1. Objects of String are immutable. 
  2. String class in Java does not have reverse() method, however, the StringBuilder class has built-in reverse() method. 
  3. StringBuilder class do not have toCharArray() method, while String class does have toCharArray() method. 
1. The idea is to traverse the length of the string 
2. Extract each character while traversing
3. Add each character in front of the existing string

Implementation:

Java

// java program to reverse a word
 
import java.io.*;
import java.util.Scanner;
 
class GFG {
    public static void main (String[] args) {
       
        String str= "Geeks", nstr="";
        char ch;
       
      System.out.print("Original word: ");
      System.out.println("Geeks"); //Example word
       
      for (int i=0; i<str.length(); i++)
      {
        ch= str.charAt(i); //extracts each character
        nstr= ch+nstr; //adds each character in front of the existing string
      }
      System.out.println("Reversed word: "+ nstr);
    }
}
 
//Contributed by Tiyasa

                    

Output
Original word: Geeks
Reversed word: skeeG

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

Method:  

1. Create a temporary byte[]  of length equal 
to the length of the input string.
2. Store the bytes (which we get by using
getBytes() method) in reverse order into
the temporary byte[] .
3. Create a new String abject using byte[] to
store result.

Implementation:

Java

// Java program to ReverseString using ByteArray.
import java.lang.*;
import java.io.*;
import java.util.*;
 
// Class of ReverseString
class ReverseString {
    public static void main(String[] args)
    {
        String input = "GeeksforGeeks";
 
        // getBytes() method to convert string
        // into bytes[].
        byte[] strAsByteArray = input.getBytes();
 
        byte[] result = new byte[strAsByteArray.length];
 
        // Store result in reverse order into the
        // result byte[]
        for (int i = 0; i < strAsByteArray.length; i++)
            result[i] = strAsByteArray[strAsByteArray.length - i - 1];
 
        System.out.println(new String(result));
    }
}

                    

Output
skeeGrofskeeG

Using built in reverse() method of the StringBuilder class: 

String class does not have reverse() method, we need to convert the input string to StringBuilder, which is achieved by using the append method of StringBuilder. After that, print out the characters of the reversed string by scanning from the first till the last index.

Implementation:

Java

// Java program to ReverseString using StringBuilder
import java.lang.*;
import java.io.*;
import java.util.*;
 
// Class of ReverseString
class ReverseString {
    public static void main(String[] args)
    {
        String input = "Geeks for Geeks";
 
        StringBuilder input1 = new StringBuilder();
 
        // append a string into StringBuilder input1
        input1.append(input);
 
        // reverse StringBuilder input1
        input1.reverse();
 
        // print reversed String
        System.out.println(input1);
    }
}

                    

Output
skeeG rof skeeG

Converting String to character array: The user input the string to be reversed. 

Method:

1. First, convert String to character array
by using the built in Java String class
method toCharArray().
2. Then, scan the string from end to start,
and print the character one by one.

Implementation:

Java

// Java program to Reverse a String  by
// converting string to characters  one
// by one
import java.lang.*;
import java.io.*;
import java.util.*;
 
// Class of ReverseString
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]);
    }
}

                    

Output
skeeGroFskeeG
  • Convert the input string into character array by using the toCharArray(): Convert the input string into character array by using the toCharArray() – built in method of the String Class. Then, scan the character array from both sides i.e from the start index (left) as well as from last index(right) simultaneously.
1. Set the left index equal to 0 and right 
index equal to the length of the string -1.
2. Swap the characters of the start index
scanning with the last index scanning
one by one. After that, increase the left
index by 1 (left++) and decrease the right
by 1 i.e., (right--) to move on to the next
characters in the character array .
3. Continue till left is less than or equal to
the right.

Implementation:

Java

// Java program to Reverse a String using swapping
// of variables
import java.lang.*;
import java.io.*;
import java.util.*;
 
// Class of ReverseString
class ReverseString {
    public static void main(String[] args)
    {
        String input = "Geeks For Geeks";
        char[] temparray = input.toCharArray();
        int left, right = 0;
        right = temparray.length - 1;
 
        for (left = 0; left < right; left++, right--) {
            // Swap values of left and right
            char temp = temparray[left];
            temparray[left] = temparray[right];
            temparray[right] = temp;
        }
 
        for (char c : temparray)
            System.out.print(c);
        System.out.println();
    }
}

                    

Output
skeeG roF skeeG
  • 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 ArrayList object which is a type of list of characters.
1. We copy String contents to an object 
of ArrayList.
1. We create a ListIterator object by using
the listIterator() method on the ArrayList
object.
2. ListIterator object is used to iterate over
the list.
3. ListIterator object helps us to iterate
over the reversed list and print it one
by one to the output screen.

Implementation:

Java

// Java program to Reverse a String using ListIterator
import java.lang.*;
import java.io.*;
import java.util.*;
 
// Class of ReverseString
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());
    }
}

                    

Output
skeeG roF skeeG

Using StringBuffer: 

String class does not have reverse() method, we need to convert the input string to StringBuffer, which is achieved by using the reverse method of StringBuffer.

Implementation:

Java

// Java program to demonstrate conversion from
// String to StringBuffer and reverse of string
import java.lang.*;
import java.io.*;
import java.util.*;
 
public class Test {
    public static void main(String[] args)
    {
        String str = "Geeks";
 
        // conversion from String object to StringBuffer
        StringBuffer sbr = new StringBuffer(str);
        // To reverse the string
        sbr.reverse();
        System.out.println(sbr);
    }
}

                    

Output
skeeG
  • Reversing String by taking input from user-

Java

/*package whatever //do not write package name here */
 
import java.io.*;
import java.util.Scanner;
class GFG {
    public static void main (String[] args) {
 
        Scanner scanner = new Scanner(System.in);
        String Str = scanner.nextLine();
        char[] arr = Str.toCharArray();
                 
        String rev = "";
   
 for(int i = Str.length() - 1; i >= 0; i--)
 {
 rev = rev + Str.charAt(i);
 }
  
 System.out.println(rev);
         
    }
}
    

                    

Output
0

In the above code, we are essentially reading a String from the user before starting an iteration loop to create a new, inverted String. The “charAt” function of the String class is used to retrieve each character of the original String individually from the end, and the “+” operator is used to concatenate them into a new String.

Using Stack: 

The idea of stack is that we will be accessing only top element of a stack so it includes 2 steps as follows:

  1. push all the characters in stack.
  2. pop all the characters from stack and append to temp string.

Below is the implementation of the above approach.

Java

import java.util.*;
 
class GFG {
    public static void main(String[] args) {
        
        String s="Geeks For Geeks";
         
        //initializing a stack of type char
        Stack<Character> stack=new Stack<>();
         
        for(char c:s.toCharArray())
        {
            //pushing all the characters
            stack.push(c);
        }
         
        String temp="";
         
        while(!stack.isEmpty())
        {
            //popping all the chars and appending to temp
            temp+=stack.pop();
        }
         
        System.out.println("Reversed string is : "+temp);
         
    }
}
 
//This code is contributed by aeroabrar_31

                    

Output
Reversed string is : skeeG roF skeeG

Time Complexity : O(N) N is length of string

Auxiliary Space: O(N) for stack

Related Article: Different methods to reverse a string in C/C++

This article is contributed by Mr. Somesh Awasthi.



Last Updated : 23 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads