Java中BigInteger的方法详解，实战最全！

IT无知君
1,815 阅读4分钟

前言

在 Java 中，有许多数字处理的类，比如 Integer类，但是Integer类有一定的局限性。 

我们都知道 Integer 是 Int 的包装类，int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类。 

BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。 

 下面，让我们一起来学习一下BigInteger的常用方法： 

正文

读入方法

nextBigInteger()：控制台读入一个BigInteger型数据，类似于int型的nextInt()；

//读入方法：nextBigInteger()
@Test
public void test5() {
    Scanner scan = new Scanner(System.in);	// 读入
    int n = scan.nextInt(); 			// 读入一个int;
    BigInteger m = scan.nextBigInteger();	// 读入一个BigInteger;
    while(scan.hasNext()){	
        System.out.print("scan.hasNext()=" + scan.hasNext());
    }
}

构造方法

默认为十进制，也是我们最常用的，同时也支持自定义进制类型（已存在的）；

//进制转换
@Test
public void testScale() {
    //在构造将函数时，把radix进制的字符串转化为BigInteger
    String str = "1011100111";
    int radix = 2;
    BigInteger interNum1 = new BigInteger(str,radix);	//743

    //我们通常不写，则是默认成10进制转换，如下：
    BigInteger interNum2 = new BigInteger(str);	        //1011100111
}

基本运算

返回值为BigInteger类型：add()，subtract()，multiply()，divide()，mod()，remainder()，pow()，abs()，negate()；

//基本运算:add(),subtract(),multiply(),divide(),mod(),remainder(),pow(),abs(),negate()
@Test
public void testBasic() {
    BigInteger a = new BigInteger("13");
    BigInteger b = new BigInteger("4");
    int n = 3;

    //1.加
    BigInteger bigNum1 = a.add(b);          //17
    //2.减
    BigInteger bigNum2 = a.subtract(b);	    //9
    //3.乘
    BigInteger bigNum3 = a.multiply(b);	    //52
    //4.除
    BigInteger bigNum4 = a.divide(b);       //3
    //5.取模(需 b > 0，否则出现异常：ArithmeticException("BigInteger: modulus not positive"))
    BigInteger bigNum5 = a.mod(b);          //1
    //6.求余
    BigInteger bigNum6 = a.remainder(b);    //1
    //7.平方(需 n >= 0，否则出现异常：ArithmeticException("Negative exponent"))
    BigInteger bigNum7 = a.pow(n);          //2197
    //8.取绝对值
    BigInteger bigNum8 = a.abs();           //13
    //9.取相反数
    BigInteger bigNum9 = a.negate();        //-13
}

比较大小

compareTo()返回一个int型数据：1 大于； 0 等于； -1 小于；
max()，min()：分别返回大的（小的）那个BigInteger数据；

//比较大小:compareTo(),max(),min()
@Test
public void testCompare() {
    BigInteger bigNum1 = new BigInteger("52");
    BigInteger bigNum2 = new BigInteger("27");

    //1.compareTo()：返回一个int型数据（1 大于； 0 等于； -1 小于）
    int num = bigNum1.compareTo(bigNum2);	        //1

    //2.max()：直接返回大的那个数，类型为BigInteger
    //	原理：return (compareTo(val) > 0 ? this : val);
    BigInteger compareMax = bigNum1.max(bigNum2);	//52

    //3.min()：直接返回小的那个数，类型为BigInteger
    //	原理：return (compareTo(val) < 0 ? this : val);
    BigInteger compareMin = bigNum1.min(bigNum2);	//27
}

常量

ZERO，ONE，TEN 返回值为BigInteger类型：有朋友提到的-1，2，源码注释里面已表明不再输出(Not exported.)；

//常量(返回BigInteger类型)
//有朋友提到的-1和2，源码注释里面已表明不再输出(Not exported.)
@Test
public void testFinalNum() {
    //0
    BigInteger zero = BigInteger.ZERO;
    //1
    BigInteger one = BigInteger.ONE;
    //10
    BigInteger ten = BigInteger.TEN;
}

类型转换

将BigInteger数据转换成基本数据类型，还可以转换成radix进制的字符串形式；

//类型转换(返回类型如下)
@Test
public void testToAnother() {
    BigInteger bigNum = new BigInteger("52");
    int radix = 2;
		
    //1.转换为bigNum的二进制补码形式
    byte[] num1 = bigNum.toByteArray();
    //2.转换为bigNum的十进制字符串形式
    String num2 = bigNum.toString();		//52
    //3.转换为bigNum的radix进制字符串形式
    String num3 = bigNum.toString(radix);	//110100
    //4.将bigNum转换为int
    int num4 = bigNum.intValue();
    //5.将bigNum转换为long
    long num5 = bigNum.longValue();
    //6.将bigNum转换为float
    float num6 = bigNum.floatValue();
    //7.将bigNum转换为double
    double num7 = bigNum.doubleValue();
}

二进制运算

返回值为BigInteger类型，此类方法不常用，有备无患；

//二进制运算(返回类型都为BigInteger，不常用，但有备无患)
@Test
public void testBinaryOperation() {
    BigInteger a = new BigInteger("13");
    BigInteger b = new BigInteger("2");
    int n = 1;

    //1.与：a&b
    BigInteger bigNum1 = a.and(b);			//0
    //2.或：a|b
    BigInteger bigNum2 = a.or(b);			//15
    //3.异或：a^b
    BigInteger bigNum3 = a.xor(b);			//15
    //4.取反：~a
    BigInteger bigNum4 = a.not();			//-14
    //5.左移n位： (a << n)
    BigInteger bigNum5 = a.shiftLeft(n);	//26
    //6.右移n位： (a >> n)
    BigInteger bigNum6 = a.shiftRight(n);	//6
}

权限控制

setBit()，testBit()：可用于菜单的权限控制，非常好用，原理如下：

//权限控制：setBit(),testBit()
@Test
public void testSetAndTest() {
    //1.封装数据(setBit的值需 >= 0，否则出现异常：ArithmeticException("Negative bit address"))
    BigInteger permission = new BigInteger("0");
    BigInteger numBig = permission.setBit(2);
    numBig = numBig.setBit(5);
    numBig = numBig.setBit(13);
    numBig = numBig.setBit(66);
    System.out.println("原理：" + numBig);	
    // 原理：73786976294838214692 = 2^2+2^5+2^13+2^66 次方的和；
    // 看！！即使这么大的数也不会溢出，而int最大值只有2147483647；

    //2.取值验证（返回Boolean型）
    boolean flag1 = numBig.testBit(2);		//true
    boolean flag2 = numBig.testBit(5);		//true
    boolean flag3 = numBig.testBit(13);		//true
    boolean flag4 = numBig.testBit(66);		//true
    boolean flag5 = numBig.testBit(27);		//false
}

源码分析

  • setBit()：将set进去变量作为二进制数，计算它们的和，并以十进制显示；

  • testBit()：与setBit()相反，验证this的二进制组成元素中是否包含传入的变量；

    //权限控制源码分析：

    //1.setBit()原理：计算this与2的n次方的和 public BigInteger setBit(int n) { if (n < 0) throw new ArithmeticException("Negative bit address");

    int intNum = n >>> 5;
int[] result = new int[Math.max(intLength(), intNum+2)];

for (int i=0; i < result.length; i++)
    result[result.length-i-1] = getInt(i);

result[result.length-intNum-1] |= (1 << (n & 31));

return valueOf(result);

    }

    //2.testBit()原理：计算this的值中是否包含2的n次方 public boolean testBit(int n) { if (n < 0) throw new ArithmeticException("Negative bit address");

    return (getInt(n >>> 5) & (1 << (n & 31))) != 0;

    }

小结 

  1. BigInteger也是不可变的，在进行每一步运算时，都会产生一个新的对象。都会产生一个新的对象。发生异常算术条件时，会抛出ArithmeticException异常。例如，一个整数除以“0”，会抛出一个这个类的实例； 
  2. 假设计算一个int数据平方与另一个大小的问题，很可能会内存溢出。除了使用二分法外，利用BigInteger的compareTo方法也是一个好选择，简单易懂，而且不需要算法支持； 
  3. 本章作为笔记使用，内容比较全面，但常用的只有：构造函数，基本运算以及compareTo()，intValue()，setBit()，testBit()方法； 
  4. setBit()和testBit()方法可用于菜单的权限控制，小编在开发中多次尝试，非常好用。很多微博有相关介绍，在这里我不做项目演示了。
avatar
文章
阅读
粉丝