1 什么是包裝類 ??

?? 在 JAVA 中，八大基礎(chǔ)數(shù)據(jù)類型（int,float,double...）不是繼承自 Object，并且不具備對象的特征的。比如：基本數(shù)據(jù)類型就不能調(diào)用方法。

int i = 10;
i.toString();

使用這段代碼就會出錯。

?? 但是我們在開發(fā)過程中肯定會遇到，將基本數(shù)據(jù)類型轉(zhuǎn)換為String類型，或者其他數(shù)據(jù)類型，而這個時候如果我們要用基礎(chǔ)數(shù)據(jù)類型實現(xiàn)這些轉(zhuǎn)換就會非常麻煩，所以Java就有了基本數(shù)據(jù)類型的包裝類，顧名思義，包裝類就是：將基本數(shù)據(jù)類型包裝成對象，使其具有了對象的屬性和方法。
這樣就可以使用方法和屬性了。

而包裝類的主要作用也就是：

• 將本類型與其他類型進(jìn)行轉(zhuǎn)換；
• 將字符串與本類型及包裝類型相互轉(zhuǎn)換。

因此為了在泛型代碼中可以支持基本類型，并且讓基本數(shù)據(jù)類型也具備對象的特征，Java 給每個基本類型都對應(yīng) 一個包裝類型

2. 怎么使用包裝類?

首先我們來看如何定義包裝類：比如定義一個int類型的包裝類

• 定義整形包裝類

Integer i1 = new Integer(100);  //定義一個值為100的 整形包裝類
Integer i2 = 100

我們可能會有疑問，數(shù)據(jù)變成了包裝類，之后要使用數(shù)據(jù)怎么辦呢 --> 很簡單，我們在將包裝類轉(zhuǎn)換成基本數(shù)據(jù)類型就可以了

• 包裝類轉(zhuǎn)換成基本數(shù)據(jù)類型

Integer i1 = new Integer(100);
int value = i1;//方法1
int value2 = i1.intValue();//方法2

經(jīng)過上述步驟就可以將包裝類轉(zhuǎn)換成基本數(shù)據(jù)類型了，這兩個例子分別展示了如何將int類型轉(zhuǎn)換成包裝類，如何將包裝類轉(zhuǎn)換成int類型。

3. 包裝類與基本類型的轉(zhuǎn)換 ??

• 我們一般將“基本數(shù)據(jù)類型轉(zhuǎn)換成包裝類”的過程叫做裝箱，將“包裝類轉(zhuǎn)換成基本數(shù)據(jù)類型”的過程叫做拆箱

• 當(dāng)包裝類與基本數(shù)據(jù)類型比較，會自動將包裝類拆箱為基本數(shù)據(jù)類型
  java1.5之后又自動裝箱（autoboxing）和自動拆箱（autounboxing）功能

3.1 裝箱

1. 把基本數(shù)據(jù)類型轉(zhuǎn)為包裝類對象。
2. 可以分為手動裝箱和自動裝箱：
3. 是為了使用專門為對象設(shè)計的API和特性

下面以 int 類型為例：

int i = 10; // 定義一個 int 基本類型值
Integer x = new Integer(i); //手動裝箱
Integer y = i; // 自動裝箱

3.2 拆箱

1. 把包裝類對象拆為基本數(shù)據(jù)類型
2. 可以分為手動拆箱和自動拆箱
3. 一般是因為需要運算，Java中的大多數(shù)運算符是為基本數(shù)據(jù)類型設(shè)計的。比較、算術(shù)等

下面以 int 類型為例：

Integer j = new Integer(8); // 定義一個 Integer 包裝類對象，值為8
int m = j.intValue(); // 手動拆箱 int 類型
int n = j; // 自動拆箱為 int 類型

注： 由于我們經(jīng)常要做基本類型與包裝類之間的轉(zhuǎn)換，從JDK5.0 開始，基本類型與包裝類的裝箱、拆箱動作可以自動完成

• 注意：只能與自己對應(yīng)的類型之間才能實現(xiàn)自動裝箱與拆箱

4.基本數(shù)據(jù)類型、包裝類與字符串間的轉(zhuǎn)換 ??

（1）包裝類轉(zhuǎn)換成其他基本數(shù)據(jù)類型

Integer i = new Integer(100);
//轉(zhuǎn)換成double類型
double d = i.doubleValue();
//轉(zhuǎn)換成float類型
float f = i.floatValue();

（2）基本數(shù)據(jù)類型轉(zhuǎn)為字符串

1. 使用包裝類的toString()方法；
2. 使用String類的valueOf()方法；
3. 使用一個空字符串加上基本類型。

int a = 10;
// 方法1
String s3 = Integer.toString(a);
// 方法2
String s1 = String.valueOf(a);
// 方法3
String s2 = a + "";

（3）字符串轉(zhuǎn)為基本數(shù)據(jù)類型

?? 方式1：除了Character類之外，其他所有包裝類都具有parseXxx靜態(tài)方法可以將字符串參數(shù)轉(zhuǎn)換為對應(yīng)的基本類型，例如：

• public static int parseInt(String s)：將字符串參數(shù)轉(zhuǎn)換為對應(yīng)的int基本類型。
• public static long parseLong(String s)：將字符串參數(shù)轉(zhuǎn)換為對應(yīng)的long基本類型。
• public static double parseDouble(String s)：將字符串參數(shù)轉(zhuǎn)換為對應(yīng)的double基本類型。

String a="123";
Integer.parseInt(a);
Short.parseShort(a);
Byte.parseByte(a);
Long.parseLong(a);
Float.parseFloat(a);
Double.parseDouble(a);
Boolean.parseBoolean(a);

?? 方式2：字符串轉(zhuǎn)為包裝類，然后可以自動拆箱為基本數(shù)據(jù)類型

• public static Integer valueOf(String s)：將字符串參數(shù)轉(zhuǎn)換為對應(yīng)的Integer包裝類，然后可以自動拆箱為int基本類型
• public static Long valueOf(String s)：將字符串參數(shù)轉(zhuǎn)換為對應(yīng)的Long包裝類，然后可以自動拆箱為long基本類型
• public static Double valueOf(String s)：將字符串參數(shù)轉(zhuǎn)換為對應(yīng)的Double包裝類，然后可以自動拆箱為double基本類型

?? 注意:如果字符串參數(shù)的內(nèi)容無法正確轉(zhuǎn)換為對應(yīng)的基本類型，則會拋出java.lang.NumberFormatException異常。

5. 包裝類對象的特點 ??

（1）Integer128 問題

public static void main(String[] args) {
    Integer a = 127;
    Integer b = 127;
    Integer c = 128;
    Integer d = 128;
    int e = 128;
    System.out.println(a == b); // true
    System.out.println(c == d); // false
    System.out.println(d == e); // true
}

• 其中在判斷(c == d)時輸出了false，很明顯輸出結(jié)果并不符合預(yù)期，在邏輯上也并不正確，而同樣的128==128的比較在基本數(shù)據(jù)類型int下便可以正常輸出true，首先要先弄清在128賦值時發(fā)生了什么，接下來通過javap -c反編譯查看測試代碼的字節(jié)碼。

?? 提醒一下：使用equals比較時，無論賦什么值都可以正確輸出true，下文所有討論都建立在使用==比較的前提上，同時出現(xiàn)問題的另一個本質(zhì)也可以說是因為==比較的是地址。

在反編譯結(jié)果，可以知道Integer在初始化時調(diào)用了Integer.valueOf()方法，這也就是我們上面所講的Java的自動裝箱機制.。

在Integer對象創(chuàng)建過程中：

• 如果傳入value數(shù)值在-128~127范圍內(nèi)，那么所有在這個范圍內(nèi)被創(chuàng)建的對象（句柄）實際都指向同一個地址，即被預(yù)創(chuàng)建Integer對象所在的地址。
• 如果傳入value數(shù)值不在范圍內(nèi)，那么每次被創(chuàng)建的對象（句柄）都指向一個新的且不同的地址，即通過new關(guān)鍵字由JVM分配的新地址。

（2）Integer 和 new Integer 問題

案例：

// 情況一：
public static void main(String[] args) {
    Integer m = new Integer(1);//新new的在堆中
    Integer n = 1;//這個用的是緩沖的常量對象，在方法區(qū)
    System.out.println(m == n);//false
    Integer x = new Integer(1);//新new的在堆中
    Integer y = new Integer(1);//另一個新new的在堆中
    System.out.println(x == y);//fa
}
// 情況二：
public static void main(String[] args) {
    int a = 10;
    String b = "10";
    Integer a1 = a;
    Integer b1 = Integer.parseInt(b);
    System.out.println(a1 == b1); // true
    Integer a2 = new Integer(a);
    Integer b2 = new Integer(b);
    System.out.println(a2 == b2); // false
}

Integer n = 1;

• Integer變量指向的是 java 常量池中的對象

new Integer(1);

• new Integer() 的變量指向堆中新建的對象,兩者在內(nèi)存中的地址不同。

（3）類型轉(zhuǎn)換問題

public static void main(String[] args) {
    Integer i1 = 10;
    double i2 = 10;
    // 會將i 自動拆箱為 int，然后根據(jù)基本數(shù)據(jù)類型 ”自動類型轉(zhuǎn)換"規(guī)則，轉(zhuǎn)為 double 比較
    System.out.println(i1 == i2); // true 
    int i3 = 10;
    // 會自動拆箱，按照基本數(shù)據(jù)類型進(jìn)行比較
    System.out.println(i1 == i3); // true
    Integer i4 = new Integer(10);  
    System.out.println(i3 == i4); // true
    System.out.println(i1 == i4); // false
    Double i5 = 10.0;
    System.out.println(i1 == i5); //編譯報錯
}

int 變量與 Integer、 int 變量與new Integer() 比較時，只要兩個的值是相等，則為true因為包裝類Integer 和 基本數(shù)據(jù)類型int 比較時，java會自動拆包裝為int ，然后進(jìn)行比較，實際上就變?yōu)閮蓚€int變量的比較。

?? 腳下留心：使用包裝類時候的注意事項

使用包裝類時，需要注意以下幾點：

1. 包裝類都重寫了Object 類中的toString()方法，以字符串的形式返回被包裝的基本數(shù)據(jù)類型的值。
2. 除了Character外，包裝類都有valueOf(String s)方法，可以根據(jù)String類型的參數(shù)S創(chuàng)建包裝類對象，但參數(shù)s不能為null，而且該字符串必須是可以解析為相應(yīng)基本類型的數(shù)據(jù)，否則雖然可以編譯通過，但運行時會報錯。具體示例如下：

   Integer i = Integer.valueof("123");
   //合法
   Integer i = Integer,valueof("12a");
   //不合法，“12a“不能被正確解析為基本數(shù)據(jù)類型

3. 除了Character 外，包裝類都有parseXxx(String s）靜態(tài)方法，該方法的作用是將字符串轉(zhuǎn)換為對應(yīng)的基本類型的數(shù)據(jù)。參數(shù)不能為null，而且該字符串必須可以解析為相應(yīng)基本類型的數(shù)據(jù)，否則雖然可以編譯通過，但運行時會報錯。具體示例如下:

int i= Integer.parseInt("123");
//合法
Integer in= Integer.parseInt("itcast");
1/不合法 

6. 小結(jié)??

包裝類的特點：

1. 對象化: 包裝類使基本數(shù)據(jù)類型可以作為對象處理，允許與 Java 的集合框架配合使用。
2. 不可變性: 包裝類對象是不可變的，即一旦創(chuàng)建，其值不能更改。
3. 類型轉(zhuǎn)換: 包裝類可以自動進(jìn)行基本類型與對象之間的轉(zhuǎn)換（自動裝箱和拆箱）。
   • 自動裝箱：將基本數(shù)據(jù)類型自動轉(zhuǎn)換為對應(yīng)的包裝類。
   • 拆箱：將包裝類對象自動轉(zhuǎn)換為對應(yīng)的基本數(shù)據(jù)類型。

包裝類是 Java 中一個重要的特性，它使得基本數(shù)據(jù)類型能夠以對象的形式進(jìn)行處理，增強了語言的靈活性與功能性。通過了解包裝類的特點和使用場景，可以在 Java 編程中更有效地處理數(shù)據(jù)。

到此這篇關(guān)于Java 包裝類詳解：從基本概念到實戰(zhàn)技巧的文章就介紹到這了,更多相關(guān)Java 包裝類內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論