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