Reverse a given number in Java

Find the Reverse of a Number in Java

Given a integer input the objective is to break down the  number into digits and rearrange them in reverse order. We’ll use loops and recursion to reverse the number input. therefore, we’ll write a program to Find the Reverse of a Number in Java Language.

Example
Input : 123
Output : 321
Find the Reverse of a Number in Python

Find the Reverse of a Number in Java Language

Given an integer input as number, the objective is Find the Reverse of a Number in Java Language. To do so we usually break down the number into its individual digits and then rearrange them in reverse order. Here are a few methods to solve the above-mentioned problem in Java Language,

  • Method 1: Using while loop
  • Method 2: Using for loop
  • Method 3: Using Recursion I
  • Method 4: Using Recursion II
  • Method 5: Taking care of negative numbers in case of method 4

Let’s implement the above-mentioned methods in the upcoming sections.

Method 1: Using while loop

In this method, we’ll use a while loop to break down the number input and rearrange the number in reverse order. We’ll use the modulo operator to extract the digits from the number and the divide operator to shorten the number.

Let’s implement the above-mentioned logic in Java Language.

Reverse a given number in Java

Java Code (Method 1)

Run
public class Main
{
    public static void main (String[]args)
    {

        //variables initialization
        int num = 1234, reverse = 0, rem;


        //loop to find reverse number
        while (num != 0)
        {
            rem = num % 10;
            reverse = reverse * 10 + rem;
            num /= 10;
        };

        //output
        System.out.println ("Reversed Number: " + reverse);
    }
}

Output

Reversed Number: 4321

Method 2: Using For loop

In this method, the approach followed is the same as the previous method but we will use a for loop instead of a while loop.

  • Initialization: Left Blank
  • Condition: num != 0 (Checking if number is reduced to zero or not)
  • Increment: num = num/10, we are reducing the digits in num here
Run
class Main
{
    public static void main (String[]args)
    {

        //variables initialization
        int num = 1234, reverse = 0, rem;


        //loop to find reverse number
        for( ;num != 0; num = num/10)
        {
            rem = num % 10;
            reverse = reverse * 10 + rem;
        };

        //output
        System.out.println ("Reversed Number: " + reverse);
    }
}

Output

Reversed Number: 4321

Method 3: Using Recursion I

In this method we’ll use recursion to break down the input integer number and reassemble them in reverse order. We’ll use the modulo and divide operators to break down the number and rearrange them. 

Let’s implement the logic in Java Language.

Java Code

Run
public class Main
 {
   public static void main (String[]args)
   {

     //variables initialization
     int num = 1234, rev = 0;

     //output
       System.out.println ("Reversed Number: " + getReverse(num, rev));
   }

   static int getReverse (int num, int rev)
   {
     if (num == 0)
       return rev;

     int rem = num % 10;
     rev = rev * 10 + rem;

     return getReverse (num / 10, rev);
   }
 }

Output

Reversed Number: 4321

Method 4: Using Recursion II

This method is similar to that of the above-mentioned method, but instead of using two arguments, we’ll use only one in this method. We’ll directly print the last extracted digit with each recursive call, forming the whole number in reverse order.

Let’s implement the above mentioned logic in Java Language.

Java Code

Run
public class Main
{
  public static void main (String[]args)
  {

    //variables initialization
    int num = 1234;

      getReverse (num);
  }

  static void getReverse (int num)
  {
    if (num == 0)
      return;

    int rem = num % 10;
    System.out.print (rem);

    getReverse (num / 10);

  }
}

Output

Reversed Number: 4321

Taking care of negative Numbers

The above program will give wrong input if the number is negative, example for -1234 the output will be  -4-3-2-1.

We can take care of this in the following way –

  • Check if the number is positive
    • Do nothing
  • If the number is negative
    • Print ‘-‘ additionally and then
    • Multiply num with -1 and then send to the function
Run
class Main
{
    public static void main (String[]args)
    {

        //variables initialization
        int num = -1234;
        boolean isNegative = num < 0 ? true: false;

        if (isNegative) {
            System.out.print("-");
            num = num * -1;
        }

        getReverse(num);
    }

    static void getReverse(int num)
    {
        if (num == 0)
            return;

        int rem = num % 10;
        System.out.print(rem);

        getReverse(num / 10);

    }
}

Output

Reversed Number: -4321

2 comments on “Reverse a given number in Java”


  • Satendra

    Class recursion {
    Public static void printrev(String str, int idx, ){
    If(idx==0){
    System.out.println(str.charAt(idx));}
    System.out print(str.charAt(idx));
    Printrev(str,idx-1);}
    }
    Public static void main (String []args){
    String str=”abcd”;
    printrev (str, str.length()-1);}
    }


  • Aditi

    import java.util.*;
    public class ReverseNumber {
    public static void main(String[] args)
    {
    Scanner sc =new Scanner(System.in);
    int number=sc.nextInt();
    int reverse =0;
    while(number!=0)
    {
    int lastDigit=number%10;
    reverse =reverse*10+lastDigit;
    number =number/10;
    }
    System.out.print(“Sum of Digit is:”+reverse);
    }
    }