100的阶乘的0？

有趣的疑问

img

超出数据类型取值范围 会输出什么数字：

数据类型：int

取值范围：-2^31–2^31-1

测试1：

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
public class test {
	public static void main(String[] args) {
		int  i3 = 1;
		for (int i=1;i<34;i++){
			i3=i3*2;
			System.out.println(i3);
		}	
	}
}

输出结果：
2
4
8
16
32
64
128
256
512
1024
2048
4096
8192
16384
32768
65536
131072
262144
524288
1048576
2097152
4194304
8388608
16777216
33554432
67108864
134217728
268435456
536870912
1073741824
-2147483648
0
0

为了更详细的看出其变化，将在临界值前后输出更多值，测试2：

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
public class test {
	public static void main(String[] args) {
		int i3=1;
		for (int i=1;i<31;i++){
			i3=i3*2;
		}
 
		int k=0;
		for(int j=(i3-3)*2;k<15;j++,k++){
			System.out.println(j);			
		}
	}
}
测试结果

2147483642
2147483643
2147483644
2147483645
2147483646
2147483647
-2147483648
-2147483647
-2147483646
-2147483645
-2147483644
-2147483643
-2147483642
-2147483641
-2147483640

分析：当前int型数据达到最大值2147483647时，是第一位为0，其余31位为全1，01111111111111111111111111111111；再加1则进1，第一位为1，其余全零，10000000000000000000000000000000。系统把第一位判断为负号，而且同时代表值，所以是-2147483648，当再继续相加时，系统会把之前的数当做负数，再加上正数1，则为-2147483647，10000000000000000000000000000001，后面以此类推。结合测试1，当为10000000000000000000000000000000时，即-2147483648，再乘以2将溢出，溢出位娶不到，全0，即为00000000000000000000000000000000，此时为0（-2147483648再乘以2为什么是0的理解） . 再乘以2依然为0.

为了解决这样大数的问题 引入了BigInteger 和 BigDecimal

BigInteger

在Java中，由CPU原生提供的整型最大范围是64位long型整数。使用long型整数可以直接通过CPU指令进行计算，速度非常快。

如果我们使用的整数范围超过了long型怎么办？这个时候，就只能用软件来模拟一个大整数。java.math.BigInteger就是用来表示任意大小的整数。BigInteger内部用一个int[]数组来模拟一个非常大的整数：

1
2
BigInteger bi = new BigInteger("1234567890");
System.out.println(bi.pow(5)); // 2867971860299718107233761438093672048294900000

对BigInteger做运算的时候，只能使用实例方法，例如，加法运算：

1
2
3
BigInteger i1 = new BigInteger("1234567890");
BigInteger i2 = new BigInteger("12345678901234567890");
BigInteger sum = i1.add(i2); // 12345678902469135780

和long型整数运算比，BigInteger不会有范围限制，但缺点是速度比较慢。

也可以把BigInteger转换成long型：

1
2
3
BigInteger i = new BigInteger("123456789000");
System.out.println(i.longValue()); // 123456789000
System.out.println(i.multiply(i).longValueExact()); // java.lang.ArithmeticException: BigInteger out of long range

使用longValueExact()方法时，如果超出了long型的范围，会抛出ArithmeticException。

BigInteger和Integer、Long一样，也是不可变类，并且也继承自Number类。因为Number定义了转换为基本类型的几个方法：

  • 转换为byte：byteValue()
  • 转换为short：shortValue()
  • 转换为int：intValue()
  • 转换为long：longValue()
  • 转换为float：floatValue()
  • 转换为double：doubleValue()

因此，通过上述方法，可以把BigInteger转换成基本类型。如果BigInteger表示的范围超过了基本类型的范围，转换时将丢失高位信息，即结果不一定是准确的。如果需要准确地转换成基本类型，可以使用intValueExact()、longValueExact()等方法，在转换时如果超出范围，将直接抛出ArithmeticException异常。

BigDecimal

和BigInteger类似，BigDecimal可以表示一个任意大小且精度完全准确的浮点数。

1
2
BigDecimal bd = new BigDecimal("123.4567");
System.out.println(bd.multiply(bd)); // 15241.55677489

BigDecimal用scale()表示小数位数，例如：

1
2
3
4
5
6
BigDecimal d1 = new BigDecimal("123.45");
BigDecimal d2 = new BigDecimal("123.4500");
BigDecimal d3 = new BigDecimal("1234500");
System.out.println(d1.scale()); // 2,两位小数
System.out.println(d2.scale()); // 4
System.out.println(d3.scale()); // 0

通过BigDecimal的stripTrailingZeros()方法，可以将一个BigDecimal格式化为一个相等的，但去掉了末尾0的BigDecimal：

1
2
3
4
5
6
7
8
9
BigDecimal d1 = new BigDecimal("123.4500");
BigDecimal d2 = d1.stripTrailingZeros();
System.out.println(d1.scale()); // 4
System.out.println(d2.scale()); // 2,因为去掉了00

BigDecimal d3 = new BigDecimal("1234500");
BigDecimal d4 = d3.stripTrailingZeros();
System.out.println(d3.scale()); // 0
System.out.println(d4.scale()); // -2

如果一个BigDecimal的scale()返回负数，例如，-2，表示这个数是个整数，并且末尾有2个0。

可以对一个BigDecimal设置它的scale，如果精度比原始值低，那么按照指定的方法进行四舍五入或者直接截断：

对BigDecimal做加、减、乘时，精度不会丢失，但是做除法时，存在无法除尽的情况，这时，就必须指定精度以及如何进行截断：

1
2
3
4
BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("23.456789");
BigDecimal d3 = d1.divide(d2, 10, RoundingMode.HALF_UP); // 保留10位小数并四舍五入
BigDecimal d4 = d1.divide(d2); // 报错：ArithmeticException，因为除不尽

调用divideAndRemainder()方法时，返回的数组包含两个BigDecimal，分别是商和余数，其中商总是整数，余数不会大于除数。我们可以利用这个方法判断两个BigDecimal是否是整数倍数：

1
2
3
4
5
6
BigDecimal n = new BigDecimal("12.75");
BigDecimal m = new BigDecimal("0.15");
BigDecimal[] dr = n.divideAndRemainder(m);
if (dr[1].signum() == 0) {
    // n是m的整数倍
}

比较BigDecimal

在比较两个BigDecimal的值是否相等时，要特别注意，使用equals()方法不但要求两个BigDecimal的值相等，还要求它们的scale()相等：

1
2
3
4
5
BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("123.45600");
System.out.println(d1.equals(d2)); // false,因为scale不同
System.out.println(d1.equals(d2.stripTrailingZeros())); // true,因为d2去除尾部0后scale变为2
System.out.println(d1.compareTo(d2)); // 0

必须使用compareTo()方法来比较，它根据两个值的大小分别返回负数、正数和0，分别表示小于、大于和等于。

总是使用compareTo()比较两个BigDecimal的值，不要使用equals()！

如果查看BigDecimal的源码，可以发现，实际上一个BigDecimal是通过一个BigInteger和一个scale来表示的，即BigInteger表示一个完整的整数，而scale表示小数位数：

1
2
3
4
public class BigDecimal extends Number implements Comparable<BigDecimal> {
    private final BigInteger intVal;
    private final int scale;
}

BigDecimal也是从Number继承的，也是不可变对象。

100的阶乘实现

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
import java.math.BigDecimal;
import java.math.BigInteger;

public class JieCheng {

    public static void main(String[] args) {
        //调用方法int
        jichengint();

        //调用方法biginteger
        jiechengbiginteger();
        
        //调用方法bigdecimal
        jiechengbigdecimal();
    }

    public static void jichengint() {
        int result = 1;
        for (int i = 1; i <= 100; i++) {
            result *= i;
        }
        System.out.println("阶乘Int:  "+result);
    }


    public static void jiechengbiginteger() {
        BigInteger result = new BigInteger("1");//为result赋初始值，为1
        for (int i = 1; i <= 100; i++) {
            BigInteger num = new BigInteger(String.valueOf(i));
            result = result.multiply(num);//调用自乘方法
        }
        System.out.println("阶乘BigInTeger  "+result);//输出结果
        System.out.println("位数： "+String.valueOf(result).length());//输出长度
    }

    public static void jiechengbigdecimal(){
        //求一百的阶乘之和
        //只能用math里边的BigDecimal来存储数据
        //定义变量保存阶乘的和
        BigDecimal result = new BigDecimal("1");//为result赋初始值，为1
        for (int i = 1; i <= 100; i++) {
            BigDecimal num = new BigDecimal(String.valueOf(i));
            result = result.multiply(num);//调用自乘方法
        }
        System.out.println("阶乘BigDecimal  "+result);//输出结果
        System.out.println("位数： "+String.valueOf(result).length());//输出长度
    }

}

输出结果：
阶乘Int:  0
    
阶乘BigInTeger 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
位数： 158
    
阶乘BigDecimal  93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
位数： 158