最近在編碼過程中，程式碼提交之後sonar報了Bug警告，引發了對java中Integer類的一些思考。程式碼如下：

public boolean verifyDimensions() {
	if (CollectionUtils.isEmpty(dimensions)) {
		return false;
	} else {
		boolean hasRightDim = false;
		
		for (DimensionInApplyDTO dim : dimensions) {
			if (dim.getIsRight() == Integer.valueOf(1)) { // 報錯位置； 注：dim.getIsRight()返回 0/1/NULL Integer物件
				hasRightDim = true;
				break;
			}
		}
		if (!hasRightDim) 
			return false;
	}
	return true;
}
 

    Bug警告：   This method compares two reference values using the == or != operator, where the correct way to compare instances of this type is generally with the equals() method. It is possible to create distinct instances that are equal but do not compare as == since they are different objects. Examples of classes which should generally not be compared by reference are java.lang.Integer, java.lang.Float, etc.

     意思就是兩個引用型別的物件進行比較，不要用“==”，要用equals()，因為"=="比較的是地址呀云云...  那為什麼這段程式碼我在測試的時候並沒有發現錯誤呢，後來看了下Integer的原始碼，結合網友大神的解答，一切都明瞭了。

Integer與int在拆箱裝箱過程中主要用到兩個方法： valueOf()  和  intValue()，下面通過具體的例子來說一下拆箱裝箱的過程~

1). intValue()： Integer --> int  拆箱

/**
 * Returns the value of this {@code Integer} as an
 * {@code int}.
 */
public int intValue() {
	return value;
}

@Test
public void test1() throws Exception {
	int i = 10;
	
	Integer j = 10;
	System.out.println(i == j);  // true
	
	Integer z = null;
	System.out.println(i == z);  // java.lang.NullPointerException
}
 

     第6行結果為true： 在Integer物件與int物件i做比較時， Integer j 物件會呼叫intValue()方法返回一個int物件， 返回的這個int物件再與i進行比較，此時兩個做比較的物件都是int物件，都為基本型別，所以“==”直接就比較值是否相等。

     第9行結果為空指標異常： z為空物件，所以呼叫一個空物件的某個方法時，會報空指標異常，我們在比較Integer與int時，注意Integer不能為null。

2). valueOf()： int --> Integer 裝箱

@Test
public void test2() throws Exception {
	
	Integer i = Integer.valueOf(127);
	Integer j = 127;
	System.out.println(i == j);  //true
	
	
	Integer x = Integer.valueOf(128);
	Integer y = 128;
	System.out.println(x == y);  //false
}

     測試程式碼第5行 j的賦值是將int物件賦值給Integer型別，此時int物件會執行自動裝箱操作，呼叫Integer的靜態方法valueOf(int i)，傳入一個int物件，返回一個Integer物件。所以第4行第5行的兩個賦值方式是沒有區別的。

     那麼為什麼兩次比較，第一次比較i，j相等，第二次比較x，y就不相等呢，別急，我們看一下Integer.valueOf(int i)的原始碼：

/**
 * Returns an {@code Integer} instance representing the specified
 * {@code int} value.  If a new {@code Integer} instance is not
 * required, this method should generally be used in preference to
 * the constructor {@link #Integer(int)}, as this method is likely
 * to yield significantly better space and time performance by
 * caching frequently requested values.
 *
 * This method will always cache values in the range -128 to 127,
 * inclusive, and may cache other values outside of this range.
 *
 * @param  i an {@code int} value.
 * @return an {@code Integer} instance representing {@code i}.
 * @since  1.5
 */
public static Integer valueOf(int i) {
	if (i >= IntegerCache.low && i <= IntegerCache.high)
		return IntegerCache.cache[i + (-IntegerCache.low)];
	return new Integer(i);
}

     程式碼中IntegerCache.low為-128， IntegerCache.high為127。 由程式碼可看出， 如果傳入的int值在-128與127之間，則呼叫了一個IntegerCache類，否則new一個新的Integer物件。

     我們都知道new出來的物件位於堆中，new多少次就有多少個不同的物件，但是IntegerCache是什麼東西呢？

/**
 * Cache to support the object identity semantics of autoboxing for values between
 * -128 and 127 (inclusive) as required by JLS.
 *
 * The cache is initialized on first usage.  // 第一次使用時進行初始化
 * The size of the cache may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 * // 陣列的大小可以通過控制虛擬機器的-XX:AutoBoxCacheMax=<size>引數來設定。
 */
private static class IntegerCache {
	static final int low = -128;
	static final int high;
	static final Integer cache[]; // 快取了一個Integer型別的陣列

	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);
				// 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這裡面封裝了一個Integer型別的陣列（程式碼12行），存放-128至127的Integer型別的物件，第一次使用時進行初始化（程式碼34行）。所以Integer.valueOf(int i)方法，在傳入i的值不在-128和127之間時，便new出一個新的Integer物件；如果範圍在-128和127之間，則直接從IntegerCache快取中取出i  對應的Integer物件。

     我們轉過頭來再看下測試程式碼：

@Test
public void testName2() throws Exception {
	
	Integer i = Integer.valueOf(127);
	Integer j = 127;
	System.out.println(i == j);  //true
	
	
	Integer x = Integer.valueOf(128);
	Integer y = 128;
	System.out.println(x == y);  //false
}

     127在-128和127之間，所以int型別的127在執行裝箱操作，呼叫valueOf方法時，取出的是IntegerCache快取的Integer物件，所以，不管來多少個127，只要是呼叫valueOf方法，返回的都是一個物件，用“==”返回true，記憶體地址也僅此一份。

     128不在-128和127之間，每次呼叫valueOf方法，都會產生一個獨一無二的Integer物件，所以用“==”返回false；但是因為兩個都是引用物件，用equals()則會返回true，因為x，y的字面值均為128。

     回到文章開頭，sonar給我的程式碼報出了一個嚴重bug，但是我自己在測試時沒有發現錯誤，

     if (dim.getIsRight() == Integer.valueOf(1)) ...

     是因為在專案邏輯中，dim.getIsRight()只可能返回 null、1、0三個情況， 返回的1也是IntegerCache中的引用物件，所以用“==”，等於1的情況下也會返回true，但是sonar不知道這種情況，提出了bug，所以說，無論什麼時候程式碼質量一定要嚴謹。

3).  parseInt()

@Test
public void testName3() throws Exception {
	
	System.out.println(Integer.parseInt("128") == Integer.valueOf(128)); // true
	
	int i = Integer.parseInt("128");
	Integer j =Integer.valueOf(128);
	System.out.println(i == j); // true
}

     上面這個例子用到了Integer的另一個方法parseInt(), 將一個物件轉換為int物件(原始碼不貼了)， parseInt()返回值是一個int物件，注意是一個int物件，不是Integer！

     所以測試程式碼中 Integer.parseInt("128") 其實就是int型別的128，第4行也就等價於 System.out.println(128 == Integer.valueOf(128));  後者呼叫valueOf方法返回一個128的Integer物件，與前面的128比較時，後者自動拆箱成為int型別的128，所以最後兩個int型別的128比較，返回true。

     關於int與Integer型別各種各樣的問題，大家如果有問題可以在評論裡發一下，在今後遇到比較好的例子或者刁鑽的面試題，我也會繼續在本文下面列出，持續更新，共同進步~