# Java Program to find the Sum of All Digits

100

If you’re a Java programmer, you might find yourself in a situation where you need to find the sum of all digits in a number. This can be a useful operation for a variety of applications, such as checking whether a number is divisible by a certain value or determining the average of a series of digits.

One way to find the sum of all digits in a number is to use a while loop. A while loop is a control structure that allows you to repeat a block of code as long as a certain condition is met.

To find the sum of all digits in a number using a while loop, you’ll need to first identify the number you want to sum. You can do this by declaring a variable and assigning it a value. For example:

int num = 12345;

Next, you’ll need to initialize a variable to keep track of the sum. This variable will be incremented each time a new digit is added to the sum.

int sum = 0;

Now it’s time to set up the while loop. You’ll want to create a loop that continues until all digits in the number have been processed. To do this, you can use the modulus operator (%). The modulus operator returns the remainder of a division operation, which can be used to determine if a number is odd or even.

The loop will continue until the value of num is less than or equal to 0. At that point, the loop will exit and the sum of all digits in the number will be stored in the sum variable.

## Java Program:

```import java.util.Scanner;

public class SumOfDigits {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter a number: ");
int num = sc.nextInt();

int sum = 0;
while (num > 0) {
sum += num % 10;
num /= 10;
}

System.out.println("Sum of digits: " + sum);
}
}
```

### Output:

```Enter the Input Number: 123456789
Sum of 123456789 : 45```

This program reads an integer from the user and calculates the sum of its digits using a loop.

First, it initializes the `sum` variable to 0. Then, it enters a loop that continues until `num` becomes 0. Inside the loop, it adds the last digit of `num` to `sum`, and removes the last digit from `num` by dividing it by 10.

For example, if the user enters the number `1234`, the loop will execute four times, with the following values:

1. `num` = 1234, `sum` = 0
2. `num` = 123, `sum` = 4
3. `num` = 12, `sum` = 7
4. `num` = 1, `sum` = 9

After the loop finishes executing, `num` becomes 0 and the loop ends. The final value of `sum` is printed to the console.

## Java Program to Find the Sum of All Digits Using Recursive Method

As a Java programmer, you may come across a situation where you need to find the sum of all digits in a given number. One way to solve this problem is by using a recursive method.

A recursive method is a function that calls itself repeatedly until a certain condition is met. In this case, we will use a recursive method to add up the digits of a number until there are no more digits left to add.

Here’s how you can find the sum of all digits in a number using a recursive method in Java:

1. Create a method called “sumOfDigits” that takes in an integer as a parameter. This will be the number whose digits we want to add up.
2. Check if the number is less than 10. If it is, return the number as the sum of its digits. This is our base case – the condition that stops the recursive method from calling itself indefinitely.
3. If the number is greater than or equal to 10, we need to break it down into its individual digits and add them up. To do this, use the modulus operator (%). This operator returns the remainder when one number is divided by another. For example, 25 % 10 will return 5.
4. Divide the number by 10 to remove the last digit. Then, call the “sumOfDigits” method again, passing in the result of the division as the new number.
5. Add the remainder obtained in step 3 to the result of the recursive call. This will give us the sum of all the digits in the original number.

Here’s the complete code for the “sumOfDigits” method:

## Java Program

```public int sumOfDigits(int num) {
// base case: if the number is less than 10, return it as the sum of its digits
if (num < 10) {
return num;
}
// divide the number by 10 to remove the last digit
int newNum = num / 10;
// use the modulus operator to find the remainder (the last digit)
int remainder = num % 10;
// call the sumOfDigits method again, passing in the result of the division as the new number
int sum = sumOfDigits(newNum) + remainder;
// return the sum of all the digits
return sum;
}
```

To test this method, you can create a main method and call the “sumOfDigits” method with a number as the argument. For example:

```public class SumOfDigits {
public static void main(String[] args) {
int result = sumOfDigits(12345);
System.out.println(result); // prints 15
}
}
```

### Output:

```Enter the Input Number: 12345
Sum of 12345 : 15```

And that’s it! You now have a recursive method that can find the sum of all digits in a number in Java. This method is efficient and easy to understand, making it a great solution for this type of problem.

You may also learn these to build the Knowledge: