我們知道Java引入包裝類型(Wrapper Types)是為了解決基本類型的實例化問題，以便讓一個基本類型也能參與到面向對象的編程世界中。而在Java5中泛型更是對基本類型說了"不"，如果把一個整型放入List中，就必須使用Integer包裝類型。我們看一段代碼：
1 import java.util.ArrayList;
2 import java.util.List;
3
4 public class Client26 {
5
6 public static int testMethod(List<Integer> list) {
7 int count = 0;
8 for (int i : list) {
9 count += i;
10 }
11 return count;
12 }
13
14 public static void main(String[] args) {
15 List<Integer> list = new ArrayList<Integer>();
16 list.add(1);
17 list.add(2);
18 list.add(null);
19 System.out.println(testMethod(list));
20 }
21 }
testMethod接收一個元素是整型的List參數，計算所有元素之和，這在統計和項目中很常見，然後編寫一個測試testMethod，在main方法中把1、2和空值都放到List中，然後調用方法計算，現在思考一下會不會報錯。應該不會吧，基本類型和包裝類型都是可以通過自動裝箱（Autoboxing）和自動拆箱(AutoUnboxing)自由轉換的，null應該可以轉換為0吧，真的是這樣嗎？運行之後的結果是： Exception in thread "main" java.lang.NullPointerException 運行失敗，報空指針異常，我們稍稍思考一下很快就知道原因了：在程序for循環中，隱含了一個拆箱過程，在此過程中包裝類型轉換為了基本類型。我們知道拆箱過程是通過調用包裝對象的intValue方法來實現的，由於包裝類型為null，訪問其intValue方法報空指針異常就在所難免了。問題清楚了，修改也很簡單，加入null值檢查即可，代碼如下：
public static int testMethod(List<Integer> list) {
int count = 0;
for (Integer i : list) {
count += (i != null) ? i : 0;
}
return count;
}
上面以Integer和int為例說明了拆箱問題，其它7個包裝對象的拆箱過程也存在著同樣的問題。包裝對象和拆箱對象可以自由轉換，這不假，但是要剔除null值，null值並不能轉換為基本類型。對於此問題，我們謹記一點：包裝類型參與運算時，要做null值校驗。
基本類型是可以比較大小的，其所對應的包裝類型都實現了Comparable接口，也說明了此問題，那我們來比較一下兩個包裝類型的大小，代碼如下：
1 public class Client27 {
2 public static void main(String[] args) {
3 Integer i = new Integer(100);
4 Integer j = new Integer(100);
5 compare(i, j);
6 }
7
8 public static void compare(Integer i, Integer j) {
9 System.out.println(i == j);
10 System.out.println(i > j);
11 System.out.println(i < j);
12
13 }
14 }
代碼很簡單，產生了兩個Integer對象，然後比較兩個的大小關系，既然包裝類型和基本類型是可以自由轉換的，那上面的代碼是不是就可以打印出兩個相等的值呢？讓事實說話，運行結果如下：
false false false
竟然是3個false，也就是說兩個值之間不相等，也沒大小關系，這個也太奇怪了吧。不奇怪，我們來一 一解釋：
問題清楚了，修改總是比較容易的，直接使用Integer的實例compareTo方法即可，但是這類問題的產生更應該說是習慣問題，只要是兩個對象之間的比較就應該采用相應的方法，而不是通過Java的默認機制來處理，除非你確定對此非常了解。
上一個建議我們解釋了包裝對象的比較問題，本建議將繼續深入討論相關問題，首先看看如下代碼：
1 import java.util.Scanner;
2
3 public class Client28 {
4 public static void main(String[] args) {
5 Scanner input = new Scanner(System.in);
6 while (input.hasNextInt()) {
7 int tempInt = input.nextInt();
8 System.out.println("\n=====" + tempInt + " 的相等判斷=====");
9 // 兩個通過new產生的對象
10 Integer i = new Integer(tempInt);
11 Integer j = new Integer(tempInt);
12 System.out.println(" new 產生的對象：" + (i == j));
13 // 基本類型轉換為包裝類型後比較
14 i = tempInt;
15 j = tempInt;
16 System.out.println(" 基本類型轉換的對象：" + (i == j));
17 // 通過靜態方法生成一個實例
18 i = Integer.valueOf(tempInt);
19 j = Integer.valueOf(tempInt);
20 System.out.println(" valueOf產生的對象：" + (i == j));
21 }
22 }
23 }
輸入多個數字，然後按照3中不同的方式產生Integer對象，判斷其是否相等，注意這裡使用了"=="，這說明判斷的不是同一個對象。我們輸入三個數字127、128、555，結果如下：
127
=====127 的相等判斷=====
new 產生的對象：false
基本類型轉換的對象：true
valueOf產生的對象：true
128
=====128 的相等判斷=====
new 產生的對象：false
基本類型轉換的對象：false
valueOf產生的對象：false
555
=====555 的相等判斷=====
new 產生的對象：false
基本類型轉換的對象：false
valueOf產生的對象：false
很不可思議呀，數字127的比較結果竟然和其它兩個數字不同，它的裝箱動作所產生的對象竟然是同一個對象，valueOf產生的也是同一個對象，但是大於127的數字和128和555的比較過程中產生的卻不是同一個對象，這是為什麼？我們來一個一個解釋。
(1)、new產生的Integer對象
new聲明的就是要生成一個新的對象，沒二話，這是兩個對象，地址肯定不等，比較結果為false。
(2)、裝箱生成的對象
對於這一點，首先要說明的是裝箱動作是通過valueOf方法實現的，也就是說後兩個算法相同的，那結果肯定也是一樣的，現在問題是：valueOf是如何生成對象的呢？我們來閱讀以下Integer.valueOf的源碼：
1 /**
2 * Returns an {@code Integer} instance representing the specified
3 * {@code int} value. If a new {@code Integer} instance is not
4 * required, this method should generally be used in preference to
5 * the constructor {@link #Integer(int)}, as this method is likely
6 * to yield significantly better space and time performance by
7 * caching frequently requested values.
8 *
9 * This method will always cache values in the range -128 to 127,
10 * inclusive, and may cache other values outside of this range.
11 *
12 * @param i an {@code int} value.
13 * @return an {@code Integer} instance representing {@code i}.
14 * @since 1.5
15 */
16 public static Integer valueOf(int i) {
17 assert IntegerCache.high >= 127;
18 if (i >= IntegerCache.low && i <= IntegerCache.high)
19 return IntegerCache.cache[i + (-IntegerCache.low)];
20 return new Integer(i);
21 }
這段代碼的意思已經很明了了，如果是-128到127之間的int類型轉換為Integer對象，則直接從cache數組中獲得，那cache數組裡是什麼東西，JDK7的源代碼如下：
1 /**
2 * Cache to support the object identity semantics of autoboxing for values between
3 * -128 and 127 (inclusive) as required by JLS.
4 *
5 * The cache is initialized on first usage. The size of the cache
6 * may be controlled by the -XX:AutoBoxCacheMax=<size> option.
7 * During VM initialization, java.lang.Integer.IntegerCache.high property
8 * may be set and saved in the private system properties in the
9 * sun.misc.VM class.
10 */
11
12 private static class IntegerCache {
13 static final int low = -128;
14 static final int high;
15 static final Integer cache[];
16
17 static {
18 // high value may be configured by property
19 int h = 127;
20 String integerCacheHighPropValue =
21 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
22 if (integerCacheHighPropValue != null) {
23 int i = parseInt(integerCacheHighPropValue);
24 i = Math.max(i, 127);
25 // Maximum array size is Integer.MAX_VALUE
26 h = Math.min(i, Integer.MAX_VALUE - (-low));
27 }
28 high = h;
29
30 cache = new Integer[(high - low) + 1];
31 int j = low;
32 for(int k = 0; k < cache.length; k++)
33 cache[k] = new Integer(j++);
34 }
35
36 private IntegerCache() {}
37 }
cache是IntegerCache內部類的一個靜態數組，容納的是-128到127之間的Integer對象。通過valueOf產生包裝對象時，如果int參數在-128到127之間，則直接從整型池中獲得對象，不在該范圍內的int類型則通過new生成包裝對象。
明白了這一點，要理解上面的輸出結果就迎刃而解了，127的包裝對象是直接從整型池中獲得的，不管你輸入多少次127這個數字，獲得的對象都是同一個，那地址自然是相等的。而128、555超出了整型池范圍，是通過new產生一個新的對象，地址不同，當然也就不相等了。
以上的理解也是整型池的原理，整型池的存在不僅僅提高了系統性能，同時也節約了內存空間，這也是我們使用整型池的原因，也就是在聲明包裝對象的時候使用valueOf生成，而不是通過構造函數來生成的原因。順便提醒大家，在判斷對象是否相等的時候，最好使用equals方法，避免使用"=="產生非預期效果。
注意：通過包裝類型的valueOf生成的包裝實例可以顯著提高空間和時間性能。
包裝類型是一個類，它提供了諸如構造方法，類型轉換，比較等非常實用的功能，而且在Java5之後又實現了與基本類型的轉換，這使包裝類型如虎添翼，更是應用廣泛了，在開發中包裝類型已經隨處可見，但無論是從安全性、性能方面來說，還是從穩定性方面來說，基本類型都是首選方案。我們看一段代碼：
1 public class Client29 {
2 public static void main(String[] args) {
3 Client29 c = new Client29();
4 int i = 140;
5 // 分別傳遞int類型和Integer類型
6 c.testMethod(i);
7 c.testMethod(new Integer(i));
8 }
9
10 public void testMethod(long a) {
11 System.out.println(" 基本類型的方法被調用");
12 }
13
14 public void testMethod(Long a) {
15 System.out.println(" 包裝類型的方法被調用");
16 }
17 }
在上面的程序中首先聲明了一個int變量i，然後加寬轉變成long型，再調用testMethod()方法,分別傳遞int和long的基本類型和包裝類型，諸位想想該程序是否能夠編譯？如果能編譯，輸出結果又是什麼呢？
首先，這段程序絕對是能夠編譯的。不過，說不能編譯的同學還是動了一番腦筋的，你可能猜測以下這些地方不能編譯：
(1)、testMethod方法重載問題。定義的兩個testMethod()方法實現了重載，一個形參是基本類型，一個形參是包裝類型，這類重載很正常。雖然基本類型和包裝類型有自動裝箱、自動拆箱功能，但並不影響它們的重載，自動拆箱(裝箱)只有在賦值時才會發生，和編譯重載沒有關系。
(2)、c.testMethod(i) 報錯。i 是int類型，傳遞到testMethod(long a)是沒有任何問題的，編譯器會自動把 i 的類型加寬，並將其轉變為long型，這是基本類型的轉換法則，也沒有任何問題。
(3)、c.testMethod(new Integer(i))報錯。代碼中沒有testMethod(Integer i)方法，不可能接收一個Integer類型的參數，而且Integer和Long兩個包裝類型是兄弟關系，不是繼承關系，那就是說肯定編譯失敗了？不，編譯時成功的，稍後再解釋為什麼這裡編譯成功。
既然編譯通過了，我們看一下輸出：
基本類型的方法被調用
基本類型的方法被調用
c.testMethod(i)的輸出是正常的，我們已經解釋過了，那第二個輸出就讓人困惑了，為什麼會調用testMethod（long a）方法呢？這是因為自動裝箱有一個重要原則：基本類型可以先加寬，再轉變成寬類型的包裝類型，但不能直接轉變成寬類型的包裝類型。這句話比較拗口，簡單的說就是，int可以加寬轉變成long，然後再轉變成Long對象，但不能直接轉變成包裝類型，注意這裡指的都是自動轉換，不是通過構造函數生成，為了解釋這個原則，我們再來看一個例子：
1 public class Client29 {
2 public static void main(String[] args) {
3 Client29 c = new Client29();
4 int i = 140;
5 c.testMethod(i);
6 }
7
8 public void testMethod(Long a) {
9 System.out.println(" 包裝類型的方法被調用");
10 }
11 }
這段程序的編譯是不通過的，因為i是一個int類型，不能自動轉變為Long型，但是修改成以下代碼就可以通過了：
int i = 140; long a =（long）i； c.testMethod(a);
這就是int先加寬轉變成為long型，然後自動轉換成Long型，規則說明了，我們繼續來看testMethod(Integer.valueOf(i))是如何調用的，Integer.valueOf(i)返回的是一個Integer對象，這沒錯，但是Integer和int是可以互相轉換的。沒有testMethod(Integer i)方法？沒關系，編譯器會嘗試轉換成int類型的實參調用，Ok，這次成功了，與testMethod（i）相同了，於是乎被加寬轉變成long型---結果也很明顯了。整個testMethod(Integer.valueOf(i))的執行過程是這樣的：
(1)、i 通過valueOf方法包裝成一個Integer對象
(2)、由於沒有testMethod(Integer i)方法，編譯器會"聰明"的把Integer對象轉換成int。
(3)、int自動拓寬為long，編譯結束
使用包裝類型確實有方便的方法，但是也引起一些不必要的困惑，比如我們這個例子，如果testMethod()的兩個重載方法使用的是基本類型，而且實參也是基本類型，就不會產生以上問題，而且程序的可讀性更強。自動裝箱(拆箱)雖然很方便，但引起的問題也非常嚴重，我們甚至都不知道執行的是哪個方法。
注意：重申，基本類型優先考慮。
隨機數用的地方比較多，比如加密，混淆計算，我們使用隨機數期望獲得一個唯一的、不可仿造的數字，以避免產生相同的業務數據造成混亂。在Java項目中通常是通過Math.random方法和Random類來獲得隨機數的，我們來看一段代碼：
1 import java.util.Random;
2
3 public class Client30 {
4 public static void main(String[] args) {
5 Random r = new Random();
6 for(int i=1; i<=4; i++){
7 System.out.println("第"+i+"次:"+r.nextInt());
8
9 }
10 }
11 }
代碼很簡單，我們一般都是這樣獲得隨機數的，運行此程序可知，三次打印，的隨機數都不相同，即使多次運行結果也不同，這也正是我們想要隨機數的原因，我們再來看看下面的程序：
1 public class Client30 {
2 public static void main(String[] args) {
3 Random r = new Random(1000);
4 for(int i=1; i<=4; i++){
5 System.out.println("第"+i+"次:"+r.nextInt());
6
7 }
8 }
9 }
上面使用了Random的有參構造，運行結果如下：
第1次:-1244746321
第2次:1060493871
第3次:-1826063944
第4次:1976922248
計算機不同輸出的隨機數也不同，但是有一點是相同的：在同一台機器上，甭管運行多少次，所打印的隨機數都是相同的，也就是說第一次運行，會打印出這幾個隨機數，第二次運行還是打印出這三個隨機數，只要是在同一台機器上，就永遠都會打印出相同的隨機數，似乎隨機數不隨機了，問題何在？
那是因為產生的隨機數的種子被固定了，在Java中，隨機數的產生取決於種子，隨機數和種子之間的關系遵從以下兩個原則：
看完上面兩個規則，我們再來看這個例子，會發現問題就出在有參構造上，Random類的默認種子(無參構造)是System.nonoTime()的返回值(JDK1.5版本以前默認種子是System.currentTimeMillis()的返回值)，注意這個值是距離某一個固定時間點的納秒數，不同的操作系統和硬件有不同的固定時間點，也就是說不同的操作系統其納秒值是不同的，而同一個操作系統納秒值也會不同，隨機數自然也就不同了.(順便說下，System.nonoTime不能用於計算日期，那是因為"固定"的時間是不確定的，納秒值甚至可能是負值，這點與System.currentTiemMillis不同)。
new Random(1000)顯示的設置了隨機種子為1000，運行多次，雖然實例不同，但都會獲得相同的四個隨機數，所以，除非必要，否則不要設置隨機種子。
順便提一下，在Java中有兩種方法可以獲得不同的隨機數：通過，java.util.Random類獲得隨機數的原理和Math.random方法相同，Math.random方法也是通過生成一個Random類的實例，然後委托nextDouble()方法的，兩者殊途同歸，沒有差別。
注意：若非必要，不要設置隨機數種子。
