//讀入方法：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() {
		//在構造將函數(shù)時，把radix進制的字符串轉化為BigInteger
		String str = "1011100111";
		int radix = 2;
		BigInteger interNum1 = new BigInteger(str,radix);	//743
		//我們通常不寫，則是默認成10進制轉換，如下：
		BigInteger interNum2 = new BigInteger(str);			//1011100111
	}

//基本運算: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，否則出現(xiàn)異常：ArithmeticException("BigInteger: modulus not positive"))
		BigInteger bigNum5 = a.mod(b);			//1
		//6.求余
		BigInteger bigNum6 = a.remainder(b);	//1
		//7.平方(需 n >= 0，否則出現(xiàn)異常：ArithmeticException("Negative exponent"))
		BigInteger bigNum7 = a.pow(n);			//2197
		//8.取絕對值
		BigInteger bigNum8 = a.abs();			//13
		//9.取相反數(shù)
		BigInteger bigNum9 = a.negate();		//-13
	}

//比較大小:compareTo(),max(),min()
	@Test
	public void testCompare() {
		BigInteger bigNum1 = new BigInteger("52");
		BigInteger bigNum2 = new BigInteger("27");
		//1.compareTo()：返回一個int型數(shù)據(jù)（1 大于； 0 等于； -1 小于）
		int num = bigNum1.compareTo(bigNum2);			//1
		//2.max()：直接返回大的那個數(shù)，類型為BigInteger
		//	原理：return (compareTo(val) > 0 ? this : val);
		BigInteger compareMax = bigNum1.max(bigNum2);	//52
		//3.min()：直接返回小的那個數(shù)，類型為BigInteger
		//	原理：return (compareTo(val) < 0 ? this : val);
		BigInteger compareMin = bigNum1.min(bigNum2);	//27
	}

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

//類型轉換(返回類型如下)
	@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，不常用，但有備無患)
	@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()
	@Test
	public void testSetAndTest() {
		//1.封裝數(shù)據(jù)(setBit的值需 >= 0，否則出現(xiàn)異常：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 次方的和；
		// 看??！即使這么大的數(shù)也不會溢出，而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
	}

//權限控制源碼分析：
	//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;
	}