【Java SE】包裝類 Byte、Short、Integer、Long、Character、Float、Double、Boolean

參考筆記：java 包裝類萬字詳解（通俗易懂)_java包裝類-CSDN博客

1.簡介

2.包裝類的繼承關系圖

3.裝箱和拆箱

3.1 介紹

3.2 手動拆裝箱

3.3. 自動拆裝箱

?4.關于String類型的轉化問題

4.1 String類型和基本類型的相互轉化

4.1.1 String ——> 基本類型

?4.1.2 基本類型?——> String

4.2 String類型和包裝類型的相互轉化

4.2.1 String ——> 包裝類

4.2.2 包裝類 ——> String

5.八大包裝類的常用成員方法

?5.1 Byte類常用方法

5.2 Short類常用方法

5.3 Integer類常用方法

5.4 Long類常用方法

5.5 Character類常用方法?

5.6 Float類常用方法

5.7 Double類常用方法

5.8 Boolean類常用方法

6.Integer創建機制的面試題（重要）

6.1 練習題1

6.2 練習題2

1.簡介

基本數據類型不是對象，不能使用類的方法；因此，? Java 針對基本類型提供了它們對應的包裝類，八大基本數據類型，對應了八種包裝類，以對象的形式來調用。包裝類有了類的特點，使得可以調用包裝類中的方法

八大包裝類位于 java.lang 包下，如下圖所示：

除了 Integer 和 Character 這兩個包裝類外，其他六個包裝類的類名均是對應的基本類型首字母大寫后得到的

2.包裝類的繼承關系圖

藍色實線：繼承extends

綠色虛線：實現implements

① Byte、Integer、Long、Float、Double、Short 的繼續關系圖

②?Boolean 的繼承關系圖

③?Character 的繼承關系圖

3.裝箱和拆箱

3.1 介紹

裝箱：基本類型?——> 包裝類型（或者叫對象類型，引用類型）
拆箱：包裝類型 ——> 基本類型

3.2 手動拆裝箱

在 JDK5.0 之前，拆裝箱均是程序員手動完成的

手動裝箱：可以使用包裝類的構造器完成，也可以使用 valueOf() 方法
手動拆箱：以 Integer 類為例，需要用到 intValue() 方法；以 Character 類為例，需要用到 charValue() 方法

案例1：Integer包裝類的手動拆裝箱過程?

public class demo {public static void main(String[] args) {//JDK5.0之前，拆裝箱都是手動完成int temp = 19;//手動裝箱(基本類型 ————> 包裝/引用類型)Integer integer_0 = new Integer(temp);//使用包裝類的構造器完成裝箱Integer integer_1 = Integer.valueOf(temp);//使用包裝類的valueOf方法完成裝箱//手動拆箱(包裝/引用類型 ————> 基本類型)int tempI_0 = integer_0.intValue();//使用包裝類的intValue方法完成拆箱System.out.println("integer_0的值 = " + integer_0);System.out.println("integer_1的值 = " + integer_1);System.out.println("tempI_0 = " + tempI_0);}
}

?案例1運行結果

案例2：Boolean包裝類的手動拆裝箱過程?

public class demo {public static void main(String[] args) {//JDK5.0之前，拆裝箱都是手動完成char temp = 'a';//手動裝箱(基本類型 ————> 包裝/引用類型)Character character_1 = new Character(temp);//使用包裝類的構造器完成裝箱Character character_2 = Character.valueOf(temp);//使用包裝類的valueOf方法完成裝箱//手動拆箱(包裝/引用類型 ————> 基本類型)char tempI_0 = character_1.charValue();//使用包裝類的charValue方法完成拆箱System.out.println("character_1的值 = " + character_1);System.out.println("character_2的值 = " + character_2);System.out.println("tempI_0 = " + tempI_0);}
}

?案例2的執行結果

3.3. 自動拆裝箱

從 JDK5.0 開始，Java 提供了自動拆裝箱的機制（不需要手動調用構造器或者方法了）

自動裝箱：實際上底層調用了 valueOf() 方法
手動拆箱：實際上底層調用了 intValue()方法（以Integer包裝類為例）

案例：Integer包裝類的自動拆裝箱?

public class demo {public static void main(String[] args) {//JDK5.0以后，java提供了自動拆裝箱Integer integer_1 = 199;    //（自動）裝箱——其實底層調用的仍然是valueOf方法（可Debug）int tempI_1 = integer_1;    //（自動）拆箱——其實底層調用的仍然是intValue方法System.out.println("integer_1的值 = " + integer_1);System.out.println("tempI_1 = " + tempI_1);System.out.println("----------------------------------");}
}

運行結果

Debug驗證自動拆裝箱是否在底層調用了手動拆裝箱時用到的方法：valueOf、intValue

由上面的 GIF 可以看到，自動裝拆箱底層分別調用了valueOf() 方法、intValue()方法

另外，關于 Integer 的 valueOf() 方法源碼如下 :

 @IntrinsicCandidatepublic static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)];return new Integer(i);}

源碼的 valueOf 方法中有一個 if 條件語句的判斷，它的意思是：如果傳入的 int 基本類型的值在這個范圍內，就不 new 新的 Integer 對象，而是調用底層的用 static final 修飾的 Integer 緩沖數組 cache。通過追溯源碼，可以得知這里的?low 和 high 的實際范圍是 -128 ~ 127，如下圖所示 :?

緩沖數組 cache 中存放的元素是[-128，127]。可以通過 Debug 來看看底層的緩沖數組是否真實存在，如下GIF所示?:?

?4.關于String類型的轉化問題

4.1 String類型和基本類型的相互轉化

4.1.1 String ——> 基本類型

包裝類中的 parseXxx 方法可以將字符串類型的數據轉換成對應的基本類型，需要用相應的基本類型來作接收

需要注意的是，在將字符串類型轉為其他基本類型前，一定要確認字符串里面的內容能否正常轉換，比方說，如果想把 "唱跳rap籃球"?這段字符串轉換為 int 類型，這時候一定會發生數字格式異常，如下圖所示 :

String ?——> 基本類型演示（byte、short、int、long、float、double、boolean）

public class demo {public static void main(String[] args) {//parseXxx(String)，以對應的基本類型作接收byte temp_byte = Byte.parseByte("11");short temp_short = Short.parseShort("141");int temp_int = Integer.parseInt("430");long temp_long = Long.parseLong("11211");float temp_float = Float.parseFloat("66.66F");double temp_double = Double.parseDouble("666.666");boolean temp_boolean = Boolean.parseBoolean("true");System.out.println("temp_byte = " + temp_byte);System.out.println("temp_short = " + temp_short);System.out.println("temp_int = " + temp_int);System.out.println("temp_long = " + temp_long);System.out.println("temp_float = " + temp_float);System.out.println("temp_double = " + temp_double);System.out.println("temp_boolean = " + temp_boolean);}
}

運行結果：

?String ?——> char 演示

在八大包裝類中，除了 Character 類外，其他的 7 種包裝類中都有 parseXxx 方法。如果想將 String 字符串類型的數據轉換成 char 類型的數據，可以通過 String 類中的兩個方法來完成：

① char[] toCharArray() : 將字符串轉換成字符數組
② char charAt(int index) : 獲取指定索引位置的字符

public class demo {public static void main(String[] args) {//定義一個字符串String str = "蔡徐坤";//利用toCharArray() 方法將字符串轉換為字符數組char[] charArray = str.toCharArray();System.out.println("string字符串一共有" + charArray.length + "個字符.");for (int i = 0; i < charArray.length; i++) {System.out.println("第" + (i + 1) + "個字符是：" + charArray[i]);}System.out.println("---------------------------------------");//利用charAt方法來直接獲取字符串中的每一個字符元素char temp_char_0 = str.charAt(0);char temp_char_1 = str.charAt(1);char temp_char_2 = str.charAt(2);System.out.println("string字符串第一個元素為：" + temp_char_0);System.out.println("string字符串第二個元素為：" + temp_char_1);System.out.println("string字符串第三個元素為：" + temp_char_2);}
}

運行結果：

?4.1.2 基本類型?——> String

基本類型轉 String 最常見的兩種方式：

① 直接與空字符串進行拼接

② String類的valueOf方法?

案例?

public class demo {public static void main(String[] args) {//方法一 : 以空字符串拼接的形式//byte --> Stringbyte temp_byte = 127;String temp_string_0 = 127 + "";//short --> Stringshort temp_short = 141;String temp_string_1 = temp_short + "";//int --> Stringint temp_int = 428;String temp_string_2 = temp_int + "";//long --> Stringlong temp_long = 11211;String temp_string_3 = temp_long + "";//float --> Stringfloat temp_float = 135.0F;String temp_string_4 = temp_float + "";//double --> Stringdouble temp_double = 433.0;String temp_string_5 = temp_double + "";//char --> Stringchar temp_char = 'A';String temp_string_6 = temp_char + "";//boolean --> Stringboolean temp_boolean = true;String temp_string_7 = temp_boolean + "";System.out.println("temp_string_0 = " + temp_string_0);System.out.println("temp_string_1 = " + temp_string_1);System.out.println("temp_string_2 = " + temp_string_2);System.out.println("temp_string_3 = " + temp_string_3);System.out.println("temp_string_4 = " + temp_string_4);System.out.println("temp_string_5 = " + temp_string_5);System.out.println("temp_string_6 = " + temp_string_6);System.out.println("temp_string_7 = " + temp_string_7);System.out.println("========================================");//方法二 : 利用String類的valueOf方法temp_string_0 = String.valueOf(temp_byte) + "_EX";temp_string_1 = String.valueOf(temp_short) + "_EX";temp_string_2 = String.valueOf(temp_int) + "_EX";temp_string_3 = String.valueOf(temp_long) + "_EX";temp_string_4 = String.valueOf(temp_float) + "_EX";temp_string_5 = String.valueOf(temp_double) + "_EX";temp_string_6 = String.valueOf(temp_char) + "_EX";temp_string_7 = String.valueOf(temp_boolean) + "_EX";System.out.println("temp_string_0 = " + temp_string_0);System.out.println("temp_string_1 = " + temp_string_1);System.out.println("temp_string_2 = " + temp_string_2);System.out.println("temp_string_3 = " + temp_string_3);System.out.println("temp_string_4 = " + temp_string_4);System.out.println("temp_string_5 = " + temp_string_5);System.out.println("temp_string_6 = " + temp_string_6);System.out.println("temp_string_7 = " + temp_string_7);}
}

4.2 String類型和包裝類型的相互轉化

4.2.1 String ——> 包裝類

String 類轉化為包裝類有 2 種方式：

① 利用包裝類的parseXXX，例如：Integer integer_0 = Integer. parseInt(字符串類型變量);

② 利用包裝類的構造器，例如 : Integer integer_1 = new Integer(字符串類型變量);?

補充：方式?①?中用到了 parseInt 方法，而在上文 String 類型轉基本類型時也用到了 parseInt 方法，但當時是用 int 類型變量來作接收的。先看一下 parseInt 的源碼：

可以看到 parseInt 的返回值類型是 int 類型，因此方式?① 實際上應用了自動裝箱，把等號右邊返回的 int 類型的值，在底層又調用 valueOf 方法裝箱成了 Integer 包裝類

案例?

public class demo {public static void main(String[] args) {//演示 : String類型 ————> 包裝類型//方式一String string_0 = "141";Integer integer_0 = Integer.parseInt(string_0);//方式二String string_1 = "133";Integer integer_1 = new Integer(string_1);System.out.println("integer_0的值 = " + integer_0);System.out.println("integer_1的值 = " + integer_1);}
}

4.2.2 包裝類 ——> String

包裝類轉換為 String 類型有 3 種方式：

① String xxx = 包裝類變量名 + ""；
② String xxx = 包裝類類名.toString()；
③ String xxx = String.valueOf(...)；

方式 ① 和上文中提到的基本類型轉 String 類型的方式是一回事

方式?② 體現出包裝類相對于基本類型的優勢，可以直接調用包裝類中的方法

方式?③?使用的是 String 的 valueOf 方法，valueOf 內部調用的就是包裝類的 toString 方法，源碼如下：

案例：Integer ——> String

public class demo{public static void main(String[] args){Integer integer_0 = 146;//自動裝箱//包裝類->String類的三種方式String str1 = integer_0 + "";//方式1String str2 = Integer.toString(integer_0);//方式2String str3 = String.valueOf(integer_0);//方式3System.out.println("str1 = " + str1);System.out.println("str2 = " + str2);System.out.println("str3 = " + str3);}
}

5.八大包裝類的常用成員方法

每個包裝類下的方法都很多，本文只講一些比較常用的，遇到不懂的問問 GPT 或者 DeepSeek 就行了。查看其方法可以通過如下步驟：

?5.1 Byte類常用方法

① byte byteValue() ：返回當前 Byte 類對象對應的值，以 byte 類型作接收

②?static int compare(byte x, byte y) ：比較兩個 byte 變量的值。返回值：前面 byte 變量的值減去后面 byte 變量的值

③?int compareTo(Byte anotherByte)：比較兩個 Byte 類對象的值，返回值同?②

④?double doubleValue() ：返回當前 Byte 類對象對應的值，以 double 類型作接收

⑤ int intValue()：返回當前 Byte 類對象對應的值，以 int 類型作接收

⑥ static int parseByte(String xxx)：?字符串類型 ——> byte 類型

⑦ String toString()：將當前 Byte 對象的值轉換為 String 類型

⑧ static String toString(byte b)：將指定的 byte 值轉換為 String 對象

⑨ static Byte valueOf(...)：字符串類型 ——> Byte 類型

案例演示

public class demo {public static void main(String[] args) {//演示 : Byte類常用方法//1 —— byte byteValue() : 返回當前Byte類對象對應的值，以byte類型作接收Byte b = 127;   //自動裝箱byte bb = b.byteValue();System.out.println("byte類型變量bb = " + bb);System.out.println("----------------------------------");//2 —— static int compare(byte x, byte y) : 比較兩個byte變量的值, 返回值為前面byte變量的值減去后面byte變量的值byte temp_b_0 = 5;byte temp_b_1 = 1;int i = Byte.compare(temp_b_0, temp_b_1);System.out.println("temp_b_0 - temp_b_1 = " + i);System.out.println("----------------------------------");//3 —— int compareTo(Byte anotherByte) : 比較兩個Byte類對象的值，返回值同方法2Byte temp_B_0 = 55;Byte temp_B_1 = 11;int i1 = temp_B_0.compareTo(temp_B_1);System.out.println("temp_B_0 - temp_B_1 = " + i1);System.out.println("----------------------------------");//4 —— double doubleValue() : 返回當前Byte類對象對應的值，以double類型作接收double bb1 = b.doubleValue();System.out.println("double類型變量bb1 = " + bb1);System.out.println("----------------------------------");//5 —— int intValue() : 返回當前Byte類對象對應的值，以int類型作接收int bb2 = b.intValue();System.out.println("int類型變量bb2 = " + bb2);System.out.println("----------------------------------");//6 —— static int parseByte(String xxx) : 字符串類型 ——> byte類型byte temp_b_2 = Byte.parseByte("1");System.out.println("byte類型變量temp_b_2 = " + temp_b_2);System.out.println("----------------------------------");//7 —— String toString() : 將當前Byte對象的值轉換為String類型Byte temp_B_2 = 127;String string_0 = temp_B_2.toString();System.out.println("Byte類型對象temp_B_2的字符串形式為：" + string_0);System.out.println("----------------------------------");//8 —— static String toString(byte b) : 將指定的byte值轉換為String對象byte temp_b_3 = 2;String string_1 = Byte.toString(temp_b_3);System.out.println("byte類型變量temp_b_3的字符串形式為：" + string_1);System.out.println("----------------------------------");//9 —— static Byte valueOf(...) : 字符串類型 ——> Byte類型Byte temp_B_3 = Byte.valueOf("11");System.out.println("Byte類型對象temp_B_3的值 = " + temp_B_3);}
}

5.2 Short類常用方法

① Short.MIN_VALUE、Short.MAX_VALUE：返回 Short/short 類型的最小值、最大值

② short shortValue()：返回當前 Short 類對象對應的值，以 short 類型作接收

③?static int compare(short?x, short?y)：比較兩個 short 變量的值, 返回值：前面 short 變量的值減去后面 short 變量的值

④?int compareTo(Short anotherShort)：比較兩個 Short 類對象的值，返回值同 ③

⑤?double doubleValue()：返回當前 Short 類對象對應的值，以 double 類型作接收

⑥ int intValue()：返回當前 Short 類對象對應的值，以 int 類型作接收

⑦ static int parseShort(String xxx) : 字符串類型 ——>? short 類型

⑧ String toString()：將當前 Short 對象的值轉換為 String 類型

⑨ static String toString(short s)：將指定的 short 值轉換為 String 對象

⑩ static Short valueOf(...)：字符串類型 ——> Short 類型

案例演示

public class demo {public static void main(String[] args) {//演示Short類常用方法//1 —— Short.MIN_VALUE,Short.MAX_VALUE,返回Short/short類型的最小值、最大值System.out.println(Short.MIN_VALUE);System.out.println(Short.MAX_VALUE);System.out.println("------------------------------------");//2 —— short shortValue() : 返回當前Short對象的值，以short基本類型作接收Short temp_S_0 = 128;       //自動裝箱short temp_s_0 = temp_S_0.shortValue();System.out.println("short類型變量temp_s_0 = " + temp_s_0);System.out.println("------------------------------------");//3 —— static int compare(short x, short y) : 比較兩個short變量的值, 返回值為前面short變量的值減去后面short變量的值short temp_s_1 = 6;short temp_s_2 = 3;int i = Short.compare(temp_s_1, temp_s_2);System.out.println("temp_s_1 - temp_s_2 = " + i);System.out.println("------------------------------------");//4 —— int compareTo(Short anotherShort) : 比較兩個Short類對象的值，返回值同3Short temp_S_1 = 66;Short temp_S_2 = 33;int i1 = temp_S_1.compareTo(temp_S_2);System.out.println("temp_S_1 - temp_S_2 = " + i1);System.out.println("------------------------------------");//5 —— double doubleValue() : 返回當前Short對象的值，以double基本類型作接收double temp_d_0 = temp_S_0.doubleValue();System.out.println("double類型變量temp_d_0 = " + temp_d_0);System.out.println("------------------------------------");//6 —— int intValue() : 返回當前Short對象的值，以int基本類型作接收int temp_i_0 = temp_S_0.intValue();System.out.println("int類型變量temp_i_0 = " + temp_i_0);System.out.println("------------------------------------");//7 —— static int parseShort(String xxx) : 字符串類型 ——> short基本類型short temp_s_3 = Short.parseShort("128");System.out.println("short類型變量temp_s_3 = " + temp_s_3);System.out.println("------------------------------------");//8 —— String toString() : 將當前Short對象的值轉換為String類型Short temp_S_3 = 1277;String string_0 = temp_S_3.toString();System.out.println("Short類型對象temp_S_3的字符串形式為：" + string_0);System.out.println("------------------------------------");//9 —— static String toString(short s) : 將指定的short值轉換為String對象short temp_s_4 = 2;String string_1 = Short.toString(temp_s_4);System.out.println("short類型變量temp_s_4的字符串形式為：" + string_1);System.out.println("----------------------------------");//10 —— static Short valueOf(...) : 字符串類型 ——> Short類型Short temp_S_4 = Short.valueOf("1111");System.out.println("Short類型對象temp_S_4的值 = " + temp_S_4);}
}

5.3 Integer類常用方法

① Integer.MIN_VALUE、Integer.MAX_VALUE：返回 Integer/int 類型的最小值、最大值

② int?intValue() 、double doubleValue()：返回當前 Integer 類對象對應的值，以 int/double 類型作接收

③?static int compare(int x, int?y)：?比較兩個 int 變量的值。返回值：如果前一個數大，返回 1 ；如果前一個數小，返回 -1 ；相等則返回 0

④?int compareTo(Integer anotherInteger)：比較兩個 Integer 類對象的值，返回值同 ③

⑤ static int parseInt(String xxx)：字符串類型 ——>? int 類型

⑥ String toString()：?將當前 Integer 對象的值轉換為 String 類型

⑦ static String toString(short s)：將指定的 int 值轉換為 String 對象

⑧ static Short valueOf(...)：字符串類型 ——> Integer 類型

⑨?static int max(int x, int y) 和 min(int x, int y)：獲取兩個數中的最大值和最小值

⑩ static int sum(int x, int y)：返回（x + y）的值

案例演示

public class demo {public static void main(String[] args) {//演示Integer類常用方法//1 —— Integer.MIN_VALUE,Integer.MAX_VALUE,返回Integer/int類型的最小值、最大值System.out.println(Integer.MIN_VALUE);System.out.println(Integer.MAX_VALUE);System.out.println("------------------------------------");//2 —— int intValue()、double doubleValue() : 返回當前Integer對象的值，以int/double基本類型作接收Integer temp_I_0 = 1280;       //自動裝箱int temp_i_0 = temp_I_0.intValue();double temp_d_0 = temp_I_0.doubleValue();System.out.println("int類型變量temp_i_0 = " + temp_i_0);System.out.println("double類型變量temp_d_0 = " + temp_d_0);System.out.println("------------------------------------");//3 —— static int compare(int x, int y) : 比較兩個int變量的值。如果前一個數大，返回1；如果前一個數小，返回-1；相等則返回0int temp_i_1 = 7;int temp_i_2 = 11;int i = Integer.compare(temp_i_1, temp_i_2);System.out.println("temp_i_1和temp_i_2，如果前一個數大，返回1；如果前一個數小，返回-1；相等則返回0 : " + i);System.out.println("------------------------------------");//4 —— int compareTo(Integer anotherInteger) : 比較兩個Integer類對象的值，返回值同方法3Integer temp_I_1 = 77;Integer temp_I_2 = 11;int i1 = temp_I_1.compareTo(temp_I_2);System.out.println("temp_I_1和temp_I_2，如果前一個數大，返回1；如果前一個數小，返回-1；相等則返回0 : " + i1);System.out.println("------------------------------------");//5 —— static int parseInt(String xxx) : 字符串類型 ——> int基本類型int temp_i_3 = Integer.parseInt("4444");System.out.println("int類型變量temp_i_3 = " + temp_i_3);System.out.println("------------------------------------");//6 —— String toString() : 將當前Integer對象的值轉換為String類型Integer temp_I_3 = 11217;String string_0 = temp_I_3.toString();System.out.println("Integer類型對象temp_I_3的字符串形式為：" + string_0);System.out.println("------------------------------------");//7 —— static String toString(int s) : 將指定的int值轉換為String對象int temp_i_4 = 111111;String string_1 = Integer.toString(temp_i_4);System.out.println("int類型變量temp_i_4的字符串形式為：" + string_1);System.out.println("----------------------------------");//8 —— static Integer valueOf(...) : 字符串類型 ——> Integer類型Integer temp_I_4 = Integer.valueOf("1111");System.out.println("Integer類型對象temp_I_4的值 = " + temp_I_4);System.out.println("----------------------------------");//9 —— static int max(int x, int y) 和 min(int x, int y) : 獲取兩個數中的最大值和最小值System.out.println("100和101哪個數更大？" + Integer.max(100, 101));System.out.println("200和201哪個數更小？" + Integer.min(200, 201));System.out.println("----------------------------------");//10 —— static int sum(int x, int y) : 返回（x + y）的值System.out.println("100 + 201 = " + Integer.sum(100 ,201));}
}

5.4 Long類常用方法

① Long.MIN_VALUE、Long.MAX_VALUE：返回 Long/long 類型的最小值、最大值

② long longValue()、int?intValue() 、double doubleValue()：返回當前 Long 類對象對應的值，以 long/int/double 類型作接收

③?static int compare(long x, long?y)：比較兩個 long 變量的值。返回值：如果前一個數大，返回 1 ；如果前一個數小，返回 -1 ；相等則返回 0

④?int compareTo(Long anotherLong)：比較兩個 Long 類對象的值，返回值同?③

⑤ static long parseLong(String xxx)：字符串類型 ——> long 類型

⑥ String toString()：將當前 Long 對象的值轉換為 String 類型

⑦ static String toString(long l)：將指定的 long 值轉換為 String 對象

⑧ static Long valueOf(...)：字符串類型 ——> Long 類型

⑨?static long?max(long?x, long?y) 和 min(long?x, long?y)：獲取兩個數中的最大值和最小值

⑩ static long?sum(long?x, long?y)：返回（x + y）的值

案例演示

public class demo {public static void main(String[] args) {//演示Long類常用方法//1 —— Long.MIN_VALUE,Long.MAX_VALUE,Long/long類型的最小值、最大值System.out.println(Long.MIN_VALUE);System.out.println(Long.MAX_VALUE);System.out.println("------------------------------------");//2 —— long longValue()、int intValue()、double doubleValue(): 返回當前Long對象的值，以long/int/double基本類型作接收Long temp_L_0 = 2224L;       //自動裝箱long temp_l_0 = temp_L_0.longValue();int temp_i_0 = temp_L_0.intValue();double temp_d_0 = temp_L_0.doubleValue();System.out.println("long類型變量temp_l_0 = " + temp_l_0);System.out.println("int類型變量temp_i_0 = " + temp_i_0);System.out.println("double類型變量temp_d_0 = " + temp_d_0);System.out.println("------------------------------------");//3 —— static int compare(long x, long y) : 比較兩個long變量的值. 如果前一個數大，返回1；如果前一個數小，返回-1；相等則返回0long temp_l_1 = 222L;long temp_l_2 = 111L;int i = Long.compare(temp_l_1, temp_l_2);System.out.println("temp_l_1和temp_l_2，如果前一個數大，返回1；如果前一個數小，返回-1；相等則返回0 : " + i);System.out.println("------------------------------------");//4 —— int compareTo(Long anotherLong) : 比較兩個Long類對象的值，返回值同方法3Long temp_L_1 = 773L;Long temp_L_2 = 113L;int i1 = temp_L_1.compareTo(temp_L_2);System.out.println("temp_L_1和temp_L_2，如果前一個數大，返回1；如果前一個數小，返回-1；相等則返回0 : " + i1);System.out.println("------------------------------------");//5 —— static long parseLong(String xxx) : 字符串類型 ——> long基本類型long temp_l_3 = Long.parseLong("35252");System.out.println("long類型變量temp_l_3 = " + temp_l_3);System.out.println("------------------------------------");//6 —— String toString() : 將當前Long對象的值轉換為String類型Long temp_L_3 = 11217L;String string_0 = temp_L_3.toString();System.out.println("Long類型對象temp_L_3的字符串形式為：" + string_0);System.out.println("------------------------------------");//7 —— static String toString(long l) : 將指定的long值轉換為String對象long temp_l_4 = 222222;String string_1 = Long.toString(temp_l_4);System.out.println("long類型變量temp_l_4的字符串形式為：" + string_1);System.out.println("----------------------------------");//8 —— static Long valueOf(...) : 字符串類型 ——> Long類型Long temp_L_4 = Long.valueOf("111241");System.out.println("Long類型對象temp_L_4的值 = " + temp_L_4);System.out.println("----------------------------------");//9 —— static long max(long x, long y) 和 min(long x, long y) : 獲取兩個數中的最大值和最小值System.out.println("10000和10100哪個數更大？" + Long.max(10000, 10100));System.out.println("20000和20100哪個數更小？" + Long.min(20000, 20100));System.out.println("----------------------------------");//10 —— static long sum(long x, long y) : 返回（x + y）的值System.out.println("11111111 + 8888889 = " + Long.sum(11111111 ,8888889));}
}

5.5 Character類常用方法?

① char charValue()：返回當前 Character 類對象對應的值，以 char 類型作接收

② static Character?valueOf(...)：字符串類型 ——> Character?類型

③?static int compare(char x, char?y)：比較兩個 Character 類對象的字符。返回值： x 的 ASCII 碼值 - y 的 ASCII 碼值

④?int compareTo(Character anotherCharater)：比較兩個 Character 類對象的值，返回值同?③

⑤??

（1）static boolean isDigit(char c1) : 判斷該字符是不是數字
（2）static boolean isLetter(char c2) : 判斷該字符是不是字母
（3）static boolean isUpperCase(char c3) : 判斷該字符是不是大寫形式
（4）static boolean isLowerCase(char c4) : 判斷該字符是不是小寫形式
（5）static boolean isWhitespace(char c5) : 判斷該字符是不是空格

⑥?

（1）static char toUpperCase(char c) : 將該字符轉換為大寫形式，以char類型作接收
（2）static char toLowerCase(char c) : 將該字符轉換為小寫形式，以char類型作接收

案例演示?

public class demo {public static void main(String[] args) {//演示 : Character類常用方法//1 —— char charValue():返回當前Character類對象對應的值，以char類型作接收Character character_0 = '蔡';//自動裝箱char char_0 = character_0.charValue();System.out.println("char基本類型變量char_0 = " + char_0);System.out.println("----------------------------------");//2 ——  static Character valueOf(...) :字符串類型 ——> Character類型Character character_1 = Character.valueOf('S');System.out.println("Character類對象character_1的字符是：" + character_0);System.out.println("----------------------------------");//3 —— static int compare(char x, char y) : 返回前面字符ASCII碼值 - 后面字符ASCII值的int類型int i1 = Character.compare('A', 'F');System.out.println("ASCII碼值'A' - 'F' = " + i1);System.out.println("----------------------------------");//4 —— int compareTo(Character anotherCharacter) : 比較兩個Character類對象的字符，返回值同方法2Character character_2 = 'a';Character character_3 = 'd';int i2 = character_2.compareTo(character_3);System.out.println("character_2 - character_3 = " + i2);System.out.println("----------------------------------");/*5—— static boolean isDigit(char c1) : 判斷該字符是不是數字—— static boolean isLetter(char c2) : 判斷該字符是不是字母—— static boolean isUpperCase(char c3) : 判斷該字符是不是大寫形式—— static boolean isLowerCase(char c4) : 判斷該字符是不是小寫形式—— static boolean isWhitespace(char c5) : 判斷該字符是不是空格*/System.out.println("\'A\'是不是數字 : " + Character.isDigit('A'));System.out.println("\'A\'是不是字母 : " + Character.isLetter('A'));System.out.println("\'A\'是不是大寫形式 : " + Character.isUpperCase('A'));System.out.println("\'A\'是不是小寫形式 : " + Character.isLowerCase('A'));System.out.println("\'A\'是不是空格 : " + Character.isWhitespace('A'));System.out.println("----------------------------------");/*6—— static char toUpperCase(char c) : 將該字符轉換為大寫形式，以char類型作接收—— static char toLowerCase(char c) : 將該字符轉換為小寫形式，以char類型作接收*/char c1 = Character.toUpperCase('n');char c2 = Character.toLowerCase('B');System.out.println("\'n\'字符的大寫形式為：" + c1);System.out.println("\'B\'字符的小寫形式為：" + c2);}
}

5.6 Float類常用方法

① Float.MIN_VALUE、Float.MAX_VALUE：返回 Float/float 類型的最小值、最大值

② float?floatValue()、int?intValue() 、long doubleValue()、double doubleValue()：返回當前 Float 類對象對應的值，以 float/int/long/double 類型作接收

③?static int compare(float?x, float?y)：比較兩個 float?變量的值。返回值：如果前一個數大，返回 1 ；如果前一個數小，返回 -1 ；相等則返回 0

④?int compareTo(Float anotherFloat)：比較兩個 Float 類對象的值，返回值同 ③

⑤ static float parseFloat(String xxx)：字符串類型 ——> float 類型

⑥ String toString()：將當前 Float 對象的值轉換為 String 類型

⑦ static String toString(float f)：將指定的 float 值轉換為 String 對象

⑧ static Float valueOf(...)：字符串類型 ——> Float 類型

⑨?static float max(float x, float y) 和 min(float x, float y)：獲取兩個數中的最大值和最小值

⑩ static float sum(float x, float y)：返回（x + y）的值

案例演示?

public class demo {public static void main(String[] args) {//演示 : Float類常用方法//1 —— Float.MIN_VALUE,Float.MAX_VALUE,Float/float類型的最小值、最大值System.out.println(Float.MIN_VALUE);System.out.println(Float.MAX_VALUE);System.out.println("------------------------------------");//2 —— float floatValue()、int intValue()、long longValue()、double doubleValue: 返回當前Float對象的值，以float/int/long/double基本類型作接收。Float temp_F_0 = 1024.11F;//自動裝箱float temp_f_0 = temp_F_0.floatValue();int temp_i_0 = temp_F_0.intValue();long temp_l_0 = temp_F_0.longValue();double temp_d_0 = temp_F_0.doubleValue();System.out.println("float類型變量temp_f_0 = " + temp_f_0);System.out.println("int類型變量temp_i_0 = " + temp_i_0);System.out.println("long類型變量temp_l_0 = " + temp_l_0);System.out.println("double類型變量temp_d_0 = " + temp_d_0);System.out.println("------------------------------------");//3 —— static int compare(float x, float y) : 比較兩個float變量的值, 如果前一個數大，返回1；如果前一個數小，返回-1；相等則返回0float temp_f_1 = 222.11F;float temp_f_2 = 222.11F;int i = Float.compare(temp_f_1, temp_f_2);System.out.println("temp_f_1和temp_f_2，如果前一個數大，返回1；如果前一個數小，返回-1；相等則返回0 : " + i);System.out.println("------------------------------------");//4 —— int compareTo(Float anotherFloat) : 比較兩個Float類對象的值，返回值同方法3Float temp_F_1 = 222.11F;Float temp_F_2 = 123.11F;int i1 = temp_F_1.compareTo(temp_F_2);System.out.println("temp_F_1和temp_F_2，如果前一個數大，返回1；如果前一個數小，返回-1；相等則返回0 : " + i1);System.out.println("------------------------------------");//5 —— static float parseFloat(String xxx) : 字符串類型 ——> float基本類型float temp_f_3 = Float.parseFloat("35252.11125");System.out.println("float類型變量temp_f_3 = " + temp_f_3);System.out.println("------------------------------------");//6 —— String toString() : 將當前Float對象的值轉換為String類型Float temp_F_3 = 12144217.12F;String string_0 = temp_F_3.toString();System.out.println("Float類型對象temp_F_3的字符串形式為：" + string_0);System.out.println("------------------------------------");//7 —— static String toString(float f) : 將指定的float值轉換為String對象float temp_f_4 = 222222.11F;String string_1 = Float.toString(temp_f_4);System.out.println("float類型變量temp_f_4的字符串形式為：" + string_1);System.out.println("----------------------------------");//8 —— static Float valueOf(...) : 字符串類型 ——> Float類型Float temp_F_4 = Float.valueOf("111241.1235");System.out.println("Float類型對象temp_F_4的值 = " + temp_F_4);System.out.println("----------------------------------");//9 —— static float max(float x, float y) 和 min(float x, float y) : 獲取兩個數中的最大值和最小值System.out.println("10000.00 和 10100.11, 哪個數更大？" + Float.max(10000.00F, 10100.11F));System.out.println("200.00 和 201.88, 哪個數更小？" + Float.min(200.00F, 201.88F));System.out.println("----------------------------------");//10 —— static float sum(float x, float y) : 返回（x + y）的值System.out.println("11111.11 + 8889.022 = " + Float.sum(11111.11F,8889.022F));}
}

5.7 Double類常用方法

與 Float 類完全一致，這里不再贅述

5.8 Boolean類常用方法

① boolean booleanValue()：返回當前 Boolean 類對象對應的值，以 boolean 類型作接收

② static int compare(boolean x，boolean y)：比較兩個 boolean 變量的值，兩個變量真值相同返回 0 .否則返回值取決于于第一個 boolean 變量的真值，true 返回 1 ，false 返回 -1

③?int compareTo(Boolean anotherBoolean)：比較兩個 Boolean 類對象的值，返回值同 ②

④ static boolean parseBoolean(String xxx)：字符串類型 ——>? boolean 類型

⑤?String toString()：將當前 Boolean 對象的值轉換為 String 類型

⑥?static String toString(boolean b)：將指定的 boolean 值轉換為 String 對象

⑦ static Boolean valueOf(...) ：字符串類型 ——> Boolean 類型

?案例演示

public class demo {public static void main(String[] args) {//演示 : Boolean類常用方法//1 —— boolean booleanValue()：返回當前Boolean類對象對應的值，以boolean類型作接收Boolean temp_B_0 = true;//自動裝箱boolean temp_b_0 = temp_B_0.booleanValue();System.out.println("boolean類型變量temp_b_0 = " + temp_b_0);System.out.println("------------------------------------");//2 —— static int compare(boolean x, boolean y) : 比較兩個boolean變量的值,兩個變量真值相同返回0。否則返回值取決于第一個boolean變量的真值，true返回1，false返回-1.boolean temp_b_1 = false;boolean temp_b_2 = true;int i = Boolean.compare(temp_b_1, temp_b_2);int ii = Boolean.compare(temp_b_2, temp_b_1);int iii = Boolean.compare(temp_b_2, temp_b_2);System.out.println("temp_b_1和temp_b_2, 兩個真值相同返回1。否則返回值取決于傳入第一個boolean變量的真值，true返回1，false返回-1 : " + i);System.out.println("temp_b_2和temp_b_1, 兩個真值相同返回1。否則返回值取決于傳入第一個boolean變量的真值，true返回1，false返回-1 : " + ii);System.out.println("temp_b_2和temp_b_2, 兩個真值相同返回1。否則返回值取決于傳入第一個boolean變量的真值，true返回1，false返回-1 : " + iii);System.out.println("------------------------------------");//3 —— int compareTo(Boolean anotherBoolean) : 比較兩個Boolean類對象的值，返回值同方法2Boolean temp_B_1 = false;Boolean temp_B_2 = false;int i1 = temp_B_1.compareTo(temp_B_2);System.out.println("temp_B_1和temp_B_2的真值情況是 : " + i1);System.out.println("------------------------------------");//4 —— static boolean parseBoolean(String xxx) : 字符串類型 ——> boolean基本類型boolean temp_b_3 = Boolean.parseBoolean("666");System.out.println("boolean類型變量temp_b_3 = " + temp_b_3);System.out.println("------------------------------------");//5 —— String toString() : 將當前Boolean對象的值轉換為String類型Boolean temp_B_3 = false;String string_0 = temp_B_3.toString();System.out.println("Boolean類型對象temp_B_3的字符串形式為：" + string_0);System.out.println("------------------------------------");//6 —— static String toString(boolean s) : 將指定的boolean值轉換為String對象boolean temp_b_4 = true;String string_1 = Boolean.toString(temp_b_4);System.out.println("boolean類型變量temp_b_4的字符串形式為：" + string_1);System.out.println("----------------------------------");//7 —— static Boolean valueOf(...) : 字符串類型 ——> Boolean類型Boolean temp_B_4 = Boolean.valueOf("false");System.out.println("Boolean類型對象temp_B_4的值 = " + temp_B_4);}
}

6.Integer創建機制的面試題（重要）

①?Integer.valueOf 的源碼在本文的 3.3自動拆裝箱已經提到，這里不作贅述

② 基本數據類型與其對應的包裝類用 "==" 比較時，比較的是值是否相等

6.1 練習題1

判斷輸出結果

public class demo{public static void main(String[] args){Integer i = new Integer(1);Integer j = new Integer(1);System.out.println(i==j);//false，i與j是兩個不同的對象Integer m = 1;//自動裝箱，底層調用的是Integer.valueOf(1),從緩沖數組cache中取IntegerInteger n = 1;//自動裝箱，底層調用的是Integer.valueOf(1),從緩沖數組cache中取IntegerSystem.out.println(m==n);//trueInteger x = 128;//自動裝箱，底層調用的是Integer.valueOf(128),new一個新的IntegerInteger y = 128;//自動裝箱，底層調用的是Integer.valueOf(128),new一個新的IntegerSystem.out.println(x==y);//false}
}

6.2 練習題2

判斷輸出結果

public class demo{public static void main(String[] args){Integer i1 = 127;//自動裝箱，底層調用的是Integer.valueOf(127),從緩沖數組cache中取IntegerInteger i2 = new Integer(127);//new一個新的IntegerSystem.out.println(i1==i2);//falseInteger i3 = 127;//自動裝箱，底層調用的是Integer.valueOf(127),從緩沖數組cache中取Integerint i4 = 127;System.out.println(i3==i4);//true，判斷的是值是否相等Integer i5 = 128;//自動裝箱，底層調用的是Integer.valueOf(128)，new一個新的Integerint i6 = 128;System.out.println(i5==i6);//true,判斷的是值是否相等}
}