【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,判断的是值是否相等}
}