Java 源碼--Integer

Integer類繼承Number類，實現Comparable接口。Integer類被修飾爲final，所以其不可被繼承。

字段

MIN_VALUE

最小值，@Native表示該字段可以從本地代碼引用。

@Native public static final int MIN_VALUE = 0x80000000;

MAX_VALUE

最大值。

@Native public static final int MAX_VALUE = 0x7fffffff;

TYPE

類原始類型int的類實例。@SuppressWarnings(“unchecked”)表示該字段應該抑制unchecked的編譯器警告。

@SuppressWarnings("unchecked")
public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

digits

所有可以表示爲字符的數字。此變量是默認修飾符 ，只能在包內訪問。

final static char[] digits = {
    '0' , '1' , '2' , '3' , '4' , '5' ,
    '6' , '7' , '8' , '9' , 'a' , 'b' ,
    'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
    'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
    'o' , 'p' , 'q' , 'r' , 's' , 't' ,
    'u' , 'v' , 'w' , 'x' , 'y' , 'z'
	};

DigitTens

處理大的數，代表十位。

final static char [] DigitTens = {
    '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
    '1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
    '2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
    '3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
    '4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
    '5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
    '6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
    '7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
    '8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
    '9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
	} ;

DigitOnes

處理大的數，代表個位。

final static char [] DigitOnes = {
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
	} ;

sizeTable

爲了得到十進制的位數。

final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                      99999999, 999999999, Integer.MAX_VALUE };

value

Integer的值，value被定義爲final，即常量，值不可更改。

private final int value;

SIZE

用於表示二進制補碼二進制形式的 int值的位數。

@Native public static final int SIZE = 32;

BYTES

用於表示二進制補碼二進制形式的 int值的字節數。

public static final int BYTES = SIZE / Byte.SIZE;

serialVersionUID

Integer的序列化版本號。

@Native private static final long serialVersionUID = 1360826667806852920L;

構造方法

Integer(int value)

public Integer(int value) {
    this.value = value;
}

Integer(String s)

public Integer(String s) throws NumberFormatException {
    this.value = parseInt(s, 10);
}

方法

toString(int i, int radix)

i是要轉換爲字符串的整數，radix是在字符串表示中使用的基數，返回基數radix表示的i的字符串。

public static String toString(int i, int radix) {
    // 如果radix不在合法的基數範圍之內，使用10作爲基數，範圍2~36。
    if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
        radix = 10;

    // 如果基數是10，使用更加快速的轉換方法。
    if (radix == 10) {
        return toString(i);
    }

    // Integer轉化爲以2爲基數的字符串最多需要32位，並且有可能需要一位來表示'-'字符。
    char buf[] = new char[33];
    boolean negative =(i < 0);
    // buf[]下標。
    int charPos = 32;

    // 如果i是非負數，將i變爲負數。
    if (!negative) {
        i = -i;
    }

    // 計算i轉換爲以radix爲基數的值，從後向前遍歷buf[]，並放入bug中。
    // 轉化爲負數來操作是因爲正數取不到128。
    while (i <= -radix) {
        buf[charPos--] = digits[-(i % radix)];
        i = i / radix;
    }
    buf[charPos] = digits[-i];

    // 如果是負數，加上字符'-'。
    if (negative) {
        buf[--charPos] = '-';
    }

   	// 返回buf[]中有值的部分的字符串。
    return new String(buf, charPos, (33 - charPos));
}

toUnsignedString(int i, int radix)

i是要轉換爲字符串的整數，radix是在字符串表示中使用的基數，返回無符號整數i以基數radix表示的字符串。具體參考Long的源碼閱讀。

public static String toUnsignedString(int i, int radix) {
    return Long.toUnsignedString(toUnsignedLong(i), radix);
}

toHexString(int i)

i是要轉換爲字符串的整數，返回無符號整數i以基數16表示的字符串。

public static String toHexString(int i) {
    return toUnsignedString0(i, 4);
}

toOctalString(int i)

i是要轉換爲字符串的整數，返回無符號整數i以基數8表示的字符串。

public static String toOctalString(int i) {
    return toUnsignedString0(i, 3);
}

toBinaryString(int i)

i是要轉換爲字符串的整數，返回無符號整數i以基數2表示的字符串。

public static String toBinaryString(int i) {
    return toUnsignedString0(i, 1);
}

toUnsignedString0(int val, int shift)

將val轉換爲以shift表示的基數的字符串，val是要轉換的整數，shift是$log_{2}x$的值，x是進制數。

private static String toUnsignedString0(int val, int shift) {
    // assert shift > 0 && shift <=5 : "Illegal shift value";
    // 得到val的二進制的有意義的位數，例如126對應的msg是7，-126對應的mag是32。
    int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
    // msg位數轉換爲2^shift進制的位數
    int chars = Math.max(((mag + (shift - 1)) / shift), 1);
    char[] buf = new char[chars];

    // 進行轉換
    formatUnsignedInt(val, shift, buf, 0, chars);

    // Use special constructor which takes over "buf".
    return new String(buf, true);
}

formatUnsignedInt(int val, int shift, char[] buf, int offset, int len)

val是要格式化的整數，shift是要格式化的基數的代表，4代表十六進制，3代表八進制，1代表二進制，buf是要寫入的字符數組，offset是buf中開始的位置，len是要寫入buf的長度，返回buf中最低位的位置。

static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
    int charPos = len;
    int radix = 1 << shift;
    int mask = radix - 1;
    // 此過程相當於從右向左遍歷val的二進制，每shift位轉換爲十進制對應radix進制的一位數。
    // 就如同二進制轉換爲十六進制時，每四位換算成十進制就是十六進制的一位；二進制轉換爲八進制時，每三位換算成十進制就是八進制的一位。
    do {
        buf[offset + --charPos] = Integer.digits[val & mask];
        val >>>= shift;
    } while (val != 0 && charPos > 0);

    return charPos;
}

toString(int i)

將i轉換爲string類型，返回String類型的i。

public static String toString(int i) {
    if (i == Integer.MIN_VALUE)
        return "-2147483648";
    // 負數有一個符號位
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    char[] buf = new char[size];
    // 將每一位轉換爲字符
    getChars(i, size, buf);
    return new String(buf, true);
}

toUnsignedString(int i)

public static String toUnsignedString(int i) {
    return Long.toString(toUnsignedLong(i));
}

getChars(int i, int index, char[] buf)

將整數i一個字符一個字符地寫入buf，index是buf的起始位置。

static void getChars(int i, int index, char[] buf) {
    int q, r;
    // buf的下標
    int charPos = index;
    // 正負數標誌
    char sign = 0;

    // 如果是負數，將sign賦值爲'-'
    if (i < 0) {
        sign = '-';
        i = -i;
    }

    // Generate two digits per iteration
    // 以中間位數爲界限，大的數使用一種算法，小的數使用一種算法
    // 2^16=65536
    while (i >= 65536) {
        q = i / 100;
        // really: r = i - (q * 100);
        // (q << 6) + (q << 5) + (q << 2) = q * (2^6 + 2^5 + 2^2) = q * 100
        r = i - ((q << 6) + (q << 5) + (q << 2));
        i = q;
        buf [--charPos] = DigitOnes[r];
        buf [--charPos] = DigitTens[r];
    }

    // Fall thru to fast mode for smaller numbers
    // assert(i <= 65536, i);
    for (;;) {
        // 爲什麼不使用i/10呢？？？因爲效率方面乘法優於除法，位運算優於乘法
        // 2^19=524288
        // 2^15<52429<2^16
        // 爲什麼是16+3呢？？？爲了精度
        q = (i * 52429) >>> (16+3);
        r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...
        buf [--charPos] = digits [r];
        i = q;
        if (i == 0) break;
    }
    // 符號
    if (sign != 0) {
        buf [--charPos] = sign;
    }
}

stringSize(int x)

獲取整型x轉爲string之後的字符串長度。

static int stringSize(int x) {
    for (int i=0; ; i++)
        if (x <= sizeTable[i])
            return i+1;
}

parseInt(String s, int radix)

將字符串s以radix爲基數轉換爲有符號整型數。如果發生以下任何一種情況，則拋出類型NumberFormatException的異常：

• 第一個參數是null或是長度爲零的字符串。
• 基數小於Character.MIN_RADIX或大於Character.MAX_RADIX。
• 字符串的任何字符不是指定基數的數字，除了第一個字符可能是減號或加號，前提是字符串長度大於1.
• 由字符串表示的值不是int類型的值。

public static int parseInt(String s, int radix) throws NumberFormatException {

	if (s == null) {
        throw new NumberFormatException("null");
    }

    if (radix < Character.MIN_RADIX) {
        throw new NumberFormatException("radix " + radix + " less than Character.MIN_RADIX");
    }

    if (radix > Character.MAX_RADIX) {
        throw new NumberFormatException("radix " + radix + " greater than Character.MAX_RADIX");
    }

    int result = 0;
    boolean negative = false;
    int i = 0, len = s.length();
    int limit = -Integer.MAX_VALUE;
    int multmin;
    int digit;

    if (len > 0) {
        char firstChar = s.charAt(0);
        // 首先檢查第一個字符是否是符號
        if (firstChar < '0') { // Possible leading "+" or "-"
            if (firstChar == '-') {
                negative = true;
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+')
                throw NumberFormatException.forInputString(s);

            if (len == 1) // Cannot have lone "+" or "-"
                throw NumberFormatException.forInputString(s);
            i++;
        }
        multmin = limit / radix;
        while (i < len) {
            // 積極消極避免MAX_VALUE附近的意外
            // 獲取以radix爲基數的字符的十進制表示，Character.digit('f', 16) = 15
            digit = Character.digit(s.charAt(i++),radix);
            if (digit < 0) {
                throw NumberFormatException.forInputString(s);
            }
            // 避免result*radix數值超過整型範圍
            if (result < multmin) {
                throw NumberFormatException.forInputString(s);
            }
            // 進位
            result *= radix;
            // 避免result-digit數值超過整型範圍
            if (result < limit + digit) {
                throw NumberFormatException.forInputString(s);
            }
            result -= digit;
        }
    } else {
        throw NumberFormatException.forInputString(s);
    }
    return negative ? result : -result;
}

parseInt(String s)

將字符串s以10爲基數轉換爲有符號整型數。

public static int parseInt(String s) throws NumberFormatException {
    return parseInt(s,10);
}

parseUnsignedInt(String s, int radix)

將字符串s以radix爲基數轉換爲無符號整型數。如果發生以下任何一種情況，則拋出類型NumberFormatException的異常：

• 第一個參數是null或是長度爲零的字符串。
• 基數小於Character.MIN_RADIX或大於Character.MAX_RADIX。
• 字符串的任何字符不是指定基數的數字，除了第一個字符可能是加號，前提是字符串長度大於1.
• 由字符串表示的值大於最大的無符號整數值$2^{31}-1$。

public static int parseUnsignedInt(String s, int radix)
    throws NumberFormatException {
    if (s == null)  {
        throw new NumberFormatException("null");
    }

    int len = s.length();
    if (len > 0) {
        char firstChar = s.charAt(0);
        if (firstChar == '-') {
            throw new
                NumberFormatException(String.format("Illegal leading minus sign " + "on unsigned string %s.", s));
        } else {
            // 此處有一個分界線，若以最大基數即36轉換字符串，則該字符串長度不能超過5，否則會超過int的取值範圍
            // 至於爲什麼十進制特殊了一下，可能是十進制比較常用吧，不然使用Long處理會佔用空間吧。
            if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
                (radix == 10 && len <= 9) ) { // Integer.MAX_VALUE in base 10 is 10 digits
                return parseInt(s, radix);
            } else {
                long ell = Long.parseLong(s, radix);
                // 判斷ell是否超出int的取值範圍
                if ((ell & 0xffff_ffff_0000_0000L) == 0) {
                    return (int) ell;
                } else {
                    throw new NumberFormatException(String.format("String value %s exceeds " + "range of unsigned int.", s));
                }
            }
        }
    } else {
        throw NumberFormatException.forInputString(s);
    }
}

parseUnsignedInt(String s)

將字符串s以10爲基數轉換爲無符號整型數。

public static int parseInt(String s) throws NumberFormatException {
    return parseInt(s,10);
}

Integer valueOf(String s, int radix)

以radix爲基數將字符串s轉換爲Integer類型。返回的Integer類型的數優先從緩存中獲取。

public static Integer valueOf(String s, int radix) throws NumberFormatException {
    return Integer.valueOf(parseInt(s,radix));
}

valueOf(String s)

以10爲基數將字符串s轉換爲Integer類型。返回的Integer類型的數優先從緩存中獲取。

public static Integer valueOf(String s) throws NumberFormatException {
    return Integer.valueOf(parseInt(s, 10));
}

valueOf(int i)

將整型數i轉換爲Integer類型數。返回的Integer類型的數優先從緩存中獲取。

public static Integer valueOf(int i) {
    // 先從緩存中獲取
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

byteValue()

返回byte類型的值。

public byte byteValue() {
    return (byte)value;
}

shortValue()

返回short類型的值。

public short shortValue() {
    return (short)value;
}

intValue()

返回int類型的值。

public int intValue() {
    return value;
}

longValue()

返回long類型的值。

public long longValue() {
    return (long)value;
}

floatValue()

返回long類型的值。

public float floatValue() {
    return (float)value;
}

doubleValue()

返回double類型的值。

public double doubleValue() {
    return (double)value;
}

toString()

返回String類型。

public String toString() {
    return toString(value);
}

hashCode()

返回哈希值。由此可見，Integer對象的hashcode值是它的值。

@Override
public int hashCode() {
    return Integer.hashCode(value);
}

hashCode(int value)

返回value的哈希值。

public static int hashCode(int value) {
    return value;
}

equals(Object obj)

判斷obj的value與調用該方法的對象的value是否相等。

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

getInteger(String nm)

返回系統屬性nm的整數值。

public static Integer getInteger(String nm) {
    return getInteger(nm, null);
}

getInteger(String nm, int val)

返回系統屬性nm的整數值，如果爲空，返回默認的val的Integer。

public static Integer getInteger(String nm, int val) {
    Integer result = getInteger(nm, null);
    return (result == null) ? Integer.valueOf(val) : result;
}

getInteger(String nm, Integer val)

返回系統屬性nm的整數值，如果爲空，返回默認的val。

public static Integer getInteger(String nm, Integer val) {
    String v = null;
    try {
        v = System.getProperty(nm);
    } catch (IllegalArgumentException | NullPointerException e) {
    }
    if (v != null) {
        try {
            return Integer.decode(v);
        } catch (NumberFormatException e) {
        }
    }
    return val;
}

decode(String nm)

將nm解碼爲Integer。

public static Integer decode(String nm) throws NumberFormatException {
    int radix = 10;
    int index = 0;
    boolean negative = false;
    Integer result;

    if (nm.length() == 0)
        throw new NumberFormatException("Zero length string");
    char firstChar = nm.charAt(0);
    // Handle sign, if present
    if (firstChar == '-') {
        negative = true;
        index++;
    } else if (firstChar == '+')
        index++;

    // Handle radix specifier, if present
    // 以'#'開頭的代表十六進制？？？
    if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
        index += 2;
        radix = 16;
    }
    else if (nm.startsWith("#", index)) {
        index ++;
        radix = 16;
    }
    // 如果0後面沒有字符了，則nm就只是0而已，不是八進制。
    else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
        index ++;
        radix = 8;
    }

    if (nm.startsWith("-", index) || nm.startsWith("+", index))
        throw new NumberFormatException("Sign character in wrong position");

    try {
        result = Integer.valueOf(nm.substring(index), radix);
        result = negative ? Integer.valueOf(-result.intValue()) : result;
    } catch (NumberFormatException e) {
        // 如果number是Integer.MIN_VALUE，由於正數最大值是Integer.MIN_VALUE-1，nm.substring(index)作爲int類型的參數傳入會有錯誤。 
        // 將nm.substring(index)轉爲負數來處理。
        String constant = negative ? ("-" + nm.substring(index))
            : nm.substring(index);
        result = Integer.valueOf(constant, radix);
    }
    return result;
}

compareTo(Integer anotherInteger)

調用該方法的對象的value與參數中的對象的value相比較，this.value比anotherInteger.value小返回-1，this.value比anotherInteger.value大返回1，this.value等於anotherInteger.value返回0。

public int compareTo(Integer anotherInteger) {
    return compare(this.value, anotherInteger.value);
}

compare(int x, int y)

比較x和y的大小，x比y小返回-1，x比y大返回1，x等於y返回0。

public static int compare(int x, int y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

compareUnsigned(int x, int y)

將x，y視爲無符號比較大小，因爲負數符號位爲1，所以正數一定比負數小。

public static int compareUnsigned(int x, int y) {
    return compare(x + MIN_VALUE, y + MIN_VALUE);
}

toUnsignedLong(int x)

將x視爲無符號轉爲long型。

public static long toUnsignedLong(int x) {
    return ((long) x) & 0xffffffffL;
}

divideUnsigned(int dividend, int divisor)

將dividend和divisor視爲無符號相除。

public static int divideUnsigned(int dividend, int divisor) {
    // In lieu of tricky code, for now just use long arithmetic.
    return (int)(toUnsignedLong(dividend) / toUnsignedLong(divisor));
}

remainderUnsigned(int dividend, int divisor)

忽略符號取dividend除以divisor的餘數。

public static int remainderUnsigned(int dividend, int divisor) {
    // In lieu of tricky code, for now just use long arithmetic.
    return (int)(toUnsignedLong(dividend) % toUnsignedLong(divisor));
}

highestOneBit(int i)

返回十進制數轉爲二進制最高位表示的十進制的數值。

public static int highestOneBit(int i) {
    // HD, Figure 3-1
    // 使得i的二進制從排除符號位的最高位到最低位數值均爲1
    i |= (i >>  1);
    i |= (i >>  2);
    i |= (i >>  4);
    i |= (i >>  8);
    i |= (i >> 16);
    return i - (i >>> 1);
}

lowestOneBit(int i)

返回十進制數轉爲二進制最低位表示的十進制的數值，即忽略符號位之後最高位的數值。

public static int lowestOneBit(int i) {
    // HD, Section 2-1
    return i & -i;
}

numberOfLeadingZeros(int i)

i是整數，返回i的補碼中最高位0的位數，從左向右數，下一位不是0的位數，範圍是0~32，0代表沒有。此方法很機智地採用了二分法的思想。numberOfLeadingZeros(8)=28。

public static int numberOfLeadingZeros(int i) {
    // HD, Figure 5-6
    if (i == 0)
        return 32;
    int n = 1;
    // 前16位上都是0，左移16位
    if (i >>> 16 == 0) { n += 16; i <<= 16; }
    // 前8位都是0，左移8位
    if (i >>> 24 == 0) { n +=  8; i <<=  8; }
    // 前4位都是0，左移4位
    if (i >>> 28 == 0) { n +=  4; i <<=  4; }
    // 前2位都是0，左移2位
    if (i >>> 30 == 0) { n +=  2; i <<=  2; }
    // 減去第1位上數值
    n -= i >>> 31;
    return n;
}

numberOfTrailingZeros(int i)

i是整數，返回i的補碼中最低位0的位數。從右向左數，下一位不是0的位數。numberOfLeadingZeros(8)=3。

public static int numberOfTrailingZeros(int i) {
    // HD, Figure 5-14
    int y;
    if (i == 0) return 32;
    int n = 31;
    y = i <<16; if (y != 0) { n = n -16; i = y; }
    y = i << 8; if (y != 0) { n = n - 8; i = y; }
    y = i << 4; if (y != 0) { n = n - 4; i = y; }
    y = i << 2; if (y != 0) { n = n - 2; i = y; }
    return n - ((i << 1) >>> 31);
}

bitCount(int i)

返回i的補碼中值爲1的位數的個數。

public static int bitCount(int i) {
    // 每兩位存儲每兩位值爲1的個數。
    i = i - ((i >>> 1) & 0x55555555);
    // 每四位存儲每四位值爲1的個數。
    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
    // 每八位存儲每八位值爲1的個數。
    i = (i + (i >>> 4)) & 0x0f0f0f0f;
    // 每十六位存儲每十六位值爲1的個數。
    i = i + (i >>> 8);
    // 每三十二位存儲每三十二位值爲1的個數。
    i = i + (i >>> 16);
    // 由於值最大爲32，所以只關注後六位即可。
    return i & 0x3f;
}

rotateLeft(int i, int distance)

i的二進制值循環左移distance位。普通左移會丟失最左邊位數的數，但是循環左移最左邊的數會循環到最右邊。

public static int rotateLeft(int i, int distance) {
    return (i << distance) | (i >>> -distance);
}

rotateRight(int i, int distance)

i的二進制值循環右移distance位。

public static int rotateRight(int i, int distance) {
    return (i >>> distance) | (i << -distance);
}

reverse(int i)

反轉i的二進制值上每一位的數。

public static int reverse(int i) {
    // HD, Figure 7-1
    // 每兩個一組，每位進行反轉
    i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
    // 每四個一組，每兩位進行反轉
    i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
    // 每八個一組，每四位進行反轉
    i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
    // 現在有四個八組已經反轉完成，標記爲i=ABCD
    // i << 24    D000
    // (i & 0xff00) << 8    0C00
    // (i >>> 8) & 0xff00    00B0
    // i >>> 24    000A
    i = (i << 24) | ((i & 0xff00) << 8) |
        ((i >>> 8) & 0xff00) | (i >>> 24);
    return i;
}

signum(int i)

如果i爲負數返回-1，如果i爲正數返回1，如果i爲0返回0。

public static int signum(int i) {
    // HD, Section 2-7
    return (i >> 31) | (-i >>> 31);
}

reverseBytes(int i)

反轉i的二進制值的每一個字節上數。

public static int reverseBytes(int i) {
    return ((i >>> 24)           ) |
           ((i >>   8) &   0xFF00) |
           ((i <<   8) & 0xFF0000) |
           ((i << 24));
}

sum(int a, int b)

返回a和b的和。

public static int sum(int a, int b) {
    return a + b;
}

max(int a, int b)

返回a，b中的最大值。

public static int max(int a, int b) {
    return Math.max(a, b);
}

min(int a, int b)

返回a，b中的最小值。

public static int min(int a, int b) {
    return Math.min(a, b);
}

內部類

IntegerCache

此內部類用來緩存部分大小的Integer，默認範圍-128-127。

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                // 若設置了更大的值，則取設置的值
                i = Math.max(i, 127);
                // 確保數組的大小最大是Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        // 緩存從low到high的整數
        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}