简单的解决方案:

public class long_length {
    long x,l=1,n;
    for (n=10;n<x;n*=10){
        if (x/n!=0){
            l++;
        }
    }
    System.out.print(l);
}

由于以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);
    }
}

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

这个递归方法呢?

    private static int length = 0;

    public static int length(int n) {
    length++;
    if((n / 10) < 10) {
        length++;
    } else {
        length(n / 10);
    }
    return length;
}

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

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

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

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

long n = 99999999999999999L;

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

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

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

下面是JDK开发人员给出的解决方案。JDK 17 (Long类):

/**
 * Returns the string representation size for a given long value.
 *
 * @param x long value
 * @return string size
 *
 * @implNote There are other ways to compute this: e.g. binary search,
 * but values are biased heavily towards zero, and therefore linear search
 * wins. The iteration results are also routinely inlined in the generated
 * code after loop unrolling.
 */
static int stringSize(long x) {
    int d = 1;
    if (x >= 0) {
        d = 0;
        x = -x;
    }
    long p = -10;
    for (int i = 1; i < 19; i++) {
        if (x > p)
            return i + d;
        p = 10 * p;
    }
    return 19 + d;
}

注意，如果需要的话，该方法会考虑减号。

不幸的是，该方法没有公开。

在性能方面，您可以从评论中看到，JDK开发人员与其他选项相比至少考虑了这一点。我猜 分而治之的方法倾向于较小的数字，效果会稍好一些 更好，因为CPU可以比整数更快地进行整数比较 乘法。但这种差异可能小到无法测量。

无论如何，我希望JDK中已经公开了这个方法，这样人们就不会开始使用自己的方法了。