Java Top

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

> CHECK OUT THE COURSE

1. Introduction

In this quick tutorial, we'll explore different ways of getting the number of digits in an Integer in Java.

We'll also analyze the different methods to figure out which algorithm would best fit each situation.

Further reading:

How to Round a Number to N Decimal Places in Java

Overview of several ways of handling the common problem of rounding a decimal number in Java

Check If a String Is Numeric in Java

Explore different ways to determine whether a String is numeric or not.

A Practical Guide to DecimalFormat

Explore the Java's DecimalFormat class along with its practical usages.

2. Number of Digits in an Integer

For the methods discussed here, we're only considering positive integers. If we expect any negative input, then we can first make use of Math.abs(number) before using any of these methods.

2.1. String-Based Solution

Perhaps the easiest way of getting the number of digits in an Integer is by converting it to String, and calling the length() method. This will return the length of the String representation of our number:

int length = String.valueOf(number).length();

However, this may be a sub-optimal approach, as this statement involves memory allocation for a String for each evaluation. The JVM must parse our number and copy its digits into a separate String, as well as perform a number of other different operations (like keeping temporary copies, handle Unicode conversions, etc).

If we only have a few numbers to evaluate, then we can use this solution because the difference between this and any other approach will be negligible, even for large numbers.

2.2. Logarithmic Approach

For numbers represented in decimal form, if we take their log in base 10 and round it up, we'll get the number of digits in that number:

int length = (int) (Math.log10(number) + 1);

Note that log100 of any number isn't defined, so if we're expecting any input with value 0, then we can put a check for that as well.

The logarithmic approach is significantly faster than the String based approach, as it doesn't have to go through the process of any data conversion. It just involves a simple, straightforward calculation without any extra object initialization or loops.

2.3. Repeated Multiplication

In this method, we'll take a temporary variable (initialized to 1) and continuously multiply it by 10 until it becomes greater than our number. During this process, we'll also use a length variable, which will keep track of the number's length:

int length = 0;
long temp = 1;
while (temp <= number) {
    length++;
    temp *= 10;
}
return length;

In this code, temp *= 10 is the same as writing temp = (temp << 3) + (temp << 1). Since multiplication is usually a costlier operation on some processors compared to shift operators, the latter may be a bit more efficient.

2.4. Dividing With Powers of Two

If we know the range of our number, then we can use a variation that will further reduce our comparisons. This method divides the number by powers of two (e.g. 1, 2, 4, 8, etc.):

int length = 1;
if (number >= 100000000) {
    length += 8;
    number /= 100000000;
}
if (number >= 10000) {
    length += 4;
    number /= 10000;
}
if (number >= 100) {
    length += 2;
    number /= 100;
}
if (number >= 10) {
    length += 1;
}
return length;

It takes advantage of the fact that any number can be represented by the addition of powers of 2. For example, 15 can be represented as 8+4+2+1, which are all powers of 2.

For a 15 digit number, we would be doing 15 comparisons in our previous approach, compared to just four in this method.

2.5. Divide and Conquer

This is perhaps the bulkiest approach when compared to all the others described here; however, it's also the fastest because we're not performing any type of conversion, multiplication, addition, or object initialization.

We can get our answer in just three or four simple if statements:

if (number < 100000) {
    if (number < 100) {
        if (number < 10) {
            return 1;
        } else {
            return 2;
        }
    } else {
        if (number < 1000) {
            return 3;
        } else {
            if (number < 10000) {
                return 4;
            } else {
                return 5;
            }
        }
    }
} else {
    if (number < 10000000) {
        if (number < 1000000) {
            return 6;
        } else {
            return 7;
        }
    } else {
        if (number < 100000000) {
            return 8;
        } else {
            if (number < 1000000000) {
                return 9;
            } else {
                return 10;
            }
        }
    }
}

Similar to the previous approach, we can only use this method if we know the range of our number.

3. Benchmarking

Now that we have a good understanding of the potential solutions, let's do some simple benchmarking of our methods using the Java Microbenchmark Harness (JMH).

The following table shows the average processing time of each operation (in nanoseconds):

Benchmark                            Mode  Cnt   Score   Error  Units
Benchmarking.stringBasedSolution     avgt  200  32.736 ± 0.589  ns/op
Benchmarking.logarithmicApproach     avgt  200  26.123 ± 0.064  ns/op
Benchmarking.repeatedMultiplication  avgt  200   7.494 ± 0.207  ns/op
Benchmarking.dividingWithPowersOf2   avgt  200   1.264 ± 0.030  ns/op
Benchmarking.divideAndConquer        avgt  200   0.956 ± 0.011  ns/op

The String-based solution, which is the simplest, is also the most costly operation, as it's the only one which requires data conversion and the initialization of new objects.

The logarithmic approach is significantly more efficient than the previous solution, as it doesn't involve any data conversion. Also, being a single line solution, it can be a good alternative to the String-based approach.

Repeated multiplication involves simple multiplication in proportion with the number length; for example, if a number is 15 digits long, then this method will involve 15 multiplications.

However, the very next method takes advantage of the fact that every number can be represented by powers of two (the approach similar to BCD). It reduces the same equation to four division operations, so it's even more efficient than the former.

Finally, as we can infer, the most efficient algorithm is the verbose Divide and Conquer implementation, which delivers the answer in just three or four simple if statements. We can use it if we have a large dataset of numbers we need to analyze.

4. Conclusion

In this brief article, we outlined some of the ways to find the number of digits in an Integer, and compared the efficiency of each approach.

As always, the complete code is available over on GitHub.

Java bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

>> CHECK OUT THE COURSE
Generic footer banner
Comments are closed on this article!