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

*Learn Spring*course:

**>> CHECK OUT THE COURSE**

Last modified: November 10, 2021

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.

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

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

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

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.

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

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.

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 *log _{10}0* of any number isn't defined, so if we're expecting any input with value

**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.

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.

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.

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.

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.

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.

Follow the Java Category

Follow the Java category to get regular info about the new articles and tutorials we publish here.