Sum of Digits in Java: While Loop, Recursion & Optimized Code

Introduction

Finding the sum of digits of a number is one of the most commonly used digit-manipulation programs in Java. Although it is often introduced as a beginner exercise, the same logic appears in many important programming problems, including Armstrong numbers, Harshad (Niven) numbers, digital root calculations, checksum algorithms, and numerous coding interview questions.

The core idea is simple: repeatedly extract the last digit of a number, add it to a running total, and remove that digit until no digits remain.

In this guide, you'll learn multiple ways to find the sum of digits in Java, understand how each approach works internally, explore digital root calculation, compare different implementations, and review common interview questions.

What Is the Sum of Digits?

The sum of digits is obtained by adding every digit of a number.

For example:

Number : 12345

Sum = 1 + 2 + 3 + 4 + 5
    = 15

Many number-based algorithms begin by calculating the sum of digits, making it one of the most fundamental programming techniques.

Method 1: Using a While Loop

This is the standard and most widely used approach.

Java Program

public class Main {

    public static void main(String[] args) {

        int num = 12345;
        int sum = 0;

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

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

Output

Sum of digits: 15

How It Works

For every iteration:

• % 10 extracts the last digit.

• The digit is added to the running total.

• / 10 removes the last digit from the number.

The process repeats until the number becomes zero.

Time Complexity

O(d)

where d is the number of digits.

Space Complexity

O(1)

Method 2: Using Recursion

The same logic can be implemented recursively.

Java Program

public class Main {

    static int sumOfDigits(int num) {

        if (num == 0) {
            return 0;
        }

        return (num % 10) + sumOfDigits(num / 10);
    }

    public static void main(String[] args) {

        int num = 12345;

        System.out.println("Sum of digits: " + sumOfDigits(num));
    }
}

Output

Sum of digits: 15

Each recursive call processes one digit and returns its contribution to the final sum.

Time Complexity

O(d)

Space Complexity

O(d)

because every recursive call occupies one stack frame.

Method 3: Finding the Digital Root

Sometimes the requirement is to continue summing digits until only a single digit remains.

This final value is called the digital root.

Java Program

public class Main {

    public static void main(String[] args) {

        int num = 9875;

        while (num >= 10) {

            int sum = 0;

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

            num = sum;
        }

        System.out.println("Digital root: " + num);
    }
}

Output

Digital root: 2

How It Works

For 9875:

9 + 8 + 7 + 5 = 29
2 + 9 = 11
1 + 1 = 2

Since 2 is a single digit, the process stops.

Time Complexity

O(d × k)

where k is the number of repeated summations required.

Method 4: Using String Conversion

Instead of arithmetic operations, the digits can be processed as characters.

Java Program

public class Main {

    public static void main(String[] args) {

        int num = 12345;

        String str = String.valueOf(num);
        int sum = 0;

        for (char ch : str.toCharArray()) {
            sum += Character.getNumericValue(ch);
        }

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

Output

Sum of digits: 15

This method converts the number into a string, iterates through every character, converts each character back into its numeric value, and adds it to the running total.

Time Complexity

O(d)

Space Complexity

O(d)

because a string and character array are created.

How Java Handles This Internally

Consider the following variables:

int num = 12345;
int sum = 0;

Internally:

1. num, sum, and digit are primitive int variables stored on the stack.

2. During every iteration, % 10 extracts the last digit.

3. The digit is added to sum.

4. / 10 removes the processed digit.

5. In the recursive method, every function call creates a new stack frame.

6. In the string-based approach, String and character array objects are created on the heap.

7. After program execution completes, local stack variables are automatically removed, and heap objects become eligible for garbage collection.

Real-Life Analogy

Imagine counting coins inside a piggy bank.

Instead of counting everything at once, you take out one coin at a time, add its value to your running total, and continue until the piggy bank is empty.

The sum-of-digits algorithm works exactly the same way—it processes one digit at a time until no digits remain.

Comparison of Different Methods

Best Practices

• Use the while-loop approach for maximum efficiency.

• Use recursion only when recursion is specifically required.

• Handle negative numbers using Math.abs() before processing digits.

• Reset the sum variable before processing another number.

• For digital root problems, remember the mathematical shortcut whenever appropriate.

Common Mistakes

Forgetting to Remove the Last Digit

Incorrect:

digit = num % 10;

without:

num = num / 10;

This creates an infinite loop.

Forgetting to Reset the Sum Variable

If processing multiple numbers:

sum = 0;

must be executed before starting the next calculation.

Confusing Sum of Digits with Digital Root

These are different operations.

Example:

9875

Sum of digits = 29

Digital root = 2

Ignoring Negative Numbers

Always use:

num = Math.abs(num);

before processing digits.

Using Floating-Point Numbers

Digit extraction using % 10 and / 10 is intended for integer values.

Floating-point numbers require different handling.

Expert Tips

• The while-loop solution is the preferred interview answer.

• Mention recursion as an alternative implementation.

• If discussing digital roots, mention the mathematical shortcut:

1 + (num - 1) % 9

for non-zero numbers.

• Explain that each iteration processes exactly one digit.

Pros and Cons

Frequently Asked Questions

What is the easiest way to find the sum of digits in Java?

Use a while loop with the modulus (%) and division (/) operators.

What is the difference between sum of digits and digital root?

The sum of digits is calculated once.

The digital root repeatedly sums digits until only one digit remains.

Can I calculate the sum of digits using recursion?

Yes.

Each recursive call returns one digit plus the sum of the remaining digits.

Is there a formula for the digital root?

Yes.

For any non-zero number:

1 + (num - 1) % 9

computes the digital root in constant time.

How should negative numbers be handled?

Use:

Math.abs(num)

before extracting digits.

What is the time complexity?

Each digit is processed exactly once.

Time Complexity: O(d)

where d is the number of digits.

Can I use String conversion instead of arithmetic?

Yes.

Convert the number into a string and use Character.getNumericValue() to process each digit.

Why is the sum of digits used in Armstrong numbers?

Armstrong number algorithms process every digit individually and perform arithmetic on those digits before comparing the result with the original number.

Does this work for very large numbers?

Yes, if they fit within the chosen numeric type.

For extremely large values, use BigInteger together with string-based digit extraction.

What happens when the input is zero?

The sum of digits of 0 is 0.

Is this a common interview question?

Yes.

It is one of the most common beginner and QA/SDET interview questions because it tests loops, modulus, division, recursion, and basic number manipulation.

Can this algorithm work for other number systems?

Yes.

Replace:

• % 10 and / 10

with:

• % base and / base

For example:

• Binary → % 2 and / 2

• Octal → % 8 and / 8

• Hexadecimal → % 16 and / 16