蓝桥杯JAVA-6.大数（整数、小数）处理

本文最后更新于：December 14, 2021 pm

积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里，不积小流无以成江海。齐骥一跃，不能十步，驽马十驾，功不在舍。面对悬崖峭壁，一百年也看不出一条裂缝来，但用斧凿，能进一寸进一寸，能进一尺进一尺，不断积累，飞跃必来，突破随之。

目录

0.BigInteger构造器

这里就演示最后两种的构造器用法：

1
2
3
4
5
6
7
8
String s = Scin.next(); //1561561561
BigInteger bs = new BigInteger(s);
System.out.println(bs); //1561561561


String s = Scin.next(); //10000
BigInteger bs = new BigInteger(s,2); //将字符串数字当成2进制
System.out.println(bs); //16

1.BigInteger类常用方法

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
BigInteger abs()  返回大整数的绝对值
BigInteger add(BigInteger val) 返回两个大整数的和
BigInteger and(BigInteger val)  返回两个大整数的按位与的结果
BigInteger andNot(BigInteger val) 返回两个大整数与非的结果
BigInteger divide(BigInteger val)  返回两个大整数的商
double doubleValue()   返回大整数的double类型的值
float floatValue()   返回大整数的float类型的值
BigInteger gcd(BigInteger val)  返回大整数的最大公约数
int intValue() 返回大整数的整型值
long longValue() 返回大整数的long型值
BigInteger max(BigInteger val) 返回两个大整数的最大者
BigInteger min(BigInteger val) 返回两个大整数的最小者
BigInteger mod(BigInteger val) 用当前大整数对val求模
BigInteger multiply(BigInteger val) 返回两个大整数的积
BigInteger negate() 返回当前大整数的相反数
BigInteger not() 返回当前大整数的非
BigInteger or(BigInteger val) 返回两个大整数的按位或
BigInteger pow(int exponent) 返回当前大整数的exponent次方
BigInteger remainder(BigInteger val) 返回当前大整数除以val的余数
BigInteger shiftLeft(int n) 将当前大整数左移n位后返回
BigInteger shiftRight(int n) 将当前大整数右移n位后返回
BigInteger subtract(BigInteger val)返回两个大整数相减的结果
byte[] toByteArray(BigInteger val)将大整数转换成二进制反码保存在byte数组中
String toString() 将当前大整数转换成十进制的字符串形式
BigInteger xor(BigInteger val) 返回两个大整数的异或

1.1 求绝对值abs()的使用

1
2
3
4
5
String s = "-23423432";
BigInteger bs = new BigInteger(s);
System.out.println(bs); //-23423432
BigInteger ba = bs.abs();
System.out.println(ba); //23423432

1.2 两数相加add()的使用

1
2
3
4
5
6
String s = "-23423432";
String ss = "23423433";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger sad = bs.add(bss);
System.out.println(sad); //1

1.3 两数相减subtract()的使用

1
2
3
4
5
6
String s = "23423432";
String ss = "23423433";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger sad = bss.subtract(bs); //bss-bs
System.out.println(sad); //1

1.4 两数相乘multiply()的使用

1
2
3
4
5
6
String s = "2";
String ss = "3";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger sad = bss.multiply(bs);
System.out.println(sad);

1.5 两数相除divide()的使用（商）

1
2
3
4
5
6
String s = "3";
String ss = "7";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger sad = bss.divide(bs); // bss/bs
System.out.println(sad); //2

1.6 求相反数negate()的使用

1
2
3
4
5
6
7
8
String s = "-3";
String ss = "7";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger nebs = bs.negate();
BigInteger nebss = bss.negate();
System.out.println(nebs); // 3
System.out.println(nebss); // -7

1.7 求余数remainder()的使用

📢注意在小数中的使用！与mod()对照。

1
2
3
4
5
6
String s = "3";
String ss = "7";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger nebs = bss.remainder(bs); // bss%bs
System.out.println(nebs); // 1

1.8 求模mod()的使用

📢注意在小数中不能使用！与remainder()对照。

1
2
3
4
5
6
String s = "3";
String ss = "7";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger nebs = bss.mod(bs);
System.out.println(nebs); //1

1.9 求幂次方pow()的使用

1
2
3
4
5
String s = "2";
int p = 4;
BigInteger bs = new BigInteger(s);
BigInteger nebs = bs.pow(p);
System.out.println(nebs);

1.10 返回大整数的double值doubleValue()的使用

📢注意：当数字长度超过了7位，会自动采用科学计数法输出！！！

1
2
3
4
String s = "2234231";
BigInteger bs = new BigInteger(s);
double ne= bs.doubleValue();
System.out.println(ne); //2234231.0

1.11 返回大整数的float值floatValue()的使用

1
2
3
4
String s = "2234231";
BigInteger bs = new BigInteger(s);
float ne= bs.floatValue();
System.out.println(ne); //2234231.0

1.12 返回大整数的int值intValue()的使用

1
2
3
4
String s = "223423321";
BigInteger bs = new BigInteger(s);
int ne= bs.intValue();
System.out.println(ne); //223423321

1.13 返回大整数的long值longValue()的使用

1
2
3
4
String s = "2234233214522333332";
BigInteger bs = new BigInteger(s);
long ne= bs.longValue();
System.out.println(ne); //2234233214522333332

1.14 两数中的最大值max()的使用

1
2
3
4
5
6
String s = "2234232";
String ss = "2342342343";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger ne= bss.max(bs);
System.out.println(ne); //2342342343

1.15 两数中的最小值min()的使用

1
2
3
4
5
6
String s = "2234232";
String ss = "2342342343";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger ne= bss.min(bs);
System.out.println(ne); //2234232

1.16 求两数的最大公约数gcd()的使用

1
2
3
4
5
6
String s = "2234232";
String ss = "2342342343";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger ne= bss.gcd(bs);
System.out.println(ne); // 33

1.17 两个数的按位与and()的使用

1
2
3
4
5
6
String s = "23";
String ss = "7";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger ne= bss.and(bs);
System.out.println(ne); //7

1.18 两个数的按位或or()的使用

1
2
3
4
5
6
String s = "23";
String ss = "7";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger ne= bss.or(bs);
System.out.println(ne); // 23

1.19 当前数的非not()的使用

1
2
3
4
String ss = "7";
BigInteger bss = new BigInteger(ss);
BigInteger ne= bss.not();
System.out.println(ne); // -8

1.20 两个数与非andNot()的使用

1
2
3
4
5
6
String s = "3";
String ss = "7";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger ne= bss.andNot(bs);
System.out.println(ne); // 4

1.21 两个数的异或

1
2
3
4
5
6
String s = "2";
String ss = "7";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger ne= bss.xor(bs);
System.out.println(ne); // 5

1.22 将当前数左移n位shiftLeft()的使用

1
2
3
4
String s = "2";
BigInteger bs = new BigInteger(s);
BigInteger ne= bs.shiftLeft(3);
System.out.println(ne); // 16

1.23 将当前数右移n位后shiftRight()的使用

1
2
3
4
String s = "64";
BigInteger bs = new BigInteger(s);
BigInteger ne= bs.shiftRight(3);
System.out.println(ne); // 8

2.BigInteger进制转换

2.1 十进制转其他进制

1
2
3
4
5
6
7
8
9
10
11
12
13
String string1 = new BigInteger("20", 10).toString(2);
System.out.println("十进制的20转换成二进制是："+string1);

String string2 = new BigInteger("20", 10).toString(8);
System.out.println("十进制的20转换成八进制是："+string2);

String string3 = new BigInteger("20", 10).toString(16);
System.out.println("十进制的20转换成十六进制是："+string3);

//out
十进制的20转换成二进制是：10100
十进制的20转换成八进制是：24
十进制的20转换成十六进制是：14

2.2 其他进制转十进制

1
2
3
4
5
6
7
8
9
10
11
12
13
String string4 = new BigInteger("110", 2).toString(10);
System.out.println("二进制的110转换成十进制是："+string4);

String string5 = new BigInteger("110", 8).toString(10);
System.out.println("八进制的110转换成十进制是："+string5);

String string6 = new BigInteger("110", 16).toString(10);
System.out.println("十六进制的110转换成十进制是："+string6);

//out
二进制的110转换成十进制是：6
八进制的110转换成十进制是：72
十六进制的110转换成十进制是：272

3.小数（BigDecimal类）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Scanner cin = new Scanner(System.in);
BigDecimal a,b;
a = cin.nextBigDecimal();
b = cin.nextBigDecimal();
System.out.println(a.add(b)); //加
System.out.println(a.subtract(b)); //减
System.out.println(a.multiply(b)); //乘
System.out.println(a.divide(b)); //除
System.out.println(a.remainder(b)); //求余
// a=7.3 b=3.2
10.5
4.1
23.36
2.28125
0.9

2.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
Scanner cin = new Scanner(System.in);
BigDecimal big ;
big = cin.nextBigDecimal();
System.out.println(big.scale()); //scale() 获取小数位数；若是整数则为负数，表示的末尾的0个数
System.out.println(big);
big = big.stripTrailingZeros(); // 去掉小数末尾的无用0
System.out.println(big.scale());
System.out.println(big);



//控制台
123.4500000

7
123.4500000
2
123.45

//控制台
12340000
0
12340000
-4
1.234E+7
  1. 对一个BigDecimal设置它的scale，如果精度比原始值低，那么按照指定的方法进行四舍五入或者直接截断。
1
2
3
4
5
6
7
8
import java.math.BigDecimal;
import java.math.RoundingMode;

BigDecimal d1 = new BigDecimal("123.456789");
BigDecimal d2 = d1.setScale(4, RoundingMode.HALF_UP); // 四舍五入
BigDecimal d3 = d1.setScale(4, RoundingMode.DOWN); // 直接截断
System.out.println(d2); //123.4568
System.out.println(d3); //123.4567

对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，因为除不尽

对BigDecimal做除法的同时求余数。调用divideAndRemainder()方法时，返回的数组包含两个BigDecimal，分别是商和余数，其中商总是整数，余数不会大于除数。

1
2
3
4
5
BigDecimal n = new BigDecimal("12.345");
BigDecimal m = new BigDecimal("0.12");
BigDecimal[] dr = n.divideAndRemainder(m);
System.out.println(dr[0]); // 102
System.out.println(dr[1]); // 0.105

2.2 比较BigDecimal

在比较两个BigDecimal的值是否相等时，要特别注意，使用equals()方法不但要求两个BigDecimal的值相等，还要求它们的scale()相等。
必须使用compareTo()方法来比较，它根据两个值的大小分别返回负数、正数和0，分别表示小于、大于和等于。总是使用compareTo()比较两个BigDecimal的值，不使用equals()。

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