Sum of Digits of a Number in Java

In this section, we will create Java programs to find the sum of digits of a number in Java. In order to find the sum of digits of a number, we must familiar with the Java loops and operators.

Steps to Find the Sum of Digits of a Number in Java

Enter any integer number as input. After that, we use modulus and division operation respectively to find the sum of digits of the number as output. Let's see the steps.

Read or initialize an integer N.
Declare a variable (sum) to store the sum of numbers and initialize it to 0.
Find the remainder by using the modulo (%) operator. It gives the last digit of the number (N).
Add the last digit to the variable sum.
Divide the number (N) by 10. It removes the last digit of the number.
Repeat the above steps (3 to 5) until the number (N) becomes 0.

Let's understand the above steps mathematically and find the sum of digits of a number.

Suppose, we have to find the sum of digits of the number (N) 674.

First iteration

674 % 10 = 4

Sum = 0 + 4 = 4

674 / 10 = 67

Second iteration

67 % 10 = 7

Sum = 4 + 7 = 11

67 / 10 = 6

Third iteration

6 % 10 = 6

Sum = 11 + 6 = 17

6 / 10 = 0

Now the number (N) has become 0. So, we will not process it further. Hence, we get 17 as the sum of digits of the number 674.

Let's implement the above steps in a Java program.

Java Programs to Find the Sum of Digits of a Number

There are the following ways to find the sum of digits of a number:

Using While Loop
Using for Loop
Using Function
Using Recursion

Using While Loop

It is the simplest approach to find the sum of the digits of a number using a while loop. Let's break down the steps:

Initialize Variables:

number: It stores the user input.

digit: It holds the last digit of the number.

sum: It accumulate the sum of the digits.

Loop Until the Number Becomes 0:

Find the last digit using the modulo operator (number % 10).
Add the last digit to sum.
Remove the last digit from number by dividing it by 10 (number / 10).

Print the Result.

SumOfDigitExample1.java

import java.util.Scanner;
public class SumOfDigitsExample1 
{
public static void main(String args[])
{
int number, digit, sum = 0;
Scanner sc = new Scanner(System.in);
System.out.print("Enter the number: ");
number = sc.nextInt();
while(number > 0)
{
//finds the last digit of the given number  
digit = number % 10;
//adds last digit to the variable sum
sum = sum + digit;
//removes the last digit from the number
number = number / 10;
}
//prints the result
System.out.println("Sum of Digits: "+sum);
}
}

Output:

Enter the number: 876
Sum of Digits: 21

Using for Loop

This approach uses a for loop to achieve the same result, which might be more concise in some cases.

Initialize Variables:

number: It stores the user input.

sum: It accumulates the sum of the digits.

Loop Until the Number Becomes 0:

In each iteration, add the last digit to sum and remove the last digit from number.

Print the Result.

SumOfDigitsExample2.java

import java.util.Scanner;
public class SumOfDigitsExample2
{
public static void main(String arg[])
{
long number, sum;
Scanner sc=new Scanner(System.in);
System.out.print("Enter a number: ");
//reads a long number from the user
number=sc.nextLong();
//executes until the condition number!=0 becomes false
for(sum=0; number!=0; number=number/10)
{
//finds the last digit and add it to the variable sum    
sum = sum + number % 10;
}
//prints the result
System.out.println("Sum of digits: "+sum);
}
}

Output:

Enter a number: 3456788
Sum of digits: 41

Using Function

Encapsulating the logic in a function improves code reusability and clarity.

Define Function:

The function findSum() takes an integer and returns the sum of its digits.

Use while Loop Inside the Function:

The logic inside the function is similar to the while loop approach.

Call the function from main() method.

SumOfDigitsExample3.java

public class SumOfDigitsExample3
{
//function that finds the sum of digits of a number
static int findSum(int number)
{	
//variable that stores the sum    
int sum = 0;
//executes until the condition becomes false
while (number != 0)
{
//finds the last digit from the number and add it to the variable sum    
sum = sum + number % 10;
//removes the last digit
number = number/10;
}
//returns the sum
return sum;
}
//driver code
public static void main(String args[])
{
int number = 5678;
//calling the user-defined method and prints the result 
System.out.println("The sum of digits: "+findSum(number));
}
}

Output:

The sum of digits: 26

In the following program, we have reduced the lines of code and implement the steps in a for loop only.

SumOfDigitsExample4.java

public class SumOfDigitsExample4
{
//function that finds the sum of digits of a number
static int findSum(int number)
{
//variable that stores the sum        
int sum;    
//calculates sum in a single line
for (sum = 0; number > 0; sum = sum + number % 10, number = number / 10);
//returns the sum
return sum;
}
//driver code
public static void main(String args[])
{
int number = 7812089;
//calling the user-defined method and prints the result 
System.out.println("The sum of digits: "+findSum(number));
}
}

Output:

The sum of digits: 35

Using Recursion

Recursion provides an elegant way to solve this problem by repeatedly breaking it down into smaller sub-problems.

Define Recursive Function:

The function calls itself with a reduced number until the base case (number == 0) is reached.

Base Case and Recursive Step:

Base case: When number is 0, return 0.

Recursive step: Add the last digit to the result of the recursive call with the remaining number.

Here is the code for this approach:

SumOfDigitsExample5.java

public class SumOfDigitsExample5
{
//function that finds the sum of digits of a number
static int findSum(int number)
{
//returns sum    
//if number is not equal to 0 then execute code after colon (:), else print 0  
//the method findSum() is recursively called
return number == 0 ? 0 : number % 10 +findSum(number/10) ;
}
//driver code
public static void main(String args[])
{
int number = 1234567;
//calling the user-defined method and prints the result 
System.out.println("The sum of digits: "+findSum(number));
}
}

Output:

The sum of digits: 28

Using Recursion with an Instance Variable

This variant of the recursion method uses an instance variable to store the sum.

Define Class with Instance Variable:

Define a class with an instance variable sum.

Recursive Function:

The function updates the instance variable sum and calls itself until the number becomes 0.

SumOfDigitsExample6.java

import java.util.Scanner;
public class SumOfDigitsExample6
{
//variable that stores the sum            
int sum=0;
//function that finds the sum of digits of a number
int sum(int number)
{
//executes until the statement returns false    
if(number != 0)
{
//finds the last digit from the number and add it to the variable sum        
sum = sum + number % 10;
//removes the last digit by diving the number by 10
number = number / 10;
//function recursively called
sum(number);
}
//returns sum
return sum;
}
public static void main(String args[])
{
int number;
SumOfDigitsExample6 sod = new SumOfDigitsExample6();
Scanner sc = new Scanner(System.in);
System.out.print("Enter a number: ");
//reads an integer from the user
number=sc.nextInt();
//calling the user-defined method and prints the result 
System.out.println("The sum of digits: "+sod.sum(number));
}
}

Output:

Enter a number: 983451
The sum of digits: 30

Conclusion

Each approach has its own advantages:

While Loop: Simple and straightforward, ideal for beginners.
For Loop: More concise and can be preferred for simpler logic.
Function: Enhances code modularity and reusability.
Recursion: Elegant and showcases a different programming paradigm, suitable for problems that can be broken down into similar sub-problems.
Recursion with Instance Variable: Useful when encapsulating the logic within an instance context.

Next TopicSum of Numbers in Java

← prev next →