常用Java API：大数类

摘要

java中的基础数据类型能存储的最大的二进制数是 2 ^ 63 - 1,

对应的十进制数是9223372036854775807，也就是说只要运算过程中会超过这个数，就会造成数据溢出，从而造成错误.

1. 而java.math.*包中提供了大数类，其理论上可以存储无限位的大数，只要内存足够的话。
2. 大数类又分为整数和浮点数.即BigInteger and BigDecimal
3. 大数类的对象不能直接进行运算，需要调用类中相应的方法,并且方法的参数必须和调用的类相同,BigInteger不能调用BigDecimal, 不能作为其方法参数, 即整数和浮点数不能混合运算.

BigInteger 和 BigDecimal

创建

1.直接声明
BigInteger a;
BigDecimal b;
2.使用构造函数初始化
BigInteger a = new BigInteger("123456789101112131415");
BigDecimal b = new BigDecimal("123456.123456");

赋值

1. BigInteger.valueOf(long val);
   
   BigDecimal.valueOf(double val);

   BigInteger a;
   BigDecimal b;
   注意 val 不能超过 long 类型的最大取值9223372036854775807, 超过int时要在数后面加L如:
   a = BigInteger.valueOf(123456789101112L); //大于int范围的要加L
   b = BigDecimal.valueOf(123456.12341235); // 超出的小数位数会自动舍弃
   

2. 使用 = 将同类型变量的值赋给另一个变量

   BigInteger a;
   BigInteger b = new BigInteger("123456");
   a = b;
   System.out.print(a);
   
   输出:
   123456
   

加法

BigInteger.add(BigInteger);

BigDecimal.add(BigDecimal);

BigInteger a, b, c;
a = BigInteger.valueOf(123456789); // 赋值为 123456789
b = BigInteger.valueOf(987654321); // 赋值为 987654321
c = a.add(b);
System.out.print(c);
输出：
1111111110
1111111110

---

减法

BigInteger.subtract(BigInteger);

BigDecimal.sbutract(BigDecimal);

BigInteger a, b, c;
a = BigInteger.valueOf(123456789); // 赋值为 123456789
b = BigInteger.valueOf(987654321); // 赋值为 987654321
c = a.subtract(b);
System.out.print(c);

输出：
-864197532

---

乘法

BigInteger.multiply(BigInteger);

BigDecimal.multiply(BigDecimal);

BigInteger a, b, c;
a = BigInteger.valueOf(123456789); // 赋值为 123456789
b = BigInteger.valueOf(987654321); // 赋值为 987654321
c = a.multiply(b);
System.out.print(c);

输出：
121932631112635269

---

除法

BigInteger.divide(BigInteger);

BigDecimal.divide(BigDecimal);

BigInteger a, b, c;
a = BigInteger.valueOf(987654321); // 赋值为 987654321
b = BigInteger.valueOf(123456789); // 赋值为 123456789
c = a.divide(b); // 整数相除仍为整数
System.out.print(c);

输出：
8

---

*取余

BigInteger.mod(BigInteger);

BigInteger a, b, c;
a = BigInteger.valueOf(987654321); // 赋值为 987654321
b = BigInteger.valueOf(123456789); // 赋值为 123456789
c = a.mod(b);
System.out.print(c);

输出：
9

*求最大公因数

BigInteger.gcd(BigInteger);

BigInteger a, b, c;
a = BigInteger.valueOf(987654321); // 赋值为 987654321
b = BigInteger.valueOf(123456789); // 赋值为 123456789
c = a.gcd(b);
System.out.print(c);

输出：
9

---

求最值

BigInteger.max(BigInteger) , BigDecimal.max(BigDecimal) 最大值

BigInteger.min(BigInteger) , BigDecimal.min(BigDecimal) 最小值

BigInteger a, b, c, d;
a = BigInteger.valueOf(987654321); // 赋值为 987654321
b = BigInteger.valueOf(123456789); // 赋值为 123456789
c = a.max(b); //a,b中的最大值
d = a.min(b); //a,b中的最小值
System.out.println(c);
System.out.println(d);

输出：
987654321
123456789

---

*(a^b)%mod

BigInteger.modPow(BigInteger, BigInteger);

BigInteger a, b, c, mod;
a = BigInteger.valueOf(987654321); // 赋值为 987654321
b = BigInteger.valueOf(123456789); // 赋值为 123456789
mod = BigInteger.valueOf(10007);
c = a.modPow(b, mod); //(a^b)%mod
System.out.println(c);
输出：
718

---

比较大小

BigInteger.compareTo(BigInteger);

BigDecimal.compareTo(BigDecimal);

BigInteger a, b;
int c;
a = BigInteger.valueOf(987654321); // 赋值为 987654321
b = BigInteger.valueOf(123456789); // 赋值为 123456789
c = a.compareTo(b);  // a 和 b
System.out.println(c);
c = b.compareTo(b);  // b 和 b
System.out.println(c);
c = b.compareTo(a);   // c 和 c
System.out.println(c);
输出：
1
0
-1
1234567891011121314
可见, 对于a.compareTo(b), a和b进行比较如果:
a > b  返回 1
a == b 返回 0
a < b  返回-1

---

*进制转化

使用构造函数BigInteger(String, int index);可以把一个index进制的字符串,转化为10进制的BigInteger;

BigInteger a = new BigInteger("111110", 2);把二进制数111110变为十进制赋值给a
System.out.println(a.toString(16));把a转化为十六进制的字符串输出

---

类型转化

BigInteger.toBigDecimal() //把BigInteger 转化为 BigDecimal

BigDecimal.toBigInteger() //把BigDecimal 转化为 BigInteger

	BigInteger a = new BigInteger(1);
	BigDecimal b = new BigDecimal(2);
	b.toBigInteger(); // 把BigDecimal转为BigInteger
	a.toBigDecimal(); // 把BigInteger转为BigDecimal
1234

---

-BigDecimal的精度问题

BigDecimal的舍入模式

想象一个数轴,从负无穷到正无穷,向哪舍入,就是趋向于哪, 向0就是舍入后要更趋近于0.

ROUND_DOWN 向零舍入。 即1.55 变为 1.5 , -1.55 变为-1.5

ROUND_CEILING 向正无穷舍入. 即 1.55 变为 1.6 , -1.55 变为 -1.5

ROUND_FLOOR 向负无穷舍入. 即 1.55 变为 1.5 , -1.55 变为 -1.6

ROUND_HALF_UP 四舍五入 即1.55 变为1.6, -1.55变为-1.6

ROUND_HALF_DOWN 五舍六入 即 1.55 变为 1.5, -1.5变为-1.5

ROUND_HALF_EVEN 如果舍入前一位的数字为偶数，则采用HALF_DOWN奇数则采用HALF_UP 如1.55 采用HALF_UP 1.45采用HALF_DOWN

ROUND_UP 向远离0的方向舍入 即 1.55 变为 1.6 , -1.55 变为-1.6

ROUND_UNNECESSARY 有精确的位数时，不需要舍入

在需要精确舍入的方式时可以使用以上的舍入模式。

(另:Math 类的 ceil（）和 floor方法对应普通浮点型的上取整和下取整.)

BigDecimal进行加减乘除时可以进行舍入

如 除法

divide(BigDecimal divisor, int scale, RoundingMode roundingMode) 返回一个

BigDecimal ，其值为 (this / divisor) ，其小数位数为scale。

import java.math.*;
import java.util.*;
import java.io.*;
public class Main{
    public static void main(String[] args){
    	BigDecimal a, b, c;
    	a = BigDecimal.valueOf(1.51);
    	b = BigDecimal.valueOf(1.37);
    	c = a.divide(b,100,BigDecimal.ROUND_DOWN);//采用向0舍入并并保留100位小数
    	System.out.println(c);
    }
}
输出：
1.1021897810218978102189781021897810218978102189781021897810218978102189781021897810218978102189781021

保留n位小数

setScale(int newScale, RoundingMode roundingMode);

import java.math.*;
import java.util.*;
import java.io.*;
public class Main{
    public static void main(String[] args){
    	BigDecimal a = new BigDecimal("1.10218");
    	a = a.setScale(4,BigDecimal.ROUND_HALF_UP);//四舍五入保留四位小数
    	System.out.println(a);
    }
}