Java 包装类详解：基本类型与引用类型的桥梁

1. 手动装箱（基本类型 → 包装类）

两种常用方式：通过构造方法创建、通过 valueOf() 静态方法创建（推荐）。

常用方法（Integer）

代码示例

public class IntegerDemo01 {
    public static void main(String[] args) {
        // 1. 构造方法创建（手动装箱）
        Integer i1 = new Integer(123); // int → Integer
        Integer i2 = new Integer("123"); // 数字字符串 → Integer

        // 2. valueOf() 方法创建（手动装箱，推荐）
        Integer i3 = Integer.valueOf(123);
        Integer i4 = Integer.valueOf("123");

        System.out.println(i1); // 123（包装类重写了 toString() 方法）
        System.out.println(i2); // 123
    }
}

2. 手动拆箱（包装类 → 基本类型）

通过包装类的 xxxValue() 方法（如 Integer 的 intValue()），将包装类对象转换为对应的基本数据类型。

代码示例

public class IntegerDemo02 {
    public static void main(String[] args) {
        // 手动装箱
        Integer i1 = Integer.valueOf(123);
        
        // 手动拆箱（Integer → int）
        int num = i1.intValue();
        
        // 进行基本类型运算
        num += 100;
        System.out.println(num); // 223

        // 其他包装类的拆箱方法（类比）
        Double d = Double.valueOf(3.14);
        double dNum = d.doubleValue(); // Double → double
    }
}

⚠️ 注意： 使用 Integer(String s) 或 valueOf(String s) 时，字符串必须是 纯数字（如 '123'），如果是字母、符号（如 '12a'、'12.3'），会抛出 NumberFormatException 异常。

（二）JDK5 以后：自动装箱与拆箱（重点）

JDK5 推出了 自动装箱（Auto-Boxing）和自动拆箱（Auto-Unboxing） 机制，彻底简化了包装类的使用 —— 编译器会自动完成'基本类型 ↔ 包装类'的转换，开发者无需手动调用方法。

1. 自动装箱（基本类型 → 包装类）

直接将基本数据类型的值赋值给对应的包装类变量，编译器自动完成装箱操作（底层本质还是调用 valueOf() 方法）。

2. 自动拆箱（包装类 → 基本类型）

直接将包装类对象赋值给对应的基本数据类型变量，编译器自动完成拆箱操作（底层调用 xxxValue() 方法）。

代码示例（核心用法）

public class IntegerDemo03 {
    public static void main(String[] args) {
        // 1. 自动装箱（int → Integer）
        Integer i1 = 123; // 等价于：Integer i1 = Integer.valueOf(123)

        // 2. 自动拆箱（Integer → int）
        int num = i1; // 等价于：int num = i1.intValue()

        // 3. 直接使用包装类进行运算（自动拆箱后运算，再自动装箱）
        Integer i2 = 456;
        Integer i3 = i1 + i2; // 底层：i1.intValue() + i2.intValue() → 自动装箱为 Integer
        System.out.println(i3); // 579

        // 4. 包装类与基本类型直接比较（自动拆箱，比较的是值）
        System.out.println(i1 == 123); // true（i1 自动拆箱，比较值）
    }
}

核心结论

JDK5 以后，基本类型和对应的包装类可以看做是'同一个东西'，可以直接赋值、运算、比较，无需手动转换（其他 7 种包装类用法完全一致）。

（三）Integer 常量池（面试高频考点）

这是 Integer 独有的重点考点，也是日常开发中容易踩坑的地方 —— valueOf() 方法创建对象时，会复用常量池中的对象，而 new Integer() 会直接创建新对象。

1. 常量池机制说明

Java 为了节省内存，在底层提前创建了 ‑128 ~ 127 之间的 Integer 对象，存入常量池中； 当使用 valueOf() 方法创建这个区间内的 Integer 对象时，会直接返回常量池中已有的对象，不会新建； 如果超出这个区间，会新建 Integer 对象，不会复用常量池。

2. 代码示例（面试常考对比）

public class IntegerDemo04 {
    public static void main(String[] args) {
        // 1. valueOf() 创建，值在 -128~127 之间 → 复用常量池对象
        Integer i1 = Integer.valueOf(127);
        Integer i2 = Integer.valueOf(127);
        System.out.println(i1 == i2); // true（地址相同，复用同一个对象）

        // 2. valueOf() 创建，值超出 -128~127 → 新建对象
        Integer i3 = Integer.valueOf(128);
        Integer i4 = Integer.valueOf(128);
        System.out.println(i3 == i4); // false（地址不同，两个不同对象）

        // 3. new Integer() 创建 → 无论值是多少，都新建对象
        Integer i5 = new Integer(127);
        Integer i6 = new Integer(127);
        System.out.println(i5 == i6); // false（地址不同）

        // 4. 自动装箱 → 底层是 valueOf()，遵循常量池规则
        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8); // true
    }
}

面试易错点总结

• == 比较的是 对象地址，equals() 比较的是 对象的值（包装类重写了 equals() 方法）；
• 自动装箱底层调用 valueOf()，遵循常量池规则（-128~127 复用）；
• new Integer() 永远新建对象，不复用常量池。

四、包装类的常用成员方法（重点）

8 种包装类的常用方法高度相似，下面以 Integer 为核心讲解，其他包装类可类比使用，重点掌握'类型转换'和'进制转换'方法。

（一）Integer 常用静态方法（高频）

（二）代码示例（日常开发高频）

public class IntegerMethodDemo {
    public static void main(String[] args) {
        // 1. 字符串转 int（最常用，比如接收前端传递的数字字符串）
        String strNum = "12345";
        int num = Integer.parseInt(strNum);
        System.out.println(num + 100); // 12445

        // 2. 进制转换（面试/刷题常用）
        int num2 = 60;
        String binary = Integer.toBinaryString(num2); // 二进制
        String octal = Integer.toOctalString(num2);   // 八进制
        String hex = Integer.toHexString(num2);       // 十六进制
        System.out.println("二进制：" + binary); // 111100
        System.out.println("八进制：" + octal);   // 74
        System.out.println("十六进制：" + hex);   // 3c

        // 3. 其他包装类的类型转换（类比）
        String strDouble = "3.14";
        double d = Double.parseDouble(strDouble); // String → double

        String strBool = "true";
        boolean b = Boolean.parseBoolean(strBool); // String → boolean
    }
}

（三）重要注意事项

1. 8 种包装类中，除了 Character，都有 parseXxx() 方法（如 Double.parseDouble()、Boolean.parseBoolean()），用于将数字字符串转换为对应的基本类型；
2. Character 没有 parseChar() 方法，若要将字符串转换为 char，需使用 str.charAt(0)（取字符串第一个字符）；
3. parseXxx() 方法的参数，必须是 符合对应类型格式的字符串（如 parseInt() 只能接收纯数字字符串），否则会抛出 NumberFormatException 异常。

五、其他包装类简单说明（类比学习）

除了 Integer，其他 7 种包装类的用法与 Integer 高度一致，重点记忆核心差异即可：

1. Character（char 的包装类）

• 父类是 Object（唯一不继承 Number 的包装类）；
• 常用方法：isDigit(char c)（判断是否是数字字符）、isLetter(char c)（判断是否是字母）、toUpperCase(char c)（转大写）；

示例：

char ch = 'a';
Character c = ch; // 自动装箱
System.out.println(Character.isLetter(ch)); // true
System.out.println(Character.toUpperCase(ch)); // A

2. Boolean（boolean 的包装类）

• 常用方法：parseBoolean(String s)（字符串转 boolean，'true' 转 true，其他均转 false）；
• 注意：Boolean.valueOf("false") 转 false，Boolean.valueOf("abc") 也转 false（仅"true"转 true）。

3. 数值型包装类（Byte、Short、Long、Float、Double）

• 都继承自 Number 类，都有 xxxValue() 方法（拆箱）、parseXxx() 方法（字符串转基本类型）；
• 用法与 Integer 完全一致，仅类型不同（如 Long.parseLong()、Float.parseFloat()）。