（ 算法樹之其他算法與技巧 ）【 JAVA大數 】
在 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;
}
小結
BigInteger也是不可變的，在進行每一步運算時，都會產生一個新的對象。都會產生一個新的對象。發生異常算術條件時，會拋出ArithmeticException異常。例如，一個整數除以“0”，會拋出一個這個類的實例；
假設計算一個int數據平方與另一個大小的問題，很可能會內存溢出。除了使用二分法外，利用BigInteger的compareTo方法也是一個好選擇，簡單易懂，而且不需要算法支持；
本章作爲筆記使用，內容比較全面，但常用的只有：構造函數，基本運算以及compareTo()，intValue()，setBit()，testBit()方法；
setBit()和testBit()方法可用於菜單的權限控制，小編在開發中多次嘗試，非常好用。很多微博有相關介紹，在這裏我不做項目演示了。
例題：I - Intergalactic Bidding 轉自：https://www.cnblogs.com/ccsu-kid/p/10526132.html
題意：n個人競價拍賣寶石，寶石價值s塊錢，求哪些人出的錢加起來剛好是s
題解：
根據題意，注意當前人出的錢至少是全場人出的最高價錢的兩倍（關鍵條件）
那我們就可以對每個人出的錢排序,從大的開始取，假設當前爲x，如果s>=x，
一定要取x，因爲如果不取x我們就得取比x小的那些數，但是就算把比x小的
數全加起來都不比x大，所以x必須被取走！
舉例：2 5 13 28 50，s=57，發現50小於等於57，取之，s=7,然後28>s，
不取，然後13也不能取，最後把5和2取完，s=0
因爲錢數很大，這裏用JAVA裏的BigInteger類處理。
一開始想着用結構體存人名字和錢，然後重載運算符再排序，
結果發現JAVA不支持重載運算符。。。
然後發現每個人的錢數肯定不同，便祭出了map；
後來又發現還他媽不支持biginteger排序。。。
好吧，大不了我手寫個排序咯
| Sample Input 1 | Sample Output 1 |
|---|---|
|
|
| Sample Input 2 | Sample Output 2 |
|---|---|
|
|
代碼：
package paticipant;
import java.math.BigInteger;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
BigInteger s = in.nextBigInteger();
Map<BigInteger, String> mp = new HashMap<BigInteger, String>();
BigInteger[] a = new BigInteger[1005];
for ( int i=0; i<n; i++ ) {
String name = in.next();
a[i] = in.nextBigInteger();
mp.put(a[i], name);
}
for ( int i=0; i<n; i++ ) {
for ( int j=i+1; j<n; j++ ) {
if ( a[j].compareTo(a[i])==1 ) {
BigInteger t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
String[] ans = new String[1005];
int cnt = 0;
for ( int i=0; i<n; i++ ) {
if ( s.compareTo(a[i])>=0 ) {
s = s.subtract(a[i]);
ans[cnt++] = mp.get(a[i]);
}
}
if ( s.compareTo(BigInteger.ZERO)==0 ) {
System.out.println(cnt);
for ( int i=0; i<cnt; i++ ) System.out.println( ans[i] );
}
else System.out.println("0");
in.close();
}
}