天天看點
傳回

Java中的自動拆裝箱（轉）

出處： 一文讀懂什麼是Java中的自動拆裝箱

本文主要介紹Java中的自動拆箱與自動裝箱的有關知識。

 基本資料類型

基本類型，或者叫做内置類型，是Java中不同于類(Class)的特殊類型。它們是我們程式設計中使用最頻繁的類型。

Java是一種強類型語言，第一次申明變量必須說明資料類型，第一次變量指派稱為變量的初始化。

Java基本類型共有八種，基本類型可以分為三類：

字元類型 

char

 布爾類型 

boolean

 整數類型 

byte

 、

short

int

long

 浮點數類型 

float

double

。

Java中的數值類型不存在無符号的，它們的取值範圍是固定的，不會随着機器硬體環境或者作業系統的改變而改變。

實際上，Java中還存在另外一種基本類型

void

 ，它也有對應的包裝類 

java.lang.Void

 ，不過我們無法直接對它們進行操作。

基本資料類型有什麼好處

我們都知道在Java語言中，

new

一個對象是存儲在堆裡的，我們通過棧中的引用來使用這些對象；是以，對象本身來說是比較消耗資源的。

對于經常用到的類型，如int等，如果我們每次使用這種變量的時候都需要new一個Java對象的話，就會比較笨重。

是以，和C++一樣，Java提供了基本資料類型，這種資料的變量不需要使用new建立，他們不會在堆上建立，而是直接在棧記憶體中存儲，是以會更加高效。

整型的取值範圍

Java中的整型主要包含

byte

short

int

和

long

這四種，表示的數字範圍也是從小到大的，之是以表示範圍不同主要和他們存儲資料時所占的位元組數有關。

先來個簡答的科普，1位元組=8位（bit）。java中的整型屬于有符号數。

先來看計算中8bit可以表示的數字：

最小值：10000000 （-128）(-2^7)
最大值：01111111（127）(2^7-1)

整型的這幾個類型中，

  • byte：byte用1個位元組來存儲，範圍為-128(-2^7)到127(2^7-1)，在變量初始化的時候，byte類型的預設值為0。
  • short：short用2個位元組存儲，範圍為-32,768 (-2^15)到32,767 (2^15-1)，在變量初始化的時候，short類型的預設值為0，一般情況下，因為Java本身轉型的原因，可以直接寫為0。
  • int：int用4個位元組存儲，範圍為-2,147,483,648 (-2^31)到2,147,483,647 (2^31-1)，在變量初始化的時候，int類型的預設值為0。
  • long：long用8個位元組存儲，範圍為-9,223,372,036,854,775,808 (-2^63)到9,223,372,036, 854,775,807 (2^63-1)，在變量初始化的時候，long類型的預設值為0L或0l，也可直接寫為0。

超出範圍怎麼辦

上面說過了，整型中，每個類型都有一定的表示範圍，但是，在程式中有些計算會導緻超出表示範圍，即溢出。如以下代碼：

int i = Integer.MAX_VALUE;
int j = Integer.MAX_VALUE;

int k = i + j;
System.out.println("i (" + i + ") + j (" + j + ") = k (" + k + ")");

輸出結果：i (2147483647) + j (2147483647) = k (-2)

這就是發生了溢出，溢出的時候并不會抛異常，也沒有任何提示。是以，在程式中，使用同類型的資料進行運算的時候，一定要注意資料溢出的問題。

包裝類型

Java語言是一個面向對象的語言，但是Java中的基本資料類型卻是不面向對象的，這在實際使用時存在很多的不便，為了解決這個不足，在設計類時為每個基本資料類型設計了一個對應的類進行代表，這樣八個和基本資料類型對應的類統稱為包裝類(Wrapper Class)。

包裝類均位于java.lang包，包裝類和基本資料類型的對應關系如下表所示

Java中的自動拆裝箱（轉）

在這八個類名中，除了Integer和Character類以後，其它六個類的類名和基本資料類型一緻，隻是類名的第一個字母大寫即可。

為什麼需要包裝類

很多人會有疑問，既然Java中為了提高效率，提供了八種基本資料類型，為什麼還要提供包裝類呢？

這個問題，其實前面已經有了答案，因為Java是一種面向對象語言，很多地方都需要使用對象而不是基本資料類型。比如，在集合類中，我們是無法将int 、double等類型放進去的。因為集合的容器要求元素是Object類型。

為了讓基本類型也具有對象的特征，就出現了包裝類型，它相當于将基本類型“包裝起來”，使得它具有了對象的性質，并且為其添加了屬性和方法，豐富了基本類型的操作。

拆箱與裝箱

那麼，有了基本資料類型和包裝類，肯定有些時候要在他們之間進行轉換。比如把一個基本資料類型的int轉換成一個包裝類型的Integer對象。

我們認為包裝類是對基本類型的包裝，是以，把基本資料類型轉換成包裝類的過程就是打包裝，英文對應于boxing，中文翻譯為裝箱。

反之，把包裝類轉換成基本資料類型的過程就是拆包裝，英文對應于unboxing，中文翻譯為拆箱。

在Java SE5之前，要進行裝箱，可以通過以下代碼：

Integer i = new Integer(10);

自動拆箱與自動裝箱

在Java SE5中，為了減少開發人員的工作，Java提供了自動拆箱與自動裝箱功能。

自動裝箱: 就是将基本資料類型自動轉換成對應的包裝類。

自動拆箱：就是将包裝類自動轉換成對應的基本資料類型。

Integer i =10;  //自動裝箱
int b= i;     //自動拆箱

Integer i=10

 可以替代 

Integer i = new Integer(10);

，這就是因為Java幫我們提供了自動裝箱的功能，不需要開發者手動去new一個Integer對象。

自動裝箱與自動拆箱的實作原理

既然Java提供了自動拆裝箱的能力，那麼，我們就來看一下，到底是什麼原理，Java是如何實作的自動拆裝箱功能。

我們有以下自動拆裝箱的代碼：

public static  void main(String[]args){
    Integer integer=1; //裝箱
    int i=integer; //拆箱
}

對以上代碼進行反編譯後可以得到以下代碼：

public static  void main(String[]args){
    Integer integer=Integer.valueOf(1); 
    int i=integer.intValue(); 
}

從上面反編譯後的代碼可以看出，int的自動裝箱都是通過

Integer.valueOf()

方法來實作的，Integer的自動拆箱都是通過

integer.intValue

來實作的。如果讀者感興趣，可以試着将八種類型都反編譯一遍 ，你會發現以下規律：

自動裝箱都是通過包裝類的

valueOf()

 方法來實作的.自動拆箱都是通過包裝類對象的

xxxValue()

 來實作的。

哪些地方會自動拆裝箱

我們了解過原理之後，在來看一下，什麼情況下，Java會幫我們進行自動拆裝箱。前面提到的變量的初始化和指派的場景就不介紹了，那是最簡單的也最容易了解的。

我們主要來看一下，那些可能被忽略的場景。

場景一、将基本資料類型放入集合類

我們知道，Java中的集合類隻能接收對象類型，那麼以下代碼為什麼會不報錯呢？

List<Integer> li = new ArrayList<>();
for (int i = 1; i < 50; i ++){
    li.add(i);
}

将上面代碼進行反編譯，可以得到以下代碼：

List<Integer> li = new ArrayList<>();
for (int i = 1; i < 50; i += 2){
    li.add(Integer.valueOf(i));
}

以上，我們可以得出結論，當我們把基本資料類型放入集合類中的時候，會進行自動裝箱。

場景二、包裝類型和基本類型的大小比較

有沒有人想過，當我們對Integer對象與基本類型進行大小比較的時候，實際上比較的是什麼内容呢？看以下代碼：

Integer a=1;
System.out.println(a==1?"等于":"不等于");
Boolean bool=false;
System.out.println(bool?"真":"假");

對以上代碼進行反編譯，得到以下代碼：

Integer a=1;
System.out.println(a.intValue()==1?"等于":"不等于");
Boolean bool=false;
System.out.println(bool.booleanValue?"真":"假");

可以看到，包裝類與基本資料類型進行比較運算，是先将包裝類進行拆箱成基本資料類型，然後進行比較的。

場景三、包裝類型的運算

有沒有人想過，當我們對Integer對象進行四則運算的時候，是如何進行的呢？看以下代碼：

Integer i = 10;
Integer j = 20;

System.out.println(i+j);

反編譯後代碼如下：

Integer i = Integer.valueOf(10);
Integer j = Integer.valueOf(20);
System.out.println(i.intValue() + j.intValue());

我們發現，兩個包裝類型之間的運算，會被自動拆箱成基本類型進行。

場景四、三目運算符的使用

這是很多人不知道的一個場景，作者也是一次線上的血淋淋的Bug發生後才了解到的一種案例。看一個簡單的三目運算符的代碼：

boolean flag = true;
Integer i = 0;
int j = 1;
int k = flag ? i : j;

很多人不知道，其實在

int k = flag ? i : j;

這一行，會發生自動拆箱。反編譯後代碼如下：

boolean flag = true;
Integer i = Integer.valueOf(0);
int j = 1;
int k = flag ? i.intValue() : j;

這其實是三目運算符的文法規範：當第二，第三位操作數分别為基本類型和對象時，其中的對象就會拆箱為基本類型進行操作。

因為例子中，

flag ? i : j;

片段中，第二段的i是一個包裝類型的對象，而第三段的j是一個基本類型，是以會對包裝類進行自動拆箱。如果這個時候i的值為

null

，那麼久會發生NPE。（自動拆箱導緻空指針異常）

場景五、函數參數與傳回值

這個比較容易了解，直接上代碼了：

//自動拆箱
public int getNum1(Integer num) {
 return num;
}
//自動裝箱
public Integer getNum2(int num) {
 return num;
}

自動拆裝箱與緩存

Java SE的自動拆裝箱還提供了一個和緩存有關的功能，我們先來看以下代碼，猜測一下輸出結果：

public static void main(String... strings) {

    Integer integer1 = 3;
    Integer integer2 = 3;

    if (integer1 == integer2)
        System.out.println("integer1 == integer2");
    else
        System.out.println("integer1 != integer2");

    Integer integer3 = 300;
    Integer integer4 = 300;

    if (integer3 == integer4)
        System.out.println("integer3 == integer4");
    else
        System.out.println("integer3 != integer4");

}

我們普遍認為上面的兩個判斷的結果都是false。雖然比較的值是相等的，但是由于比較的是對象，而對象的引用不一樣，是以會認為兩個if判斷都是false的。

在Java中，==比較的是對象應用，而equals比較的是值。

是以，在這個例子中，不同的對象有不同的引用，是以在進行比較的時候都将傳回false。奇怪的是，這裡兩個類似的if條件判斷傳回不同的布爾值。

上面這段代碼真正的輸出結果：

integer1 == integer2
integer3 != integer4

原因就和Integer中的緩存機制有關。在Java 5中，在Integer的操作上引入了一個新功能來節省記憶體和提高性能。整型對象通過使用相同的對象引用實作了緩存和重用。

适用于整數值區間-128 至 +127。

隻适用于自動裝箱。使用構造函數建立對象不适用。

具體的代碼實作可以閱讀Java中整型的緩存機制一文，這裡不再闡述。

我們隻需要知道，當需要進行自動裝箱時，如果數字在-128至127之間時，會直接使用緩存中的對象，而不是重新建立一個對象。

其中的javadoc詳細的說明了緩存支援-128到127之間的自動裝箱過程。最大值127可以通過

-XX:AutoBoxCacheMax=size

修改。

實際上這個功能在Java 5中引入的時候,範圍是固定的-128 至 +127。後來在Java 6中，可以通過

java.lang.Integer.IntegerCache.high

設定最大值。

這使我們可以根據應用程式的實際情況靈活地調整來提高性能。到底是什麼原因選擇這個-128到127範圍呢？因為這個範圍的數字是最被廣泛使用的。 在程式中，第一次使用Integer的時候也需要一定的額外時間來初始化這個緩存。

在Boxing Conversion部分的Java語言規範(JLS)規定如下：

如果一個變量p的值是：

-128至127之間的整數(§3.10.1)

true 和 false的布爾值 (§3.10.3)

‘\u0000’至 ‘\u007f’之間的字元(§3.10.4)

範圍内的時，将p包裝成a和b兩個對象時，可以直接使用a==b判斷a和b的值是否相等。

自動拆裝箱帶來的問題

當然，自動拆裝箱是一個很好的功能，大大節省了開發人員的精力，不再需要關心到底什麼時候需要拆裝箱。但是，他也會引入一些問題。

包裝對象的數值比較，不能簡單的使用

==

 ，雖然-128到127之間的數字可以，但是這個範圍之外還是需要使用

equals

比較。

前面提到，有些場景會進行自動拆裝箱，同時也說過，由于自動拆箱，如果包裝類對象為null，那麼自動拆箱時就有可能抛出NPE。

如果一個for循環中有大量拆裝箱操作，會浪費很多資源。

組合繼承 原型鍊
上一篇: java線程池實作原理
下一篇: InvokeRequired和Invoke

繼續閱讀