一个人想要这样做主要是因为他/她想要“呈现”它，这主要意味着它最终需要显式或隐式地“toString-ed”(或以另一种方式转换);才能呈现(例如打印出来)。如果是这种情况，那么只需尝试显式地使用必要的“toString”并计算位数。

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

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

使用Java

int nDigits = Math.floor(Math.log10(Math.abs(the_integer))) + 1;

使用import java.lang.Math.*;一开始

使用C

int nDigits = floor(log10(abs(the_integer))) + 1;

在开始时使用include math.h

我看到有人使用String库，甚至使用Integer类。这没什么问题，但是求位数的算法并不复杂。我在这个例子中使用的是long类型，但它也可以用于int类型。

 private static int getLength(long num) {

    int count = 1;

    while (num >= 10) {
        num = num / 10;
        count++;
    }

    return count;
}

我在看了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;
        }
    }
}

Marian的解决方案适用于长类型数字(高达9,223,372,036,854,775,807)，以防有人想要复制和粘贴它。 在程序中，我写了这个，因为10000以内的数字更有可能，所以我为它们做了一个特定的分支。不管怎样，这不会有太大的区别。

public static int numberOfDigits (long n) {     
    // Guessing 4 digit numbers will be more probable.
    // They are set in the first branch.
    if (n < 10000L) { // from 1 to 4
        if (n < 100L) { // 1 or 2
            if (n < 10L) {
                return 1;
            } else {
                return 2;
            }
        } else { // 3 or 4
            if (n < 1000L) {
                return 3;
            } else {
                return 4;
            }
        }           
    } else  { // from 5 a 20 (albeit longs can't have more than 18 or 19)
        if (n < 1000000000000L) { // from 5 to 12
            if (n < 100000000L) { // from 5 to 8
                if (n < 1000000L) { // 5 or 6
                    if (n < 100000L) {
                        return 5;
                    } else {
                        return 6;
                    }
                } else { // 7 u 8
                    if (n < 10000000L) {
                        return 7;
                    } else {
                        return 8;
                    }
                }
            } else { // from 9 to 12
                if (n < 10000000000L) { // 9 or 10
                    if (n < 1000000000L) {
                        return 9;
                    } else {
                        return 10;
                    }
                } else { // 11 or 12
                    if (n < 100000000000L) {
                        return 11;
                    } else {
                        return 12;
                    }
                }
            }
        } else { // from 13 to ... (18 or 20)
            if (n < 10000000000000000L) { // from 13 to 16
                if (n < 100000000000000L) { // 13 or 14
                    if (n < 10000000000000L) { 
                        return 13;
                    } else {
                        return 14;
                    }
                } else { // 15 or 16
                    if (n < 1000000000000000L) {
                        return 15;
                    } else {
                        return 16;
                    }
                }
            } else { // from 17 to ...¿20?
                if (n < 1000000000000000000L) { // 17 or 18
                    if (n < 100000000000000000L) {
                        return 17;
                    } else {
                        return 18;
                    }
                } else { // 19? Can it be?
                    // 10000000000000000000L is'nt a valid long.
                    return 19;
                }
            }
        }
    }
}