In this article, we will explore a simple yet interesting problem: how to reverse a number in Java. This problem is common in beginner-level programming exercises and tests. It helps learners understand basic Java constructs, control flow, and arithmetic operations. The solution involves getting each digit of the number and arranging these digits in the reverse order.

## Approach

To reverse a number in Java, we use the **modulus (%)** and **integer division (/)** operations.

**Modulus (%) operation**: In Java, the modulus operation finds the remainder after division of one number by another (also called divisor). For example,**`10 % 3`**will give**`1`**, which is the remainder when**`10`**is divided by**`3`**. If we use**`10 % 10`**, the result will be**`0`**, because**`10`**is wholly divisible by**`10`**. When we perform the modulus operation of any number with**`10`**, we obtain the last digit of that number. For example,**`12345 % 10`**will yield**`5`**.**Integer division (/) operation**: In Java, when we perform an integer division, we get the quotient as the result without the remainder. For instance,**`12345 / 10`**will give**`1234`**. This operation helps us to remove the last digit from our number.

Using these two operations, we can repeatedly obtain the last digit of the number and eliminate it, thus effectively reversing the number.

## Java Code

Below is a Java program that reverses a given number.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 | public class Main { public static void main(String[] args) { int num = 12345; int reversedNum = 0; while(num != 0) { int digit = num % 10; reversedNum = reversedNum * 10 + digit; num /= 10; } System.out.println("Reversed Number: " + reversedNum); } } |

## Code Explanation

Let’s break down the above Java code:

- We declare and initialize an integer
**`num`**with the number we want to reverse. - We declare another integer
**`reversedNum`**and initialize it to**`0`**. This variable will hold the reversed number. - We use a while loop to iterate until
**`num`**becomes**`0`**. Inside the loop:- We calculate the remainder of
**`num`**divided by**`10`**using the modulus operator. This gives us the last digit of**`num`**, which we store in digit. - We multiply
**`reversedNum`**by**`10`**and add digit to it. This effectively appends digit to the end of**`reversedNum`**. - We divide
**`num`**by**`10`**to remove its last digit.

- We calculate the remainder of
- Finally, we print
**`reversedNum`**, which now contains the reversed number.

If you run this program with **`num`** initialized to **`12345`**, it will print Reversed Number: **`54321`**.

## Conclusion

In conclusion, reversing a number in Java is a simple task involving basic arithmetic and control flow. This exercise is great for beginners to practice their understanding of Java’s modulus and integer division operations, as well as control flow constructs. However, remember that this method will not handle leading zeros. For instance, reversing 100 using this method would result in 1, not 001. To handle such cases, you might want to consider a different approach, such as converting the number to a string and then reversing that string.