关于java：获取int中的位数的方法？

Way to get number of digits in an int?

有没有比这个方法更整洁的方法来获取int的长度？

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

相关讨论

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

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

相关讨论

对数是你的朋友：

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

注：仅适用于n>0。

相关讨论

最快的方法：分而治之。

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

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

代码(长但快)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

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

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

基线方法(带string.length)：2145MS

log10方法：711ms=3.02次比基线快

重复除法：2797ms=0.77次比基线快

分而治之：74ms=28.99比基线快几倍

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

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 faster than baseline");

c = new Chronometer(true);
allMethod3();
c.stop();
System.out.println(c +" =" + StringTools.formatDouble((double)baseline / c.getValue() ,"0.00") +" times faster than baseline");

c = new Chronometer(true);
allMethod4();
c.stop();
System.out.println(c +" =" + StringTools.formatDouble((double)baseline / c.getValue() ,"0.00") +" times faster than 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;
}

号

同样，基准：

基线方法(带string.length)：2145MS

log10方法：711ms=3.02次比基线快

重复除法：2797ms=0.77次比基线快

分而治之：74ms=28.99比基线快几倍

编辑：在我写了基准之后，我从Java 6中偷偷地进入了整数。ToStand，我发现它使用：

1
2
3
4
5
6
7
8
9

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

我把它与我的分而治之的解决方案作了比较：

分而治之：104ms

Java 6解决方案——迭代与比较：406MS

我的大约快4倍。

相关讨论

关于你的基准的两个评论：Java是一个复杂的环境，什么是及时编译和垃圾收集等等，所以为了得到公平的比较，每当我运行一个基准时，我总是：(a)将两个测试包围在一个循环中，这些循环以5或10次顺序运行它们。通常，第二次循环传递的运行时与第一次循环有很大的不同。(b)在每个"方法"之后，我都会执行system.gc()来尝试触发垃圾收集。否则，第一种方法可能会生成一堆对象，但不足以强制进行垃圾收集，然后第二种方法创建一些对象，堆耗尽，垃圾收集运行。然后，第二种方法被"充电"以拾起第一种方法留下的垃圾。非常不公平！

也就是说，在这个例子中，上述两个都没有显著的区别。

不管有没有这些修改，我得到的结果与你完全不同。当我运行这个时，是的，ToString方法给出了6400到6600毫秒的运行时间，而Log方法给出了20000到20400毫秒的运行时间。对于我来说，日志方法不是稍微快一点，而是慢三倍。

请注意，这两种方法涉及的成本非常不同，因此这并不完全令人震惊：ToString方法将创建许多必须清理的临时对象，而Log方法需要更高的计算强度。因此，区别可能在于，在内存较少的计算机上，ToString需要更多的垃圾收集循环，而在处理器速度较慢的计算机上，额外的日志计算将更加痛苦。

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

1
2
3
4
5
6
7
8
9

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。

如果您有一个广泛的数字范围，您可以通过开始除以1000或1000000来进一步加快速度，从而减少通过循环的次数。我没玩过。

相关讨论

使用Java

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

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

使用C

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

。

一开始使用inclue math.h。

相关讨论

由于整数以10为底的位数仅为1+截断(log10(number))，因此可以执行以下操作：

1
2
3
4
5
6
7
8
9
10

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

号

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

相关讨论

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

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

1
2
3
4
5
6
7

long n = 99999999999999999L;

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

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

。

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

相关讨论

Marian的解决方案适用于长类型数字(最多9223372036854775807)，以防有人想要复制和粘贴它。在这个程序中，我为多达10000个数字编写的这个更可能，所以我为它们做了一个特定的分支。无论如何，这不会有什么显著的区别。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

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

。

相关讨论

我能试试吗？；)

基于Dirk的解决方案

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

简单的旧数学怎么样？除以10直到0。

1
2
3
4
5
6
7
8

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

相关讨论

玛丽安的溶液，现在是三元：

1
2
3

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

因为我们可以。

相关讨论

另一个字符串方法。短而甜-适用于任何整数n。

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

好奇的是，我试着把它作为基准…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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

}
}

。

结果是：

1
2
3
4

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

现在我想知道我的基准测试是否真的有意义，但是我确实在基准测试的多次运行中得到了一致的结果(毫秒内的变化)。：)尝试优化这一点似乎毫无用处…

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

。

相关讨论

这个递归方法怎么样？

1
2
3
4
5
6
7
8
9
10
11

private static int length = 0;

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

。

简单解决方案：

1
2
3
4
5
6
7
8
9

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

。

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

1
2
3
4

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

号

相关讨论

与设计(基于问题)。这是分而治之的交替。我们首先定义一个枚举(考虑到它只针对无符号int)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

号

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

1
2
3
4
5
6
7
8
9
10

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

号

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

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

号

}

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
* 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…因为最小值是9，90，900…n减去9，90，900…

不幸的是，由于溢出，仅通过替换int的每个实例，它不能移植到long。另一方面，它同样适用于2垒和10垒(但其他大多数垒都严重失败)。您需要一个溢出点的查找表(或一个除法测试…电子战)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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

号

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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+"]");
}

。

人们之所以想这样做，主要是因为他/她想"呈现"它，这意味着它最终需要"以另一种方式"显式或隐式地"扭曲"(或以另一种方式转换)，然后才能呈现(例如打印)。

如果是这种情况，那么只需尝试使必要的"to字符串"显式并计算位。

1
2
3
4
5
6
7
8

int num = 02300;
int count = 0;
while(num>0){
if(num == 0) break;
num=num/10;
count++;
}
System.out.println(count);

号

相关讨论

简单的递归方式

1
2
3
4
5
6

int get_int_lenght(current_lenght, value)
{
if (value / 10 < 10)
return (current_lenght + 1);
return (get_int_lenght(current_lenght + 1, value))
}

未试验过

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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位空格。因此，如果你有int number = 103342;，你会得到6个，因为这相当于0.000001个空格。另外，是否有人对numberCounter有更好的变量名？我想不出比这更好的了。

编辑：只是想一个更好的解释。实际上，这个while循环所做的就是让它，所以你把你的数字除以10，直到它小于1。本质上，当你把某个数除以10时，你会把它移回一个数字空间，所以你只需要简单地把它除以10，直到你的数字的位数小于1。

下面是另一个可以用十进制计算数字的版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

。

你可以用连续十除的数字：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int a=0;

if (no < 0) {
no = -no;
} else if (no == 0) {
no = 1;
}

while (no > 0) {
no = no / 10;
a++;
}

System.out.println("Number of digits in given number is:"+a);

相关讨论

输入数字并创建一个Arraylist，while循环将所有数字记录到Arraylist中。然后我们可以取出数组的大小，即您输入的整数值的长度。

1
2
3
4
5
6
7
8
9
10

ArrayList<Integer> a=new ArrayList<>();

while(number > 0)
{
remainder = num % 10;
a.add(remainder);
number = number / 10;
}

int m=a.size();

。

相关讨论

尝试将int转换为字符串，然后获取字符串的长度。这应该得到int的长度。

1
2
3
4
5

public static int intLength(int num){
String n = Integer.toString(num);
int newNum = n.length();
return newNum;
}

。

相关讨论