面試題：new Integer(112)和Integer.valueOf(112)的區別
面試官考察點猜想
這道題，考察的是對Integer這個對象原理的理解，關於這道題的變體有很多，我們會一一進行分析。
理解這道題，對於實際開發過程中防止出現意想不到的Bug很有用，建議大家認真思考和解讀。
背景知識詳解
關於Integer的實現
Integer是int的一個封裝類，它的構造實現如下。
/**
* The value of the {@code Integer}.
*
* @serial
*/
private final int value;
/**
* Constructs a newly allocated {@code Integer} object that
* represents the specified {@code int} value.
*
* @param value the value to be represented by the
* {@code Integer} object.
*/
public Integer(int value) {
this.value = value;
}
Integer中定義了一個int類型的value屬性。由於該屬性是final類型，因此需要通過構造方法來賦值。這個邏輯非常簡單，沒有太多要關注得。
結論： 當通過
new關鍵字構建一個Integer實例時，和所有普通對象的實例化相同，都是在堆內存地址中分配一塊空間。
Integer.valueOf
Integer.valueOf方法，是把一個字符串轉換為Integer類型，該方法定義如下
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}
這個方法調用另外一個重載方法，該方法定義如下。
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
從這段代碼中發現，如果i的值是在IntegerCache.low和IntegerCache.high這個區間范圍，則通過下面這段代碼返回Integer對象實例。
IntegerCache.cache[i+(-IntegerCache.low)];
否則，使用new Integer(i)創建一個新的實例對象。
IntegerCache是什么？
從它的命名來看，不難猜出它應該和緩存有關系，簡單猜測就是：如果i的值在某個區間范圍內，則直接從緩存中獲取對象。
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;
//high的值允許通過系統屬性來調整
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
//如果配置了high的屬性值，則取兩者中最大的一個值作為IntegerCache的最高區間值。
if (integerCacheHighPropValue != null) {
try {
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);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
//創建一個數組容器
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() {}
}
上述代碼的實現邏輯非常簡單：
- IntegerCache的取值區間為： IntegerCache.low=-128， IntegerCache.hign=127，其中
hign是可以通過系統參數來調整。 - 創建一個Integer數組，循環初始化這個區間中的每一個值。
Integer為什么這么設計？ 但凡涉及到Cache的，一定和性能有關，在Integer這個對象中，常用的數值區間是在-128到127之間，所以為了避免對這個區間范圍內的數據頻繁創建和銷毀對象，所以構建了一個緩存。意味着后續只要不是通過
new關鍵字創建的Integer實例，在這個區間內的數值都會從IntegerCache中獲取。
問題解答
面試題：new Integer(112)和Integer.valueOf(112)的區別
理解了上面的原理后，再來解答這個問題就很容易了。
-
new Integer，是創建一個Integer對象實例。 -
Integer.valueOf(112)，Integer默認提供了Cache機制，在-128到127區間范圍內的數據，通過valueOf方法不需要創建新的對象實例，只需要從緩存中獲取即可。
問題總結
Integer這個對象的變形面試題比較多，其中一個面試題比較典型。
有兩個Integer變量a,b，通過swap方法之后，交換a,b的值，請寫出swap的方法。
public class SwapExample {
public static void main(String[] args){
Integer a=1;
Integer b=2;
System.out.println("交換前：a="+a+",b="+b);
swap(a,b);
System.out.println("交換后：a="+a+",b="+b);
}
private static void swap(Integer a,Integer b){
//doSomething
}
}
基礎不是很好的同學，可能會很直接的按照”正確的邏輯“來編寫程序，可能的代碼如下。
private static void swap(Integer a,Integer b){
Integer temp=a;
a=b;
b=temp;
}
程序邏輯，理論上是沒問題，定義一個臨時變量存儲a的值，然后再對a和b進行交換。而實際運行結果如下
交換前：a=1,b=2
交換后：a=1,b=2
Integer對象的重新賦值思考
Integer作為封裝對象類型，通過函數傳遞該引用以后，理論上來說，main方法中定義的a和b，以及傳遞到swap方法中的a、和b，指向同一個內存地址，那么按照上述代碼的實現，理論上來說也是成立的。
Java中有兩種參數傳遞類型。
- 值傳遞，傳遞的是數據的副本，方法執行中形式參數值的改變不影響實際參數的值。
- 引用傳遞，傳遞的是內存地址的引用，在方法執行中，由於引用對象的地址指向同一塊內存，所以對於對象數據的修改，會影響到引用了該地址的變量。
這么設計的好處，是為了減少內存的占用，提升訪問效率和性能。
那么Integer作為封裝類型，為什么傳遞的是副本，而不是引用呢？
我們來看一下Integer中value值得定義，可以發現該屬性是final修飾，意味着是不可更改。
/**
* The value of the {@code Integer}.
*
* @serial
*/
private final int value;
結論：在Java中，只有一種參數傳遞方式，就是值傳遞。但是，當參數傳的是基本類型時，傳的是值的拷貝，對拷貝變量的修改不影響原變量；當傳的是引用類型時，傳的是引用地址的拷貝，但是拷貝的地址和真實地址指向的都是同一個真實數據，因此可以修改原變量中的值；當傳的是Integer類型時，雖然拷貝的也是引用地址，指向的是同一個數據，但是Integer的值不能被修改，因此無法修改原變量中的值。
因此，上述代碼之所以沒有交換成功，是因為傳遞到swap方法中的a和b，會創建一個變量副本，這個副本中的值雖然發生了交換，但不影響原始值。
了解了這塊知識之后，我們的問題就變成了，如何對一個修飾了final關鍵字的屬性進行數據修改。那就是通過反射來實現，實現代碼如下.
public class SwapExample {
public static void main(String[] args){
Integer a=1;
Integer b=2;
System.out.println("交換前：a="+a+",b="+b);
swap(a,b);
System.out.println("交換后：a="+a+",b="+b);
}
private static void swap(Integer a,Integer b){
try {
Field field=Integer.class.getDeclaredField("value");
Integer temp= a;
field.setAccessible(true); //針對private修飾的變量，需要通過該方法設置。
field.set(a,b);
field.set(b,temp);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
那這段代碼運行完是否能達到預期呢？ 上述程序運行結果如下：
交換前：a=1,b=2
交換后：a=2,b=2
從結果來看，確實是發生了變化，但是變化並不完整，因為b=1這個預期值並沒有出現。為什么呢？其實還是和今天分享得主題有關系，我們來逐步看一下。
Integer temp=a這個地方，基於IntegerCache的原理，這里並不會產生一個新的temp實例，意味着temp變量和a變量指向的內存地址是同一個。- 當通過
field.set方法，把a內存地址的值通過反射修改成b以后，那么此時a的值應該是2。注意：由於內存地址的值變成了2，而temp這個變量又指向該內存地址，因此temp的值自然就變成了2. - 接着使用
filed.set(b,temp)修改b屬性的值，此時temp的值時2，所以得到的結果b也變成了2.
private static void swap(Integer a,Integer b){
try {
Field field=Integer.class.getDeclaredField("value");
Integer temp= a;
field.setAccessible(true); //針對private修飾的變量，需要通過該方法設置。
field.set(a,b);
field.set(b,temp);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
理解了原理后，我們只需要修改Integer temp=a這段代碼，改成下面這種寫法。保證temp變量是一個獨立的實例。
Integer temp=new Integer(a);
修改以后運行結果如下
交換前：a=1,b=2
交換后：a=2,b=1
Mic說： 只有基本功足夠扎實，才能對任何問題的本質一眼看透，解決這些問題的時候也能得心應手。
關注[跟着Mic學架構]公眾號，獲取更多精品原創
