面試一般都會問到你看過原始碼嗎，所以，我就參考了網上的資料和自己的見解寫了這篇原始碼解讀。
概況
首先介紹 Integer和int的區別
1、Integer是int的包裝類，int是java的一種基本資料型別
2、Integer變數必須例項化後才能使用，而int變數不需要
3、Integer實際是物件的引用，當new一個Integer時，實際上是生成一個指標指向此物件；而int則是直接儲存資料值
非new生成的Integer變數指向的是java常量池中的物件，而new Integer()生成的變數指向堆中新建的物件，兩者在記憶體中的地址不同）
Integer a = new Integer(99);
Integer b = 99;
System.out.print(a== b);
//false複製程式碼4、Integer的預設值是null，int的預設值是0
Java的Ingeter是int的包裝類,在開發中我們基本可以將兩者等價。
Integer類是對int進行封裝,裡面包含處理int型別的方法，比如int到String型別的轉換方法或String型別轉int型別的方法，也有與其他型別之間的轉換方，當然也包括操作位的方法。
主要屬性
Integer的界限範圍是 0x7fffffff~0x80000000 這與int型別的界限範圍是一樣的。
在Integer類中是這樣宣告的。
//MIN_VALUE靜態變數表示int能取的最小值，為-2的31次方，被final修飾說明不可變。
public static final int MIN_VALUE = 0x80000000;
//類似的還有MAX_VALUE，表示int最大值為2的31次方減1。
public static final int MAX_VALUE = 0x7fffffff;
public static final int SIZE = 32;
複製程式碼SIZE用來表示二進位制補碼形式的int值的位元數，值為32，因為是靜態變數所以值不可變。
由於補碼錶示負數的關係。正數總是比負數多一個來，所以：
MIN_VALUE表示int能取的最小值，為-2的31次方。
MAX_VALUE表示int能取最大值，為2的31次方減1。
public static final Class<Integer> TYPE = (Class<Integer>) Class.getPrimitiveClass("int");複製程式碼還有一個是這個，這個應該是指型別，型別是int。
final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
99999999, 999999999, Integer.MAX_VALUE };
// Requires positive xstatic int stringSize(int x) {
for (int i=0; ; i++)
if (x <= sizeTable[i])
return i+1;
}
複製程式碼stringSize主要是為了判斷一個int型數字對應字串的長度。sizeTable這個陣列儲存了該位數的最大值。
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'
};複製程式碼digits陣列裡面存的是數字從二進位制到36進位制所表示的字元，所以需要有36個字元才能表示所有不用進位制的數字。
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',
} ;
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',
} ;複製程式碼DigitTens和DigitOnes兩個陣列，DigitTens陣列是為了獲取0到99之間某個數的十位,DigitOnes是為了獲取0到99之間某個數的個位
IntegerCache內部類
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) {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
}
private IntegerCache() {}
}複製程式碼IntegerCache是Integer的一個靜態內部類，它包含了int可能值得Integer陣列，它負責儲存了(high -low)個靜態Integer物件，並切在靜態程式碼塊中初始化。預設範圍是【-128,127】，所以這裡預設只例項化了256個Integer物件，當Integer的值範圍在【-128,127】時則直接從快取中獲取對應的Integer物件，不必重新例項化。這些快取值都是靜態且final的，避免重複的例項化和回收。
如果不去配置虛擬機器引數，這個值不會變。配合valueOf(int) 方法，可以節省建立物件造成的資源消耗。另外如果想改變這些值快取的範圍，再啟動JVM時可以通過-Djava.lang.Integer.IntegerCache.high=xxx就可以改變快取值的最大值，比如-Djava.lang.Integer.IntegerCache.high=888則會快取[-888]。
方法
parseInt
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}
public static int parseInt(String s, int radix)
throws NumberFormatException
{
/*
* WARNING: This method may be invoked early during VM initialization
* before IntegerCache is initialized. Care must be taken to not use
* the valueOf method.
*/
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) {
// Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(s.charAt(i++),radix);
if (digit < 0) {
throw NumberFormatException.forInputString(s);
}
if (result < multmin) {
throw NumberFormatException.forInputString(s);
}
result *= radix;
if (result < limit + digit) {
throw NumberFormatException.forInputString(s);
}
result -= digit;
}
} else {
throw NumberFormatException.forInputString(s);
}
return negative ? result : -result;
}複製程式碼有兩個parseInt方法，這裡就是java的overload(過載)了，以後再介紹，第一個引數是需要轉換的字串，第二個參數列示進位制數（比如2,8,10）。
原始碼裡已經給出了例子：
* parseInt("0", 10) returns 0
* parseInt("473", 10) returns 473
* parseInt("+42", 10) returns 42
* parseInt("-0", 10) returns 0
* parseInt("-FF", 16) returns -255
* parseInt("1100110", 2) returns 102
* parseInt("2147483647", 10) returns 2147483647
* parseInt("-2147483648", 10) returns -2147483648
* parseInt("2147483648", 10) throws a NumberFormatException
* parseInt("99", 8) throws a NumberFormatException
* parseInt("Kona", 10) throws a NumberFormatException
* parseInt("Kona", 27) returns 411787d
複製程式碼但是Integer.parseInt("10000000000",10)，會丟擲java.lang.NumberFormatException異常,因為超過了Integer的最大的範圍了。
該方法的邏輯：
1.判斷字串不為空，並且傳進來進位制引數在 Character.MIN_RADIX ，Charcater.MAX_RADIX 之間，即2和36。
2.判斷輸入的字串長度必須大於0，再根據第一個字串可能是數字或負號或正號進行處理。
3.之後就是核心邏輯了，字串轉換數字。
例如
127 轉換成8進位制 1*8*8+2*8+7*1=87
127轉換成十進位制 1*10*10+2*10+7*1=127
從左到右遍歷字串，然後乘上進位制數，再加上下一個字元，接著再乘以進位制數，再加上下個字元，不斷重複，直到最後一個字元。
這裡也是通過計算負數再新增符號位的方式避免Integer.MIN_VALUE單獨處理的問題，，因為負數Integer.MIN_VALUE變化為正數時會導致數值溢位，所以全部都用負數來運算。這裡使用了一個mulmin變數來避免數字溢位的問題，單純的使用正負號不能準確判斷是否溢位(一次乘法導致溢位的結果符號不確定)。
建構函式
public Integer(int value) {
this.value = value;
}
public Integer(String s) throws NumberFormatException {
this.value = parseInt(s, 10);
}複製程式碼這兩種建構函式，一個是傳int型別，一個是String型別。第二種是通過呼叫parseInt方法進行轉換的。
getChars方法
static void getChars(int i, int index, char[] buf) {
int q, r;
int charPos = index;
char sign = 0;
if (i < 0) {
sign = '-';
i = -i;
}
// Generate two digits per iteration
while (i >= 65536) {
q = i / 100;
// really: r = i - (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 (;;) {
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;
}
}
複製程式碼該方法主要做的事情是將某個int型數值放到char陣列裡面。
這裡面處理用了一些技巧，int高位的兩個位元組和低位的兩個位元組分開處理，
while (i >= 65536)部分就是處理高位的兩個位元組，大於65536的部分使用了除法，一次生成兩位十進位制字元，每次處理2位數，其實((q << 6) + (q << 5) + (q << 2))其實等於q*100,DigitTens和DigitOnes陣列前面已經講過它的作用了，用來獲取十位和個位。
小於等於65536的部分使用了乘法加位移做成除以10的效果，比如(i * 52429) >>> (16+3)其實約等於i/10，((q << 3) + (q << 1))其實等於q*10，然後再通過digits陣列獲取到對應的字元。可以看到低位處理時它儘量避開了除法，取而代之的是用乘法和右移來實現，可見除法是一個比較耗時的操作，比起乘法和移位。另外也可以看到能用移位和加法來實現乘法的地方也儘量不用乘法，這也說明乘法比起它們更加耗時。而高位處理時沒有用移位是因為做乘法後可能會溢位。
toString方法
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);
}
public String toString() {
return toString(value);
}
public static String toString(int i, int radix) {
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
radix = 10;
if (radix == 10) {
return toString(i);
}
char buf[] = new char[33];
boolean negative = (i < 0);
int charPos = 32;
if (!negative) {
i = -i;
}
while (i <= -radix) {
buf[charPos--] = digits[-(i % radix)];
i = i / radix;
}
buf[charPos] = digits[-i];
if (negative) {
buf[--charPos] = '-';
}
return new String(buf, charPos, (33 - charPos));
}
複製程式碼這裡有三個toString 方法。
第一個toString方法很簡單，就是先用stringSize得到數字是多少位，再用getChars獲取數字對應的char陣列，最後返回一個String型別。
第二個更簡單了，就是呼叫第一個toString方法。
第三個toString方法是帶了進位制資訊的，它會轉換成對應進位制的字串。不在2到36進位制範圍之間的都會按照10進位制處理。
valueOf方法
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}
public static Integer valueOf(String s, int radix) throws NumberFormatException {
return Integer.valueOf(parseInt(s,radix));
}
複製程式碼第二個和第三個都是呼叫第一個valueOf方法，只不過呼叫的parseInt（）的方法不一樣。
decode方法
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;
}
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) {
// If number is Integer.MIN_VALUE, we'll end up here. The next line
// handles this case, and causes any genuine format error to be
// rethrown.
String constant = negative ? ("-" + nm.substring(index))
: nm.substring(index);
result = Integer.valueOf(constant, radix);
}
return result;
}複製程式碼decode方法主要作用是對字串進行解碼。
預設會處理成十進位制，0開頭的都會處理成8進位制，0x和#開頭的都會處理成十六進位制。
xxxvalue方法（byteValue，shortValue，intValue，longValue，floatValue，doubleValue）
public byte byteValue() {
return (byte)value;
}
public short shortValue() {
return (short)value;
}
public int intValue() {
return value;
}
public long longValue() {
return (long)value;
}
public float floatValue() {
return (float)value;
}
public double doubleValue() {
return (double)value;
}複製程式碼其實就是轉換成對應的型別
hashCode方法
public int hashCode() {
return value;
}複製程式碼就是返回int型別的值
equals方法
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
複製程式碼比較是否相同之前會將int型別通過valueof轉換成Integer型別，equals本質就是值得比較
compare方法
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}複製程式碼x小於y則返回-1，相等則返回0，否則返回1。
bitCount方法
public static int bitCount(int i) {
// HD, Figure 5-2
i = i - ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i + (i >>> 4)) & 0x0f0f0f0f;
i = i + (i >>> 8);
i = i + (i >>> 16);
return i & 0x3f;
}
複製程式碼這些都是移位和加減操作。
0x55555555等於01010101010101010101010101010101，0x33333333等於110011001100110011001100110011，0x0f0f0f0f等於1111000011110000111100001111。
先每兩位一組統計看有多少個1，比如10011111則每兩位有1、1、2、2個1，記為01011010，然後再算每四位一組看有多少個1，而01011010則每四位有2、4個1，記為00100100， 接著每八位一組就為00000110，接著16位，32位，最終在與0x3f進行與運算，得到的數即為1的個數。
highestOneBit方法
public static int highestOneBit(int i) {
// HD, Figure 3-1
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
return i - (i >>> 1);
}
// 隨便一個例子，不用管最高位之後有多少個1，都會被覆蓋
// 00010000 00000000 00000000 00000000 raw
// 00011000 00000000 00000000 00000000 i | (i >> 1)
// 00011110 00000000 00000000 00000000 i | (i >> 2)
// 00011111 11100000 00000000 00000000 i | (i >> 4)
// 00011111 11111111 11100000 00000000 i | (i >> 8)
// 00011111 11111111 11111111 11111111 i | (i >> 16)
// 00010000 0000000 00000000 00000000 i - (i >>>1)複製程式碼這個方法是返回最高位的1，其他都是0的值。將i右移一位再或操作，則最高位1的右邊也為1了，接著再右移兩位並或操作，則右邊1+2=3位都為1了，接著1+2+4=7位都為1，直到1+2+4+8+16=31都為1，最後用i - (i >>> 1)自然得到最終結果。
lowestOneBit方法
public static int lowestOneBit(int i) {
// HD, Section 2-1
return i & -i;
}
// 例子
// 00001000 10000100 10001001 00101000 i
// 11110111 01111011 01110110 11011000 -i
// 00000000 00000000 00000000 00001000 i & -i
複製程式碼與highestOneBit方法對應，lowestOneBit獲取最低位1，其他全為0的值。這個操作較簡單，先取負數，這個過程需要對正數的i取反碼然後再加1，得到的結果和i進行與操作，剛好就是最低位1其他為0的值了。
numberOfLeadingZeros方法
public static int numberOfLeadingZeros(int i) {
// HD, Figure 5-6
if (i == 0)
return 32;
int n = 1;
if (i >>> 16 == 0) { n += 16; i <<= 16; }
if (i >>> 24 == 0) { n += 8; i <<= 8; }
if (i >>> 28 == 0) { n += 4; i <<= 4; }
if (i >>> 30 == 0) { n += 2; i <<= 2; }
n -= i >>> 31;
return n;
}
// 方法很巧妙， 類似於二分法。不斷將數字左移縮小範圍。例子用最差情況：
// i: 00000000 00000000 00000000 00000001 n = 1
// i: 00000000 00000001 00000000 00000000 n = 17
// i: 00000001 00000000 00000000 00000000 n = 25
// i: 00010000 00000000 00000000 00000000 n = 29
// i: 01000000 00000000 00000000 00000000 n = 31
// i >>>31 == 0
// return 31
複製程式碼該方法返回i的二進位制從頭開始有多少個0。i為0的話則有32個0。這裡處理其實是體現了二分查詢思想的，先看高16位是否為0，是的話則至少有16個0，否則左移16位繼續往下判斷，接著右移24位看是不是為0，是的話則至少有16+8=24個0，直到最後得到結果。
numberOfTrailingZeros方法
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);
}
// 與求開頭多少個0類似，也是用了二分法，先鎖定1/2, 再鎖定1/4，1/8，1/16，1/32。
// i: 11111111 11111111 11111111 11111111 n: 31
// i: 11111111 11111111 00000000 00000000 n: 15
// i: 11111111 00000000 00000000 00000000 n: 7
// i: 11110000 00000000 00000000 00000000 n: 3
// i: 11000000 00000000 00000000 00000000 n: 1
// i: 10000000 00000000 00000000 00000000 n: 0複製程式碼與前面的numberOfLeadingZeros方法對應，該方法返回i的二進位制從尾開始有多少個0。它的思想和前面的類似，也是基於二分查詢思想，詳細步驟不再贅述。
reverse方法
public static int reverse(int i) {
i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
i = (i << 24) | ((i & 0xff00) << 8) |
((i >>> 8) & 0xff00) | (i >>> 24);
return i;
}複製程式碼該方法即是將i進行反轉，反轉就是第1位與第32位對調，第二位與第31位對調，以此類推。它的核心思想是先將相鄰兩位進行對換，比如10100111對換01011011，接著再將相鄰四位進行對換，對換後為10101101，接著將相鄰八位進行對換，最後把32位中中間的16位對換，然後最高8位再和最低8位對換。
toHexString和toOctalString方法
public static String toHexString(int i) {
return toUnsignedString0(i, 4);
}
public static String toOctalString(int i) {
return toUnsignedString0(i, 3);
}
private static String toUnsignedString0(int val, int shift) {
int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
int chars = Math.max(((mag + (shift - 1)) / shift), 1);
char[] buf = new char[chars];
formatUnsignedInt(val, shift, buf, 0, chars);
return new String(buf, true);
}
static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
int charPos = len;
int radix = 1 << shift;
int mask = radix - 1;
do {
buf[offset + --charPos] = Integer.digits[val & mask];
val >>>= shift;
} while (val != 0 && charPos > 0);
return charPos;
}複製程式碼這兩個方法類似，合到一起講。看名字就知道轉成8進位制和16進位制的字串。可以看到都是間接呼叫toUnsignedString0方法，該方法會先計算轉換成對應進位制需要的字元數，然後再通過formatUnsignedInt方法來填充字元陣列，該方法做的事情就是使用進位制之間的轉換方法（前面有提到過）來獲取對應的字元。
參考出處：https://juejin.im/post/5992b1986fb9a03c3223ce32