BigInteger简析

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++)<span style="color:#ff0000;">//keep表示第一个非符号位也就是-1的字节索引，keep索引开始的字节是有效字节</span>
	    ;

        <span style="color:#ff0000;">//k用于判断，从非符号位开始后面的字节是否全是0，如果是，则表示这个值是补码所能表示的最小值。固定二进制位数下，补码表示的数值范围是负数最小值的绝对值比正数最大值大1，因此如果要表示负数最小值的绝对值，就要多加1位二进制位，在这里就表现为多加一个byte。</span>
	/* 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;<span style="color:#ff0000;">//result数组的长度取决于有效字节的个数和extraByte</span>
	int result[] = new int[intLength];<span style="color:#ff0000;">//要返回的结果数组</span>

	/* 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)<span style="color:#ff0000;">;//numBytesToTransfer表示接下来有几个字节需要填充到result数组里，一个int4个字节，所以最大取3</span>
            if (numBytesToTransfer < 0)
                numBytesToTransfer = 0;
            for (int j=8; j <= 8*numBytesToTransfer; j += 8)
                result[i] |= ((a[b--] & 0xff) << j);<span style="color:#ff0000;">//每个字节占8位，所以每次递加8位</span>

            // Mask indicates which bits must be complemented<span style="color:#ff0000;">//mask用于标记哪几个字节需要取反（one‘s complement）</span>
            int mask = -1 >>> (8*(3-numBytesToTransfer));
            result[i] = ~result[i] & mask;
        }

	// Add one to one‘s complement to generate two‘s complement<span style="color:#ff0000;">//补码取反后，result数组最大索引处的值加1，得到原码（也就是这个负数补码所对应的整数）</span>
	for (int i=result.length-1; i>=0; i--) {
            result[i] = (int)((result[i] & LONG_MASK) + 1);
	    if (result[i] != 0)<span style="color:#ff0000;">//result[i]此时已经是原码了，如果原码全是0，补码也必定全身0。补码全0取反后是全1，加1后要进位，因此result[i+1]要加1</span>
                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)

注意事项

java.math.BigInteger系列教程（八）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
    }