Java-算法竞赛中常用的Java API之大数类

摘要

java中的基础数据类型能存储的最大的二进制数是 2 ^ 63 - 1,
对应的十进制数是9223372036854775807，也就是说只要运算过程中会超过这个数，就会造成数据溢出，从而造成错误.

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

BigInteger和BigDecimal

创建

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

赋值

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); // 超出的小数位数会自动舍弃 

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

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

可见, 对于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变为10进制赋值给a
System.out.println(a.toString(16));把a转化为16进制的字符串输出

类型转化

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

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