Sum of digits of a number in Java

In Java, the sum of digits is calculated by using the modulus operator (%) to get each digit and adding it to a total. Then, the number is divided by 10 to remove the last digit, and this repeats until the number becomes zero. The challenge isn't efficiency but handling big integers beyond int and long limits, which is addressed using BigInteger.

In this guide, you’ll walk you through different methods, including the sum of digits of a number in Java using for loop. By the end, you'll have a solid understanding of how to solve this problem with ease.   

Improve your Java programming skills with our Software Development courses — take the next step in your learning journey! 

How to Calculate the Sum of Digits of a Number in Java

In this tutorial, you'll learn how to calculate the sum of digits of a number in Java with example, using several methods. You’ll explore straightforward techniques like using loops, and delve into the sum of digits of a number in Java using for loop, among others. Each method will be explained with code examples, so you can understand how to implement them in your own projects.

Different approaches offer trade-offs in readability and performance.

Let's dive into the first method: using a for loop to tackle this task step by step.

Method 1: Using a For Loop

Let’s start with one of the most common and easy-to-understand methods to calculate the sum of digits of a number in Java — using a for loop. This approach is great for beginners because it gives you a hands-on understanding of how loops work, while also solving the problem efficiently.

Step-by-Step Explanation

To calculate the sum of digits of a number using a for loop, you first need to extract each digit from the number. You can do this by repeatedly dividing the number by 10, until the number becomes zero. The remainder of each division will give you the last digit of the number. 

1. Convert the number into its absolute value (to handle negative numbers).
2. Use a for loop to process each digit.
3. Add each digit to a running total.

Code Example 

public class SumOfDigits {
    public static int sumOfDigits(int num) {
        int sum = 0;
        num = Math.abs(num); // Make sure the number is positive        
        // Loop through each digit
        for (; num > 0; num /= 10) {
            sum += num % 10; // Add the last digit to sum
        }        
        return sum;
    }
    public static void main(String[] args) {
        int number = 123;
        System.out.println("Sum of digits: " + sumOfDigits(number));
    }
}

Output: 

Sum of digits: 6

Code Breakdown:

• Math.abs(num): This ensures the number is positive, even if the input is negative. For instance, if num = -123, the absolute value will make it 123.
• num % 10: This gets the last digit of the number. For example, for num = 123, 123 % 10 equals 3.
• num /= 10: This removes the last digit by dividing the number by 10. So, 123 becomes 12, then 12 becomes 1, and finally, 1 becomes 0.
• Floating-point numbers should be converted to an integer first using Math.floor(n) before summing digits.

Edge Cases

When working with the sum of digits, it's important to consider edge cases:

1. Negative Numbers: We used Math.abs(num) to handle negative inputs. For example, -123 will still produce the sum 6, just like 123.
2. Zero: If the input is zero (0), the loop won’t run because num > 0 is false right away. The sum will be 0 as expected.
3. Large Integers: The method works for large numbers as well, like 9876543210. The loop will still iterate through each digit, summing them up correctly.

Time Complexity

This method runs in O(d) time since we process each digit by repeatedly dividing by 10.

For example, for a number like 123456, the loop will run six times (one for each digit). As the size of the number increases, the number of iterations grows linearly, making this approach quite efficient for most practical purposes.

Method 2: Using a While Loop

While both loops serve a similar purpose, the while loop works differently in terms of its structure, and it’s useful to understand both.

Step-by-Step Explanation

In this method, the basic idea remains the same: you need to extract each digit of the number and add it to a sum. The key difference is how the loop works. With a while loop, you continue extracting digits as long as the number is greater than zero. 

1. Convert the number to its absolute value to handle negative numbers.
2. Use a while loop to keep extracting the last digit of the number.
3. Add each digit to the sum and reduce the number by removing the last digit.

Code Example 

public class SumOfDigits {
    public static int sumOfDigits(int num) {
        int sum = 0;
        num = Math.abs(num); // Ensure the number is positive
        // Loop through each digit
        while (num > 0) {
            sum += num % 10; // Add the last digit to sum
            num /= 10;        // Remove the last digit
        }        
        return sum;
    }
    public static void main(String[] args) {
        int number = 987;
        System.out.println("Sum of digits: " + sumOfDigits(number));
    }
}

Output  

Sum of digits: 24

This is because 9 + 8 + 7 = 24.

Code Breakdown:

• Math.abs(num): Just like in the previous method, this ensures that the number is positive, even if the input is negative.
• num % 10: This extracts the last digit of the number. For example, for num = 987, 987 % 10 gives 7.
• num /= 10: This reduces the number by removing the last digit. So, 987 becomes 98, then 98 becomes 9, and finally, 9 becomes 0.

Edge Cases

Just like with the for loop method, we need to consider edge cases:

1. Negative Numbers: We handle this by using Math.abs(num) to convert any negative input into a positive one. For instance, -987 will be processed as 987, resulting in the sum 24.
2. Zero: If the input is zero (0), the while loop won’t run, and the sum will remain 0 as expected.

Optimizing for Large Numbers

If you're working with numbers larger than long (19+ digits), consider using Java’s BigInteger class. This class can handle numbers that are far larger than what int or long can accommodate. 

You can apply the same logic using BigInteger, and it will still work for calculating the sum of digits, no matter how large the number is.

Here’s how you could modify the code to use BigInteger: 

import java.math.BigInteger;
public class SumOfDigits {
    public static int sumOfDigits(BigInteger num) {
        int sum = 0;        
        // Loop through each digit
        while (num.compareTo(BigInteger.ZERO) > 0) {
            sum += num.mod(BigInteger.TEN).intValue(); // Add the last digit to sum
            num = num.divide(BigInteger.TEN);           // Remove the last digit
        }        
        return sum;
    }
    public static void main(String[] args) {
        BigInteger bigNum = new BigInteger("12345678901234567890");
        System.out.println("Sum of digits: " + sumOfDigits(bigNum));
    }
}

Output: 

For the input number 12345678901234567890, the output will be: 

Sum of digits: 90

Time Complexity

The time complexity of the while loop method is O(d), where d is the number of digits in the input number. This is similar to the for loop method. 

In both cases, the time complexity depends on the number of digits, and you will see a linear increase in iterations as the size of the number grows.

When working with BigInteger, while the approach still operates in linear time, the actual performance will be slower compared to primitive types like int, due to the overhead of handling very large numbers. However, this is an acceptable trade-off for most applications if you need to deal with large numbers.

Also Read: 50 Java Projects With Source Code in 2025: From Beginner to Advanced

Method 3: Using Recursion

You can use the recursion technique to repeatedly extract the last digit of a number and add it to the sum, reducing the number at each step.

Step-by-Step Explanation

To calculate the sum of digits using recursion, we:

1. Check if the number has more than one digit.
2. Add the last digit to the sum.
3. Call the same method on the remaining part of the number (without the last digit).
4. Repeat the process until the number is reduced to a single digit, at which point the base case is reached.

Code Example 

public class SumOfDigits {
    public static int sumOfDigits(int num) {
        // Base case: if the number is less than 10, return the number itself
        if (num < 10) {
            return num;
        }        
        // Recursive case: sum the last digit and recursively call on the remaining number
        return num % 10 + sumOfDigits(num / 10);
    }
    public static void main(String[] args) {
        int number = 456;
        System.out.println("Sum of digits: " + sumOfDigits(number));
    }
}

Output 

Sum of digits: 15

This is because 4 + 5 + 6 = 15.

Code Breakdown:

• Base Case: If the number is less than 10 (i.e., a single digit), we return the number itself. This is the terminating condition for the recursion.
• Recursive Case: We add the last digit of the number (num % 10) to the result of the recursive call on the remaining digits (num / 10).

Edge Cases

1. Negative Numbers: Just like the other methods, we need to handle negative numbers. In the case of recursion, you can use Math.abs(num) to ensure the number is positive before processing it. For instance, -456 would still give the sum 15 because we’re only interested in the digits themselves.
2. Zero: The base case handles 0 automatically, returning 0 without any issues.

Time Complexity

The time complexity of the recursive method is O(d), where d is the number of digits in the number. This is because the recursion operates by repeatedly dividing the number by 10, which reduces the size of the number by one digit per recursive call.

However, recursion in Java has an overhead because each method call requires stack space. If the number of digits is very large, deep recursion can lead to StackOverflowError. This is one of the reasons why using recursion for problems like this may not always be the best choice, especially when working with large numbers.

Best Practices for Recursion

While recursion is a neat and elegant solution, there are a few best practices to keep in mind:

• Avoid Deep Recursion for Large Numbers: Recursion has limitations in terms of stack depth. If you're working with extremely large numbers, consider using a loop-based solution to avoid stack overflow errors.
• Tail Recursion: In some programming languages, tail recursion can optimize memory usage. Unfortunately, Java doesn’t optimize tail recursion, so it’s still important to be cautious with deep recursion.
• Recursion for Conceptual Understanding: Recursion is excellent for understanding how problems can be broken down into smaller subproblems. It helps you think about the structure of the problem in a more abstract way, but for practical applications, loops are often more efficient.

Also Read: Top 12 Pattern Programs in Java You Should Checkout Today

Method 4: Using String Conversion

In this method, we'll use Java’s ability to convert a number to a string to calculate the sum of its digits. This approach is particularly handy when you want to treat the number as a collection of characters, making it easy to extract each digit. 

By converting the number to a string, we can simply iterate over each character, convert it back to an integer, and sum them up.

Step-by-Step Explanation

The process of summing the digits of a number using string conversion involves:

1. Converting the number to a string.
2. Iterating over each character in the string.
3. Converting each character back to its corresponding numeric value.
4. Summing all the digits together.

By treating the number as a string, each character can be easily converted to an integer using Character.getNumericValue().

Code Example 

public class SumOfDigits {
    public static int sumOfDigits(int num) {
        // Convert the number to a string and handle negative numbers
        String numStr = String.valueOf(Math.abs(num));
        int sum = 0;

        // Loop through each character in the string
        for (int i = 0; i < numStr.length(); i++) {
            sum += Character.getNumericValue(numStr.charAt(i)); // Add the digit to the sum
        }
        return sum;
    }
    public static void main(String[] args) {
        int number = 12345;
        System.out.println("Sum of digits: " + sumOfDigits(number));
    }
}

Output 

Sum of digits: 15

This is because 1 + 2 + 3 + 4 + 5 = 15.

Code Breakdown:

• String.valueOf(Math.abs(num)): First, we convert the number to its absolute value using Math.abs(num) to handle negative numbers. Then, we convert this absolute value to a string.
• Character.getNumericValue(numStr.charAt(i)): For each character in the string, we use charAt(i) to get the digit (as a character) and then Character.getNumericValue() to convert it back to an integer.
• Looping: We loop through each character of the string, adding the numeric value of each digit to the sum.

Edge Cases

1. Negative Numbers: The code handles negative numbers by using Math.abs(num), ensuring that negative inputs are treated as positive. For example, -12345 will also give the sum 15, just like 12345.
2. Zero: If the input is zero (0), the string will contain just one character '0', and the sum will be 0 as expected.
3. Multi-Digit Numbers: The method works seamlessly for multi-digit numbers. Since we treat the number as a string, it doesn’t matter how many digits the number has.

Optimizing for Large Numbers

Java’s primitive data types like int and long can only handle numbers up to a certain size. If you are working with extremely large numbers, consider using Java’s BigInteger class, which can handle arbitrarily large integers. When using BigInteger, the method can still work in the same way by converting the number to a string.

Here's an example using BigInteger: 

import java.math.BigInteger;
public class SumOfDigits {
    public static int sumOfDigits(BigInteger num) {
        String numStr = num.toString(); // Convert BigInteger to string
        int sum = 0;
        // Loop through each character in the string
        for (int i = 0; i < numStr.length(); i++) {
            sum += Character.getNumericValue(numStr.charAt(i)); // Add the digit to the sum
        }
        return sum;
    }
    public static void main(String[] args) {
        BigInteger bigNum = new BigInteger("123456789012345678901234567890");
        System.out.println("Sum of digits: " + sumOfDigits(bigNum));
    }
}

Output

For the input number 123456789012345678901234567890, the output will be: 

Sum of digits: 135

Time Complexity

The time complexity of this method is O(d), where d is the number of digits in the input number. This is because the time taken to loop through each character of the string is proportional to the number of digits in the number.

However, string conversion has a higher overhead compared to looping methods. The process of converting a number to a string (and vice versa) takes additional time and resources, which can make this method slower than using loops, especially for smaller numbers. 

Also Read: String Functions In Java | Java String [With Examples] 

For large numbers, though, using BigInteger ensures that we can handle numbers that exceed the limits of primitive types.

Method 5: Using Streams (Java 8+)

Java 8 introduced Streams, a powerful tool for functional programming that allows you to work with collections of data in a more declarative way. Using Streams to calculate the sum of digits is a modern approach that leverages the power of functional programming, making the code more concise and readable.

Step-by-Step Explanation

The idea behind using Streams is to:

1. Convert the number into a string (like in the string conversion method).
2. Convert each character of the string into a stream of integers.
3. Use a Stream operation to sum up the digits.

This approach is clean, efficient, and makes use of Java's built-in libraries for functional programming.

Code Example 

import java.util.stream.*;
public class SumOfDigits {
    public static int sumOfDigits(int num) {
        // Convert number to string and use streams to process each character
        return String.valueOf(Math.abs(num))  // Convert number to string and handle negative numbers
                .chars()                    // Create an IntStream of characters
                .map(Character::getNumericValue)  // Convert characters to their numeric value
                .sum();                     // Sum the values of the digits
    }
    public static void main(String[] args) {
        int number = 9876;
        System.out.println("Sum of digits: " + sumOfDigits(number));
    }
}

Output

Sum of digits: 30

This is because 9 + 8 + 7 + 6 = 30.

Code Breakdown:

• String.valueOf(Math.abs(num)): Converts the number to a string and ensures it is positive by applying Math.abs(num) for negative numbers.
• chars(): This converts the string into an IntStream, where each character in the string is treated as a stream element.
• Character::getNumericValue: For each character in the stream, we convert it back into its corresponding numeric value (e.g., the character '9' becomes the integer 9).
• sum(): Finally, we sum up all the digits in the stream.

Edge Cases

1. Negative Numbers: The method handles negative numbers by converting them to their absolute values before processing. For example, -9876 will still give the sum 30, just like 9876.
2. Zero: If the input is zero (0), the stream will contain just one element, '0', and the sum will be 0.
3. Multi-Digit Numbers: The method works well for multi-digit numbers, handling them as long as they can be converted into a string representation.

Optimizing for Large Numbers

Java 8 Streams are quite powerful but are not optimized for performance in every case. For extremely large numbers, where performance is crucial, it’s important to remember that Streams introduce some overhead. However, for most practical purposes, using Streams will be efficient enough.

The BigInteger class has its own methods that support functional operations, but you can also use Streams for large numbers, just as we did with primitive types.

Code Example with BigInteger 

import java.math.BigInteger;
import java.util.stream.*;
public class SumOfDigits {
    public static int sumOfDigits(BigInteger num) {
        // Convert BigInteger to string and use streams to process each character
        return num.toString()  // Convert BigInteger to string
                .chars()      // Create an IntStream of characters
                .map(Character::getNumericValue)  // Convert characters to their numeric value
                .sum();       // Sum the values of the digits
    }
    public static void main(String[] args) {
        BigInteger bigNum = new BigInteger("123456789012345678901234567890");
        System.out.println("Sum of digits: " + sumOfDigits(bigNum));
    }
}

Output

For the input number 123456789012345678901234567890, the output will be: 

Sum of digits: 135

Time Complexity

The time complexity of this method is O(d), where d is the number of digits in the input number, just like the previous methods. 

However, Streams have a slight overhead compared to simple loops due to their functional nature and additional processing steps. For small numbers, this overhead is negligible, but for large numbers, the performance might be slightly impacted compared to a simple loop-based solution.

Also Read: Exploring the 14 Key Advantages of Java: Why It Remains a Developer's Top Choice in 2025

Now that we've explored various methods, let’s compare them and find out which one suits your needs best.

Comparing the Methods

Looking at this comparison will help you choose the method that best fits your needs based on performance, readability, and the size of the numbers you're working with.

Here’s a side-by-side performance breakdown:

Now that we've compared the methods, let's move on to some best practices to keep your code clean, efficient, and error-free.

Best Coding Practices for Summing Digits in Java

Let’s go over some key best practices that will help you write cleaner, more efficient Java code when summing digits.

• Write Clear, Descriptive Names:

When writing a method to calculate the sum of digits of a number in Java, make sure your variable and method names are clear. 

For example, name your method sumOfDigits(int num) and avoid using vague names like sum or temp. This makes your code easier to understand and maintain.

• Keep Functions Focused:

Your function for calculating the sum of digits should focus solely on summing digits. Don’t mix it with other responsibilities, like validating user input or formatting output. This follows the Single Responsibility Principle and makes your code cleaner. 

For example, sumOfDigits(int num) should just return the sum, not deal with other tasks.

• Handle Edge Cases Properly:

Always consider edge cases like negative numbers, zero, and very large numbers. For example, when calculating the sum of digits of a number in Java with example, ensure negative numbers are converted to positive values using Math.abs(num) to avoid incorrect results. 

Also, consider what happens when the number is zero. In that case, your method should return 0.

• Optimize Performance:

While loops are the most efficient computationally, streams add readability but introduce minor overhead. If performance is a concern, especially with large integers, try to avoid string conversion or recursion, as they introduce unnecessary overhead. 

Use the for loop or while loop for better control over the process and memory.

• Avoid Unnecessary Data Structures:

When summing digits, avoid using unnecessary data structures like arrays or lists unless your problem specifically requires them. 

For example, converting the number to a string is handy, but it’s not always the most memory-efficient way, especially when you’re only interested in the digits. Stick to simpler structures like integers or loops whenever possible.

• Write Test Cases:

As with any function, make sure to test your sum of digits function with various inputs. Test it with:

1. Positive numbers (e.g., 123)
2. Negative numbers (e.g., -123)
3. Zero (e.g., 0)
4. Large numbers (e.g., 9876543210) By testing a variety of edge cases, you ensure your code handles all scenarios.
   

• Comment Your Code:

Even if your code is simple, add comments where necessary, especially if you're using recursion or more complex approaches like sum of digits of a number in Java using for loop. 

For example, explain how the loop works and why you're using num % 10 to get the last digit.

Remember, the goal is to write code that is easy to understand, efficient to run, and free of errors—whether you’re summing digits or tackling more complex problems!

How Well Do You Know Summing Digits in Java? 10 Questions

Test your understanding of summing digits in Java with these questions! From basic concepts to advanced methods, let's see how well you grasp the techniques.

1. What is the primary purpose of calculating the sum of digits of a number in Java?

A) To convert a number to a string

B) To perform mathematical operations

C) To extract individual digits and sum them

D) To find the maximum digit in a number

2. Which of the following methods can be used to sum the digits of a number in Java?

A) Using a for loop

B) Using a while loop

C) Using recursion

D) All of the above

3. What is the result of summing the digits of the number 459 in Java?

A) 18

B) 15

C) 13

D) 9

4. How can you handle negative numbers when summing digits in Java?

A) Convert the number to a positive using Math.abs()

B) Ignore the negative sign

C) Treat negative numbers as zero

D) Use a different method for negative numbers

5. Which method is best suited for handling extremely large numbers when summing digits in Java?

A) Using recursion

B) Using the string conversion method

C) Using a for loop

D) Using BigInteger class

6. What is the time complexity of the method for summing digits in Java using a for loop?

A) O(1)

B) O(d)

C) O(n^2)

D) O(log n)

7. Which method for summing digits in Java can lead to a stack overflow error if used with large numbers?

A) For loop

B) While loop

C) Recursion

D) String conversion

8. How does the string conversion method work when summing digits in Java?

A) By converting the number to a string and summing the ASCII values

B) By converting the number to a string and summing the individual characters' numeric values

C) By using a loop to extract digits from the string

D) By converting the digits to integers and summing them using a for loop

9. Which of the following is a limitation of using recursion for summing digits in Java?

A) It is less readable

B) It requires additional memory for each recursive call

C) It can be slower than a for loop

D) It cannot handle negative numbers

10. How can the sum of digits of a number be calculated efficiently in Java for both small and large numbers?

A) Using recursion

B) Using a while loop with manual digit extraction

C) Using string conversion for better readability

D) Using a combination of BigInteger and string conversion

Also Read: Top 13 String Functions in Java | Java String [With Examples]

You can further enhance your Java skills by practicing summing digits techniques and exploring advanced Java methods, helping you master real-world applications and strengthen your programming expertise.

How Can upGrad Help You Master Advanced Java Techniques?

Dive into advanced Java techniques for summing digits, including efficient methods like loops, recursion, and string conversion. Gain hands-on experience with different approaches, which are essential for building optimized, high-performance applications that handle a variety of numerical tasks.

Explore more Java concepts and deepen your understanding of real-world applications to enhance your programming skills.

Below are some relevant upGrad courses:

• Core Java Basics
• JavaScript Basics from Scratch
• Learn Basic Python Programming
• Data Structures & Algorithms
• AI-Powered Full Stack Development Course by IIITB

You can also receive personalized career guidance with upGrad to help navigate your career path, or visit your nearest upGrad center to begin practical, hands-on training today!

Similar Reads:

• Step by Step Java Tutorial Concepts - From Beginner to Pro
• What is Java? Java Programming Language Explained
• History of Java
• Java Tutorial for Beginners
• How Java Program Works?
• What is Java JDK? Java Development Kit
• Difference between Python and Java
• Difference Between Java and JavaScript
• Difference Between Java and JavaScript
• From Java Source Code to Executable
• Java Installation on Linux: A Beginner-Friendly Guide
• Step-by-Step Guide: Installing Java on Windows 10
• Java Hello World Program: Your First Step into Java Programming

FAQs

1. How can I improve the performance of calculating the sum of digits of a number in Java with example?

You can improve performance by using the most efficient methods like the sum of digits of a number in Java using for loop instead of recursion or string conversion, especially for large numbers.

2. Is it better to use recursion or a for loop for summing digits in Java?

For most cases, using the sum of digits of a number in Java using for loop is more efficient, as recursion may cause stack overflow for large numbers.

3. Can I sum digits of a large number using BigInteger in Java?

Yes, you can use BigInteger in Java to handle extremely large numbers and calculate the sum of digits of a number in Java with example efficiently.

4. How do I handle decimal numbers while summing digits in Java?

Convert the number to a string and sum the digits before the decimal point. Alternatively, extract the integer part first and handle the digits separately.

5. Can the sum of digits of a number in Java using for loop handle negative numbers?

Yes, you can handle negative numbers by converting them to their absolute value before summing the digits.

6. What is the time complexity when summing digits using a for loop in Java?

The time complexity is O(d), where d is the number of digits in the number being processed.

7. How can I sum digits of a very large number in Java without converting it to a string?

You can directly use a mathematical approach like the sum of digits of a number in Java using for loop, iterating through the digits by dividing the number by 10.

8. What if I need to sum the digits of a number in Java with example and preserve leading zeros?

Leading zeros are not stored in integers, but you can handle them by converting the number to a string first.

9. How do I sum digits in Java for a number stored in an array?

Iterate through the array, converting each element to an integer and summing them up using a loop or recursion.

10. Is there any performance impact when using the sum of digits of a number in Java with example on large datasets?

Yes, for large datasets, methods like recursion or string conversion might be slower; using sum of digits of a number in Java using for loop is more efficient.

11. Can I use a stream in Java to sum the digits of a number?

Yes, Java streams provide a functional approach to summing digits by converting the number to a string and using stream operations like mapToInt() to sum the digits.

Take the Free Quiz on Java

Answer quick questions and assess your Java knowledge

Start Quiz