簡介
big-endian和little-endian
數據 05 06 07 08
在LITTLE-ENDIAN的情況下存放爲：
數據 08 07 06 05
BigInteger
先看一下JDK對BigInteger類的介紹：
Immutable arbitrary-precision integers. All operations behave as if BigIntegers were represented in two's-complement notation (like Java's primitive integer types).
BigInteger provides analogues to all of Java's primitive integer operators, and all relevant methods from java.lang.Math. Additionally, BigInteger provides operations for modular arithmetic, GCD calculation, primality testing, prime generation, bit manipulation,
and a few other miscellaneous operations.
上面這段話的意思是：
BigInteger是不可變的任意精度的整數。所有操作中，都以二進制補碼形式表示 BigInteger（如 Java 的基本整數類型）。BigInteger 提供所有 Java 的基本整數操作符的對應物，並提供 java.lang.Math 的所有相關方法。另外，BigInteger 還提供以下運算：模算術、GCD 計算、素數生成、位操作以及一些其他操作。
下面看看BigInteger有哪些重點的屬性，主要的有下面三個：
（1）final int signum
signum屬性是爲了區分：正負數和0的標誌位，JDK註釋裏面已經說的很明白了，-1代表負數，0代表0，1代表整數：
The signum of this BigInteger: -1 for negative, 0 for zero, or 1 for positive. Note that the BigInteger zero must have a signum of 0. This is necessary to ensures that there is exactly one representation for each BigInteger value.
（2）final int[] mag
mag是magnitude的縮寫形式，mag表示的是正數的原碼字節數組。mag數組是存儲BigInteger數值大小的，採用big-endian的順序，也就是高位字節存入低地址，低位字節存入高地址，依次排列的方式。JDK原文註釋如下：
The magnitude of this BigInteger, in big-endian order: the zeroth element of this array is the most-significant int of the magnitude. The magnitude must be "minimal" in that the most-significant int (mag[0]) must be non-zero. This is necessary to ensure that
there is exactly one representation for each BigInteger value. Note that this implies that the BigInteger zero has a zero-length mag array.
（3）final static long LONG_MASK = 0xffffffffL;
This mask is used to obtain the value of an int as if it were unsigned。
構造函數
BigInteger(byte[] val)
public BigInteger(byte[] val) {
if (val.length == 0)
throw new NumberFormatException("Zero length BigInteger");
if (val[0] < 0) {
mag = makePositive(val);
signum = -1;
} else {
mag = stripLeadingZeroBytes(val);
signum = (mag.length == 0 ? 0 : 1);
}
}private static int[] makePositive(byte a[]) {
int keep, k;
int byteLength = a.length;
// Find first non-sign (0xff) byte of input
for (keep=0; keep<byteLength && a[keep]==-1; keep++)//keep表示第一個非符號位也就是-1的字節索引，keep索引開始的字節是有效字節
;
//k用於判斷，從非符號位開始後面的字節是否全是0，如果是，則表示這個值是補碼所能表示的最小值。固定二進制位數下，補碼錶示的數值範圍是負數最小值的絕對值比正數最大值大1，因此如果要表示負數最小值的絕對值，就要多加1位二進制位，在這裏就表現爲多加一個byte。
/* Allocate output array. If all non-sign bytes are 0x00, we must
* allocate space for one extra output byte. */
for (k=keep; k<byteLength && a[k]==0; k++)
;
int extraByte = (k==byteLength) ? 1 : 0;
int intLength = ((byteLength - keep + extraByte) + 3)/4;//result數組的長度取決於有效字節的個數和extraByte
int result[] = new int[intLength];//要返回的結果數組
/* Copy one's complement of input into output, leaving extra
* byte (if it exists) == 0x00 */
int b = byteLength - 1;
for (int i = intLength-1; i >= 0; i--) {
result[i] = a[b--] & 0xff;
int numBytesToTransfer = Math.min(3, b-keep+1);//numBytesToTransfer表示接下來有幾個字節需要填充到result數組裏，一個int4個字節，所以最大取3
if (numBytesToTransfer < 0)
numBytesToTransfer = 0;
for (int j=8; j <= 8*numBytesToTransfer; j += 8)
result[i] |= ((a[b--] & 0xff) << j);//每個字節佔8位，所以每次遞加8位
// Mask indicates which bits must be complemented//mask用於標記哪幾個字節需要取反（one's complement）
int mask = -1 >>> (8*(3-numBytesToTransfer));
result[i] = ~result[i] & mask;
}
// Add one to one's complement to generate two's complement//補碼取反後，result數組最大索引處的值加1，得到原碼（也就是這個負數補碼所對應的整數）
for (int i=result.length-1; i>=0; i--) {
result[i] = (int)((result[i] & LONG_MASK) + 1);
if (result[i] != 0)//result[i]此時已經是原碼了，如果原碼全是0，補碼也必定全身0。補碼全0取反後是全1，加1後要進位，因此result[i+1]要加1
break;
}
return result;
}/**
* Returns a copy of the input array stripped of any leading zero bytes.
*/
private static int[] stripLeadingZeroBytes(byte a[]) {
int byteLength = a.length;
int keep;
// Find first nonzero byte
for (keep=0; keep<byteLength && a[keep]==0; keep++)
;
// Allocate new array and copy relevant part of input array
int intLength = ((byteLength - keep) + 3) >>> 2;
int[] result = new int[intLength];
int b = byteLength - 1;
for (int i = intLength-1; i >= 0; i--) {
result[i] = a[b--] & 0xff;
int bytesRemaining = b - keep + 1;
int bytesToTransfer = Math.min(3, bytesRemaining);
for (int j=8; j <= (bytesToTransfer << 3); j += 8)
result[i] |= ((a[b--] & 0xff) << j);
}
return result;
}BigInteger(int signum, byte[] magnitude)
public BigInteger(int signum, byte[] magnitude) {
this.mag = stripLeadingZeroBytes(magnitude);
if (signum < -1 || signum > 1)
throw(new NumberFormatException("Invalid signum value"));
if (this.mag.length==0) {
this.signum = 0;
} else {
if (signum == 0)
throw(new NumberFormatException("signum-magnitude mismatch"));
this.signum = signum;
}
}BigInteger(String val)
BigInteger(String val, int radix)
BigInteger(int numBits, Random rnd)
BigInteger(int bitLength, int certainty, Random rnd)
注意事項
BigInteger如何存儲大數據的？
public static BigInteger valueOf(long val)
public static BigInteger valueOf(long val) {
// If -MAX_CONSTANT < val < MAX_CONSTANT, return stashed constant
if (val == 0)
return ZERO;
if (val > 0 && val <= MAX_CONSTANT)
return posConst[(int) val];
else if (val < 0 && val >= -MAX_CONSTANT)
return negConst[(int) -val];
return new BigInteger(val);
} /**
* Initialize static constant array when class is loaded.
*/
private final static int MAX_CONSTANT = 16;
private static BigInteger posConst[] = new BigInteger[MAX_CONSTANT+1];
private static BigInteger negConst[] = new BigInteger[MAX_CONSTANT+1];
static {
for (int i = 1; i <= MAX_CONSTANT; i++) {
int[] magnitude = new int[1];
magnitude[0] = i;
posConst[i] = new BigInteger(magnitude, 1);
negConst[i] = new BigInteger(magnitude, -1);
}
}System.out.println(BigInteger.valueOf(16) == BigInteger.valueOf(16));//true
System.out.println(BigInteger.valueOf(17) == BigInteger.valueOf(17));//false
System.out.println(BigInteger.valueOf(-16) == BigInteger.valueOf(-16));//true
System.out.println(BigInteger.valueOf(-17) == BigInteger.valueOf(-17));//false基本運算示例
public static void main(String[] args) {
BigInteger b1 = BigInteger.valueOf(20l);
BigInteger b2 = BigInteger.valueOf(10l);
System.out.println(b1.add(b2).toString());//加 30
System.out.println(b1.subtract(b2).toString());//減 10
System.out.println(b1.multiply(b2).toString());//乘 200
System.out.println(b1.divide(b2).toString());//除 2
System.out.println(b1.remainder(b2).toString());//取餘 0
}