深入理解Java之裝箱與拆箱
作者：佚名
在說裝箱與拆箱之前，先說一下Java的基本數據類型，Java從數據類型上可以劃分為值類型與引用類型。
一、Java數據類型
1、在說裝箱與拆箱之前，先說一下Java的基本數據類型，Java從數據類型上可以劃分為值類型與引用類型，值類型是四類八種，分別是：
- 整數型：byte̵，short̵，int̵，long
- 浮點型：float，double
- 字符型：char
- 布爾型：boolean
| 數據類型 | 內存 | 默認值 | 包裝類 |
|---|---|---|---|
| byte | 8位 | 0 | Byte |
| short | 16位 | 0 | short |
| int | 32位 | 0 | Integer |
| long | 64位 | 0L或0l | Long |
| float | 32位 | 0.0F或0.0f | Float |
| double | 64位 | 0.0D或0.0d | Double |
| char | 16位 | \u0000 | Character |
| boolean | 8位 | flase | Boolean |
2、引用類型：
- 數組
- 類（class）
- 接口（Interface）
- 枚舉（enum）
3、值類型與引用類型的區別
1. 從概念方面上來說：
- 值類型：變量名指向具體的值
- 引用類型：變量名指向數據對象的內存地址
2. 從內存構建方面上來說：
- 值類型：變量在聲明之后，Java就會立刻分配給它內存空間
- 引用類型：它以特殊的方式（類似C指針）指向對象實體，這類變量聲明時不會分配內存，只是存儲
3. 從使用方面上來說：
- 值類型：使用時需要賦具體值，判斷時用 ” == “號
- 引用類型：使用時可以賦null，判斷時使用 equals 方法
二、Java數據類型轉換
1、自動轉換
- 定義：程序在執行過程中“悄然”進行的轉換，不需要用戶提前聲明，一般是從位數低的類型向位數高的類型轉換
- 優先關系：按從低到高的順序轉換。不同類型數據間的優先 關系如下：
- 低--------------------------------------------->高
- byte,short,char-> int -> long -> float -> double
- 轉換規則：
運算中，不同類型的數據先轉化為同一類型，然后進行運算
| 操作數1類型 | 操作數2類型 | 轉換后的類型 |
|---|---|---|
| byte、short、char | int | int |
| byte、short、char、int | long | long |
| byte、short、char、int、long | float | float |
| byte、short、char、int、long、float | double | double |
2、強制轉換
- 定義：強制類型轉換則必須在代碼中聲明，轉換順序不受限制
- 格式：在需要轉型的數據前加上“( )”，然后在括號內加入需要轉化的數據類型
- 結果：精度可能會丟失，也可能更加精確
- int x;
- double y;
- x = (int)3.14 + (int)5.20 //精度丟失
- y = (double)x + (double)8 //精度提升
- 輸出：x = 8;y = 16.0
三、Java之裝箱與拆箱
1、包裝類
- Java是面向對象語言，號稱萬事萬物皆對象，因此，8種基本數據類型有了對應的類，這就是包裝類
2、什么是裝箱與拆箱
- 裝箱：將值類型裝換成引用類型的過程
- 拆箱：將引用類型轉換成值類型的過程
- 自動裝箱：
- int x = 3;
- Integer y = x; //int --> Integer，Integer y = x <==> Integer y = Integer.valueOf(x)
- 自動拆箱：
- Integer x = new Integer(5);
- int y = x; //Integer --> int，int y = x <==> int y = x.intValue()
3、裝箱和拆箱是如何實現的
- 裝箱過程是通過調用包裝器的valueOf方法實現的
- 拆箱過程是通過調用包裝器的 xxxValue方法實現的。（xxx代表對應的基本數據類型）
4、注意點：
- 大量使用自動拆裝箱會使性能降低，還會造成大量的內存消耗
- 在重載方法中，可能出現問題
- List<Integer> list = new ArrayList<>();
- Integer x,y,z;
- x = 1;y = 2;z = 4;
- list.add(x);list.add(y);list.add(z);
- list.remove(2);
在上面這段代碼中ArrayList.remove方法有兩個重載方法，那么list.remove(2)是調用了哪個方法，remove掉的是值為2的對象，還是remove了index為2，值為4的那個對象呢？
在這種情況下，編譯器不會進行自動拆裝箱，所以調用的是remove(int index),index為2值為4的這個Integer對象會被remove.
如果要調用 remove(Object o)的方法，應該這么寫 list.remove(y)
3. 緩存值問題
- 案例解析：
- Integer i1 = 100;
- Integer i2 = 100;
- Integer i3 = 200;
- Integer i4 = 200;
- System.out.println(i1==i2);
- System.out.println(i3==i4);
- Output: true false
- 觀察源碼：
Intteger.valueOf方法
- public static Integer valueOf(int i) {
- if (i >= IntegerCache.low && i <= IntegerCache.high)
- return IntegerCache.cache[i + (-IntegerCache.low)];
- return new Integer(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;
- 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.
- }
- }
- hhigh = 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() {}
- }
從源碼可以看出，在通過valueOf方法創建Integer對象的時候，如果數值在[-128,127]之間，便返回指向IntegerCache.cache中已經存在的對象的引用；否則創建一個新的Integer對象
- Byte、Short、Integer、Long四種包裝類默認創建了數值為[-128,127]的相應類型的緩存數據，但是超出此范圍仍會創建新的對象。
- Character默認會創建[0,127]的響應類型的緩存數據
- 兩種浮點型沒有實現常量池技術，在某個范圍內的整型數值的個數是有限的，而浮點數卻不是
| 包裝類 | 常量池 | 常量池范圍 |
|---|---|---|
| Byte | 存在 | [-128,127] |
| Short | 存在 | [-128,127] |
| Integer | 存在 | [-128,127] |
| Long | 存在 | [-128,127] |
| Character | 存在 | [0,127] |
| Float | 不存在 | 無 |
| Double | 不存在 | 無 |
- 注意點：
- 當 "=="運算符的兩個操作數都是 包裝器類型的引用，則是比較指向的是否是同一個對象，而如果其中有一個操作數是表達式（即包含算術運算）則比較的是數值（即會觸發自動拆箱的過程）
- 對于包裝器類型，equals方法并不會進行類型轉換
- 算術運算會觸發裝箱與拆箱過程
責任編輯：龐桂玉
來源：
Linux公社
