如何获取 int 中的位数？

Question

有没有比此方法更简洁的方法来获取 int 中的位数？

int numDigits = String.valueOf(1000).length();

Answer 1

您的基于字符串的解决方案完全没问题，没有什么“不整洁”的。你必须意识到，从数学上来说，数字没有长度，也没有数字。长度和数字都是特定基数（即字符串）中数字的物理表示的属性。

基于对数的解决方案在内部执行（某些）与基于字符串的解决方案相同的操作，并且可能（不明显）更快，因为它只生成长度并忽略数字。但我实际上不会认为它的意图更清晰——这是最重要的因素。

Answer 2

对数是你的朋友：

int n = 1000;
int length = (int)(Math.log10(n)+1);

注意：仅对 n > 有效。 0。

Answer 3

最快的方法：分而治之。

假设您的范围是 0 到 MAX_INT，那么您有 1 到 10 位数字。您可以使用分而治之的方法接近此间隔，每个输入最多进行 4 次比较。首先，通过一次比较将 [1..10] 分为 [1..5] 和 [6..10]，然后使用一次比较将每个长度 5 的区间划分为一个长度 3 和一个长度 2 的区间。长度2区间需要再比较一次（共3次比较），长度3区间又可以分为长度1区间（解）和长度2区间。因此，您需要进行 3 或 4 次比较。

没有除法，没有浮点运算，没有昂贵的对数，只有整数比较。

代码（长但快）：

if (n < 100000) { // 1 to 5
    if (n < 100) { // 1 or 2
        if (n < 10) return 1;
        return 2;
    }
    else { // 3, 4 or 5
        if (n < 1000) return 3;
        if (n < 10000) return 4;
        return 5;
    }
}
else { // 6 to 7
    if (n < 10000000) { // 6 or 7
        if (n < 1000000) return 6;
        return 7;
    }
    else { // 8, 9 or 10
        if (n < 100000000) return 8;
        if (n < 1000000000) return 9;
        return 10;
    }
}

基准测试（JVM 预热后）- 请参阅下面的代码以了解基准测试是如何运行的：

1. 基线方法（使用 String.length）：
   2145ms
2. log10 方法：711ms = 3.02 倍
   一样快
3. 与基线重复除法 ：2797ms = 0.77 倍
   一样快
4. 与基线分而治之 ：74ms = 28.99
   与基线一样快的倍

完整代码：

public static void main(String[] args) throws Exception {
    
    // validate methods:
    for (int i = 0; i < 1000; i++)
        if (method1(i) != method2(i))
            System.out.println(i);
    for (int i = 0; i < 1000; i++)
        if (method1(i) != method3(i))
            System.out.println(i + " " + method1(i) + " " + method3(i));
    for (int i = 333; i < 2000000000; i += 1000)
        if (method1(i) != method3(i))
            System.out.println(i + " " + method1(i) + " " + method3(i));
    for (int i = 0; i < 1000; i++)
        if (method1(i) != method4(i))
            System.out.println(i + " " + method1(i) + " " + method4(i));
    for (int i = 333; i < 2000000000; i += 1000)
        if (method1(i) != method4(i))
            System.out.println(i + " " + method1(i) + " " + method4(i));
    
    // work-up the JVM - make sure everything will be run in hot-spot mode
    allMethod1();
    allMethod2();
    allMethod3();
    allMethod4();
    
    // run benchmark
    Chronometer c;
    
    c = new Chronometer(true);
    allMethod1();
    c.stop();
    long baseline = c.getValue();
    System.out.println(c);
    
    c = new Chronometer(true);
    allMethod2();
    c.stop();
    System.out.println(c + " = " + StringTools.formatDouble((double)baseline / c.getValue() , "0.00") + " times as fast as baseline");
    
    c = new Chronometer(true);
    allMethod3();
    c.stop();
    System.out.println(c + " = " + StringTools.formatDouble((double)baseline / c.getValue() , "0.00") + " times as fast as baseline");
    
    c = new Chronometer(true);
    allMethod4();
    c.stop();
    System.out.println(c + " = " + StringTools.formatDouble((double)baseline / c.getValue() , "0.00") + " times as fast as baseline");
}


private static int method1(int n) {
    return Integer.toString(n).length();
}

private static int method2(int n) {
    if (n == 0)
        return 1;
    return (int)(Math.log10(n) + 1);
}

private static int method3(int n) {
    if (n == 0)
        return 1;
    int l;
    for (l = 0 ; n > 0 ;++l)
        n /= 10;
    return l;
}

private static int method4(int n) {
    if (n < 100000) {
        // 5 or less
        if (n < 100) {
            // 1 or 2
            if (n < 10)
                return 1;
            else
                return 2;
        } else {
            // 3 or 4 or 5
            if (n < 1000)
                return 3;
            else {
                // 4 or 5
                if (n < 10000)
                    return 4;
                else
                    return 5;
            }
        }
    } else {
        // 6 or more
        if (n < 10000000) {
            // 6 or 7
            if (n < 1000000)
                return 6;
            else
                return 7;
        } else {
            // 8 to 10
            if (n < 100000000)
                return 8;
            else {
                // 9 or 10
                if (n < 1000000000)
                    return 9;
                else
                    return 10;
            }
        }
    }
}


private static int allMethod1() {
    int x = 0;
    for (int i = 0; i < 1000; i++)
        x = method1(i);
    for (int i = 1000; i < 100000; i += 10)
        x = method1(i);
    for (int i = 100000; i < 1000000; i += 100)
        x = method1(i);
    for (int i = 1000000; i < 2000000000; i += 200)
        x = method1(i);
    
    return x;
}

private static int allMethod2() {
    int x = 0;
    for (int i = 0; i < 1000; i++)
        x = method2(i);
    for (int i = 1000; i < 100000; i += 10)
        x = method2(i);
    for (int i = 100000; i < 1000000; i += 100)
        x = method2(i);
    for (int i = 1000000; i < 2000000000; i += 200)
        x = method2(i);
    
    return x;
}

private static int allMethod3() {
    int x = 0;
    for (int i = 0; i < 1000; i++)
        x = method3(i);
    for (int i = 1000; i < 100000; i += 10)
        x = method3(i);
    for (int i = 100000; i < 1000000; i += 100)
        x = method3(i);
    for (int i = 1000000; i < 2000000000; i += 200)
        x = method3(i);
    
    return x;
}

private static int allMethod4() {
    int x = 0;
    for (int i = 0; i < 1000; i++)
        x = method4(i);
    for (int i = 1000; i < 100000; i += 10)
        x = method4(i);
    for (int i = 100000; i < 1000000; i += 100)
        x = method4(i);
    for (int i = 1000000; i < 2000000000; i += 200)
        x = method4(i);
    
    return x;
}

再次，基准测试：

1. 基线方法（使用 String.length）：2145ms
2. log10 方法：711ms = 3.02 倍于基线
3. 重复除法：2797ms = 0.77 倍于基线
4. 分而治之： 74ms = 比基线快 28.99 倍

---

编辑

在编写基准测试之后，我从 Java 6 中偷偷了解了 Integer.toString，我发现它使用了：

final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                  99999999, 999999999, Integer.MAX_VALUE };

// Requires positive x
static int stringSize(int x) {
    for (int i=0; ; i++)
        if (x <= sizeTable[i])
            return i+1;
}

我根据我的分而治之解决方案对它进行了基准测试：

4. 分而治之-征服：104ms
5. Java 6 解决方案 - 迭代和比较：406ms

我的解决方案大约是 Java 6 解决方案的 4 倍。

Answer 4

对你的基准测试的两个评论：Java是一个复杂的环境，有即时编译和垃圾收集等等，所以为了得到公平的比较，每当我运行基准测试时，我总是：（a）附上两个测试在一个循环中按顺序运行它们 5 或 10 次。通常，第二次循环的运行时间与第一次的运行时间有很大不同。 (b) 在每次“方法”之后，我都会执行 System.gc() 来尝试触发垃圾收集。否则，第一种方法可能会生成一堆对象，但不足以强制进行垃圾收集，然后第二种方法会创建一些对象，堆耗尽，然后运行垃圾收集。然后第二个途径就被“收费”，用于捡起第一个途径留下的垃圾。非常不公平！

也就是说，上述两项在此示例中都没有产生显着差异。

不管有没有这些修改，我得到的结果与你的结果非常不同。当我运行这个时，是的，toString 方法的运行时间为 6400 到 6600 毫秒，而 log 方法 topok 的运行时间为 20,000 到 20,400 毫秒。对我来说，日志方法非但没有稍微快一点，反而慢了 3 倍。

请注意，这两种方法涉及非常不同的成本，因此这并不完全令人震惊：toString 方法将创建大量必须清理的临时对象，而 log 方法需要更密集的计算。所以也许区别在于，在内存较少的机器上，toString 需要更多的垃圾收集轮次，而在处理器较慢的机器上，额外计算 log 会更痛苦。

我还尝试了第三种方法。我写了这个小函数：

static int numlength(int n)
{
    if (n == 0) return 1;
    int l;
    n=Math.abs(n);
    for (l=0;n>0;++l)
        n/=10;
    return l;           
}

运行时间为 1600 到 1900 毫秒——不到我机器上 toString 方法的 1/3，以及 log 方法的 1/10。

如果您的数字范围很广，您可以通过除以 1,000 或 1,000,000 来进一步加快速度，以减少循环次数。我没玩过那个。

Answer 5

还不能发表评论，所以我将作为单独的答案发布。

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

long n = 99999999999999999L;

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

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

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

Answer 6

使用 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;

使用 inclue math.h一开始

Answer 7

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

已编辑，因为我上次编辑修复了代码示例，但不是描述。

Answer 8

另一种字符串方法。简短而甜蜜——对于任何整数n。

int length = ("" + n).length();

Answer 9

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;
                }
            }
        }
    }
}

Answer 10

普通的旧数学怎么样？除以 10，直到达到 0。

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

Answer 11

我看到人们使用 String 库甚至使用 Integer 类。这没有什么问题，但是获取位数的算法并不复杂。我在这个例子中使用了 long，但它与 int 的效果一样好。

 private static int getLength(long num) {

    int count = 1;

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

    return count;
}

Answer 12

我可以尝试吗？ ;)

基于德克的解决方案

final int digits = number==0?1:(1 + (int)Math.floor(Math.log10(Math.abs(number))));

Answer 13

玛丽安的解决方案，现在有了三元：

 public int len(int n){
        return (n<100000)?((n<100)?((n<10)?1:2):(n<1000)?3:((n<10000)?4:5)):((n<10000000)?((n<1000000)?6:7):((n<100000000)?8:((n<1000000000)?9:10)));
    }

因为我们可以。

Answer 14

没有 String API，没有 utils，没有类型转换，只有纯 java 迭代 ->

public static int getNumberOfDigits(int input) {
    int numOfDigits = 1;
    int base = 1;
    while (input >= base * 10) {
        base = base * 10;
        numOfDigits++;
    }
    return numOfDigits;
 }

如果您愿意，您可以做多更大的价值。

Answer 15

好奇，我尝试对其进行基准测试...

import org.junit.Test;
import static org.junit.Assert.*;


public class TestStack1306727 {

    @Test
    public void bench(){
        int number=1000;
        int a= String.valueOf(number).length();
        int b= 1 + (int)Math.floor(Math.log10(number));

        assertEquals(a,b);
        int i=0;
        int s=0;
        long startTime = System.currentTimeMillis();
        for(i=0, s=0; i< 100000000; i++){
            a= String.valueOf(number).length();
            s+=a;
        }
        long stopTime = System.currentTimeMillis();
        long runTime = stopTime - startTime;
        System.out.println("Run time 1: " + runTime);
        System.out.println("s: "+s);
        startTime = System.currentTimeMillis();
        for(i=0,s=0; i< 100000000; i++){
            b= number==0?1:(1 + (int)Math.floor(Math.log10(Math.abs(number))));
            s+=b;
        }
        stopTime = System.currentTimeMillis();
        runTime = stopTime - startTime;
        System.out.println("Run time 2: " + runTime);
        System.out.println("s: "+s);
        assertEquals(a,b);


    }
}

结果是：

Run time 1: 6765
s: 400000000
Run time 2: 6000
s: 400000000

现在我想知道我的基准测试是否确实意味着什么，但我确实在多次运行基准测试本身时得到了一致的结果（毫秒内的变化）...:)看起来尝试优化这个是没有用的...

---

编辑：根据 ptomli 的评论，我在上面的代码中用“i”替换了“number”，并在 5 次运行中得到了以下结果：

Run time 1: 11500
s: 788888890
Run time 2: 8547
s: 788888890

Run time 1: 11485
s: 788888890
Run time 2: 8547
s: 788888890

Run time 1: 11469
s: 788888890
Run time 2: 8547
s: 788888890

Run time 1: 11500
s: 788888890
Run time 2: 8547
s: 788888890

Run time 1: 11484
s: 788888890
Run time 2: 8547
s: 788888890

Answer 16

通过设计（基于问题）。这是分而治之的替代方法。我们首先定义一个枚举（考虑到它仅适用于无符号整数）。

public enum IntegerLength {
    One((byte)1,10),
    Two((byte)2,100),
    Three((byte)3,1000),
    Four((byte)4,10000),
    Five((byte)5,100000),
    Six((byte)6,1000000),
    Seven((byte)7,10000000),
    Eight((byte)8,100000000),
    Nine((byte)9,1000000000);

    byte length;
    int value;

    IntegerLength(byte len,int value) {
        this.length = len;
        this.value = value;
    }

    public byte getLenght() {
        return length;
    }

    public int getValue() {
        return value;
    }
}

现在我们将定义一个类来遍历枚举的值并进行比较并返回适当的长度。

public class IntegerLenght {
    public static byte calculateIntLenght(int num) {    
        for(IntegerLength v : IntegerLength.values()) {
            if(num < v.getValue()){
                return v.getLenght();
            }
        }
        return 0;
    }
}

该解决方案的运行时间与分治法相同。

Answer 17

这个递归方法怎么样？

    private static int length = 0;

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

Answer 18

简单的解决方案：

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);
}

Answer 19

一个非常简单的解决方案：

public int numLength(int n) {
  for (int length = 1; n % Math.pow(10, length) != n; length++) {}
  return length;
}

Answer 20

或者，您可以检查长度是否大于或小于所需的数字。

    public void createCard(int cardNumber, int cardStatus, int customerId) throws SQLException {
    if(cardDao.checkIfCardExists(cardNumber) == false) {
        if(cardDao.createCard(cardNumber, cardStatus, customerId) == true) {
            System.out.println("Card created successfully");
        } else {

        }
    } else {
        System.out.println("Card already exists, try with another Card Number");
        do {
            System.out.println("Enter your new Card Number: ");
            scan = new Scanner(System.in);
            int inputCardNumber = scan.nextInt();
            cardNumber = inputCardNumber;
        } while(cardNumber < 95000000);
        cardDao.createCard(cardNumber, cardStatus, customerId);
    }
}

}

Answer 21

我还没有看到基于乘法的解决方案。基于对数、除法和字符串的解决方案对于数百万个测试用例来说将变得相当笨拙，因此这里有一个针对整数的解决方案：

/**
 * Returns the number of digits needed to represents an {@code int} value in 
 * the given radix, disregarding any sign.
 */
public static int len(int n, int radix) {
    radixCheck(radix); 
    // if you want to establish some limitation other than radix > 2
    n = Math.abs(n);

    int len = 1;
    long min = radix - 1;

    while (n > min) {
        n -= min;
        min *= radix;
        len++;
    }

    return len;
}

在基数 10 中，这是有效的，因为 n 本质上是与 9、99、999 进行比较... 因为 min 是 9, 90, 900... 并且 n 被 9, 90, 900 减去...

不幸的是，仅通过替换 < 的每个实例，这不能移植到 long code>int 由于溢出。另一方面，它恰好适用于底座 2 和 10（但对于大多数其他底座来说严重失败）。您需要一个溢出点查找表（或除法测试......呃）

/**
 * For radices 2 &le r &le Character.MAX_VALUE (36)
 */
private static long[] overflowpt = {-1, -1, 4611686018427387904L,
    8105110306037952534L, 3458764513820540928L, 5960464477539062500L,
    3948651115268014080L, 3351275184499704042L, 8070450532247928832L,
    1200757082375992968L, 9000000000000000000L, 5054470284992937710L,
    2033726847845400576L, 7984999310198158092L, 2022385242251558912L,
    6130514465332031250L, 1080863910568919040L, 2694045224950414864L,
    6371827248895377408L, 756953702320627062L, 1556480000000000000L,
    3089447554782389220L, 5939011215544737792L, 482121737504447062L,
    839967991029301248L, 1430511474609375000L, 2385723916542054400L,
    3902460517721977146L, 6269893157408735232L, 341614273439763212L,
    513726300000000000L, 762254306892144930L, 1116892707587883008L,
    1617347408439258144L, 2316231840055068672L, 3282671350683593750L,
    4606759634479349760L};

public static int len(long n, int radix) {
    radixCheck(radix);
    n = abs(n);

    int len = 1;
    long min = radix - 1;
    while (n > min) {
        len++;
        if (min == overflowpt[radix]) break;
        n -= min;
        min *= radix;

    }

    return len;
}

Answer 22

人们想要这样做主要是因为他/她想要“呈现”它，这主要意味着它最终需要显式或隐式地“toString-ed”（或以另一种方式转换）；在呈现之前（例如打印）。

如果是这种情况，那么只需尝试明确必要的“toString”并计算位即可。

Answer 23

我们可以使用递归循环来实现这一点

    public static int digitCount(int numberInput, int i) {
        while (numberInput > 0) {
        i++;
        numberInput = numberInput / 10;
        digitCount(numberInput, i);
        }
        return i;
    }

    public static void printString() {
        int numberInput = 1234567;
        int digitCount = digitCount(numberInput, 0);

        System.out.println("Count of digit in ["+numberInput+"] is ["+digitCount+"]");
    }

Answer 24

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

Answer 25

计算 int 变量中位数的有效方法之一是定义一个带有所需数量的条件语句的方法 digitsCounter。
方法很简单，我们将检查可以包含 n 位数字的每个范围：
0 : 9 是单位数字
10 : 99 是双数字
100 : 999 是三位数 等等...

    static int digitsCounter(int N)
    {   // N = Math.abs(N); // if `N` is -ve
        if (0 <= N && N <= 9) return 1;
        if (10 <= N && N <= 99) return 2;
        if (100 <= N && N <= 999) return 3;
        if (1000 <= N && N <= 9999) return 4;
        if (10000 <= N && N <= 99999) return 5;
        if (100000 <= N && N <= 999999) return 6;
        if (1000000 <= N && N <= 9999999) return 7;
        if (10000000 <= N && N <= 99999999) return 8;
        if (100000000 <= N && N <= 999999999) return 9;
        return 10;
    }

---

更简洁的方法是删除对下限的检查，因为如果我们按顺序进行。

    static int digitsCounter(int N)
    {
        N = N < 0 ? -N : N;
        if (N <= 9) return 1;
        if (N <= 99) return 2;
        if (N <= 999) return 3;
        if (N <= 9999) return 4;
        if (N <= 99999) return 5;
        if (N <= 999999) return 6;
        if (N <= 9999999) return 7;
        if (N <= 99999999) return 8;
        if (N <= 999999999) return 9;
        return 10; // Max possible digits in an 'int'
    }

Answer 26

理想情况下，只要整数不为零，整数除以 10 多次就会返回位数。因此可以创建一个简单的方法，如下所示。

public static int getNumberOfDigits(int number) {
    int numberOfDigits = 0;                
    while(number != 0) {
        number /= 10;
        numberOfDigits++;
    }
    
    return numberOfDigits;
}

Answer 27

这取决于你所说的“整洁”是什么意思。我认为下面的代码相当简洁，而且运行速度很快。

它基于 玛丽安 答案，扩展为可处理所有 long 值并使用 ? 进行渲染。 : 运算符。

private static long[] DIGITS = { 1l,
                                 10l,
                                 100l,
                                 1000l,
                                 10000l,
                                 100000l,
                                 1000000l,
                                 10000000l,
                                 100000000l,
                                 1000000000l,
                                 10000000000l,
                                 100000000000l,
                                 1000000000000l,
                                 10000000000000l,
                                 100000000000000l,
                                 1000000000000000l,
                                 10000000000000000l,
                                 100000000000000000l,
                                 1000000000000000000l };

public static int numberOfDigits(final long n)
{
    return n == Long.MIN_VALUE ? 19 : n < 0l ? numberOfDigits(-n) :
            n < DIGITS[8] ? // 1-8
              n < DIGITS[4] ? // 1-4
                n < DIGITS[2] ? // 1-2
                  n < DIGITS[1] ? 1 : 2 : // 1-2
                        n < DIGITS[3] ? 3 : 4 : // 3-4
                      n < DIGITS[6] ? // 5-8
                        n < DIGITS[5] ? 5 : 6 : // 5-6
                      n < DIGITS[7] ? 7 : 8 : // 7-8
            n < DIGITS[16] ? // 9-16
              n < DIGITS[12] ? // 9-12
                n < DIGITS[10] ? // 9-10
                  n < DIGITS[9] ? 9 : 10 : // 9-10
                        n < DIGITS[11] ? 11 : 12 : // 11-12
                      n < DIGITS[14] ? // 13-16
                        n < DIGITS[13] ? 13 : 14 : // 13-14
                      n < DIGITS[15] ? 15 : 16 : // 15-16
            n < DIGITS[17] ? 17 :  // 17-19
            n < DIGITS[18] ? 18 :
            19;
}

Answer 28

以下是 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 可以比整数更快地进行整数比较
乘法。但差异可能很小，无法测量。

无论如何，我希望这个方法已经在 J​​DK 中公开，这样人们就不会开始滚动自己的方法。

Answer 29

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

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;
}