这是我做的一个非常简单的方法，适用于任何数字:

public static int numberLength(int userNumber) {

    int numberCounter = 10;
    boolean condition = true;
    int digitLength = 1;

    while (condition) {
        int numberRatio = userNumber / numberCounter;
        if (numberRatio < 1) {
            condition = false;
        } else {
            digitLength++;
            numberCounter *= 10;
        }
    }

    return digitLength; 
}

它的工作方式是使用数字计数器变量，即10 = 1位空格。例如。1 = 1十分之一=> 1位空格。因此，如果你有int number = 103342;你会得到6，因为这相当于。000001个空格。还有，谁有更好的numberCounter变量名?我想不出比这更好的了。

编辑:我想到了一个更好的解释。本质上，这个while循环所做的就是让你的数字除以10，直到它小于1。从本质上讲，当你将一个数除以10时，你是在向后移动一个数字空间，所以你只需将它除以10，直到你的数字中的位数小于1。

下面是另一个版本，可以计算小数中的数字数量:

public static int repeatingLength(double decimalNumber) {

    int numberCounter = 1;
    boolean condition = true;
    int digitLength = 1;

    while (condition) {
        double numberRatio = decimalNumber * numberCounter;

        if ((numberRatio - Math.round(numberRatio)) < 0.0000001) {
            condition = false;
        } else {
            digitLength++;
            numberCounter *= 10;
        }
    }
    return digitLength - 1;
}

我在看了Integer.java源代码后写了这个函数。

private static int stringSize(int x) {
    final int[] sizeTable = {9, 99, 999, 9_999, 99_999, 999_999, 9_999_999,
            99_999_999, 999_999_999, Integer.MAX_VALUE};
    for (int i = 0; ; ++i) {
        if (x <= sizeTable[i]) {
            return i + 1;
        }
    }
}

由于以10为基数的整数的位数只是1 + truncate(log10(number))，您可以这样做:

public class Test {

    public static void main(String[] args) {

        final int number = 1234;
        final int digits = 1 + (int)Math.floor(Math.log10(number));

        System.out.println(digits);
    }
}

被编辑是因为我的最后一次编辑修复了代码示例，但没有修复描述。

那简单的数学呢?除以10，直到0。

public static int getSize(long number) {
        int count = 0;
        while (number > 0) {
            count += 1;
            number = (number / 10);
        }
        return count;
    }

你的基于字符串的解决方案是完全OK的，没有什么“不整洁”的。你必须意识到，在数学上，数字没有长度，也没有数字。长度和数字都是数字在特定基底(即字符串)中的物理表示形式的属性。

基于对数的解决方案在内部完成(部分)与基于字符串的解决方案相同的工作，并且可能(微不足道地)更快，因为它只生成长度而忽略数字。但实际上我并不认为它的意图更明确——这是最重要的因素。

现在还不能留言，所以我会单独回复。

基于对数的解决方案不能计算非常大的长整数的正确位数，例如:

long n = 99999999999999999L;

// correct answer: 17
int numberOfDigits = String.valueOf(n).length();

// incorrect answer: 18
int wrongNumberOfDigits = (int) (Math.log10(n) + 1); 

基于对数的解决方案在大整数中计算不正确的位数