【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() 方法源码如下 :

 
 @IntrinsicCandidate
    public 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 --> String
        byte temp_byte = 127;
        String temp_string_0 = 127 + "";

        //short --> String
        short temp_short = 141;
        String temp_string_1 = temp_short + "";

        //int --> String
        int temp_int = 428;
        String temp_string_2 = temp_int + "";

        //long --> String
        long temp_long = 11211;
        String temp_string_3 = temp_long + "";

        //float --> String
        float temp_float = 135.0F;
        String temp_string_4 = temp_float + "";

        //double --> String
        double temp_double = 433.0;
        String temp_string_5 = temp_double + "";

        //char --> String
        char temp_char = 'A';
        String temp_string_6 = temp_char + "";

        //boolean --> String
        boolean 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 + "";//方式1
        String str2 = Integer.toString(integer_0);//方式2
        String str3 = String.valueOf(integer_0);//方式3

        System.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类对象的值，返回值同方法2
        Byte 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类对象的值，返回值同3
        Short 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；相等则返回0
        int 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类对象的值，返回值同方法3
        Integer 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；相等则返回0
        long 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类对象的值，返回值同方法3
        Long 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类对象的字符，返回值同方法2
        Character 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；相等则返回0
        float 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类对象的值，返回值同方法3
        Float 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类对象的值，返回值同方法2
        Boolean 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中取Integer
        Integer n = 1;//自动装箱，底层调用的是Integer.valueOf(1),从缓冲数组cache中取Integer
        System.out.println(m==n);//true

        Integer x = 128;//自动装箱，底层调用的是Integer.valueOf(128),new一个新的Integer
        Integer y = 128;//自动装箱，底层调用的是Integer.valueOf(128),new一个新的Integer
        System.out.println(x==y);//false
    }
}

6.2 练习题2

判断输出结果

public class demo{
    public static void main(String[] args){
        Integer i1 = 127;//自动装箱，底层调用的是Integer.valueOf(127),从缓冲数组cache中取Integer
        Integer i2 = new Integer(127);//new一个新的Integer
        System.out.println(i1==i2);//false

        Integer i3 = 127;//自动装箱，底层调用的是Integer.valueOf(127),从缓冲数组cache中取Integer
        int i4 = 127;
        System.out.println(i3==i4);//true，判断的是值是否相等

        Integer i5 = 128;//自动装箱，底层调用的是Integer.valueOf(128)，new一个新的Integer
        int i6 = 128;
        System.out.println(i5==i6);//true,判断的是值是否相等
    }
}