Java 中的包装类（3千字详解）

迷南。 2023-09-28 14:50 13阅读 0赞

# 包装类（Wrapper） #

## 1. 包装类的基本概念 ##

*  **包装类：针对八种基本数据类型定义了相应的引用类型；有了类的特点，就可以调用类中的方法。**
 *  **对应关系如下图：**  
    ![在这里插入图片描述][6a2700785f76494b9c65029792723b96.png]
 *  其中，Boolean 类和 Character 类直接继承自 Object 类；而其余的 6 种包装类直接继承自 Number 类。

## 2. 包装类和基本数据类型的转换 ##

*  所有包装类与其数据类型的转换的方法都类似，因此这里只以 int 和 Integer 为例说明。
 *  **装箱与拆箱：装箱指的是 将基本数据类型转换为其对应的包装类；拆箱指的是将 包装类转换为其对应的基本数据类型。**

> **（1）手动装箱和手动拆箱（JDK 5 之前），用法如下：**

// 手动装箱 int->Integer
            int n1 = 100;
            // 方式一：通过Integer类的构造方法，创建一个Integer 类对象
            Integer integer = new Integer(n1);
            
    		// 方式二：调用Integr类的静态方法 valueOf；
            Integer integer1 = Integer.valueOf(n1);
    
            // 手动拆箱
            // Integer -> int
            int i = integer.intValue();

> **（2）自动装箱和自动拆箱（JDK 5 之后，包括JDK 5），用法如下：**

//jdk5后，就可以自动装箱和自动拆箱
            int n2 = 200;
            //自动装箱 int->Integer
            Integer integer2 = n2; //底层使用的是 Integer.valueOf(n2)
            
            //自动拆箱 Integer->int
            int n3 = integer2; //底层仍然使用的是 intValue()方法

## 3. 包装类型和 String 类型的相互转换 ##

*  所有包装类与 String 类型的相互转换的方法都类似，因此这里只以 String 和 Integer 为例说明。

> **（1）包装类（Integer）-> String 类，用法如下：**

//包装类(Integer)->String
            Integer i = 100;// 自动装箱
            
            // 方式1，直接用i 拼接一个空字符串；
            String str1 = i + "";
            
            // 方式2：调用Integer 类中的toString 方法；
            String str2 = i.toString();
            
            // 方式3：调用 String 类中的静态方法 valueOf；
            String str3 = String.valueOf(i);

> **（2）String类 -> 包装类(Integer)，用法如下：**

// String类 -> 包装类(Integer)
            String str4 = "12345";
            
            // 方式1：调用Integer 静态方法 parseInt，返回 int类型，再自动装箱；
            Integer i2 = Integer.parseInt(str4);
    
    		// 方式2：使用Integer构造器，创建一个Integer 对象；
            Integer i3 = new Integer(str4);

## 4. Integer 类和 Character 类的常用方法 ##

*  **代码演示如下：**

public class WrapperMethod {
        
        public static void main(String[] args) {
        
        
            System.out.println(Integer.MIN_VALUE); //返回最小值
            System.out.println(Integer.MAX_VALUE);//返回最大值
    
            System.out.println(Character.isDigit('a'));//判断是不是数字
            System.out.println(Character.isLetter('a'));//判断是不是字母
            System.out.println(Character.isUpperCase('a'));//判断是不是大写
            System.out.println(Character.isLowerCase('a'));//判断是不是小写
    
            System.out.println(Character.isWhitespace('a'));//判断是不是空格
            System.out.println(Character.toUpperCase('a'));//转成大写
            System.out.println(Character.toLowerCase('A'));//转成小写
    
        }
    }

*  **包装类中的方法还有很多，这里不能一一列出举例，可以使用 API 文档查验。**

## 5. Integer 类面试题 ##

> **例一：看下面代码，输出什么，并说明理由。**

public class WrapperExercise02 {
        
        public static void main(String[] args) {
        
        
            // 只要是 new，就是创建了一个新的对象，两个对象的地址不同
            Integer i = new Integer(1);
            Integer j = new Integer(1);
            System.out.println(i == j); // False
            
            /*
    		看 valueOf(i)的源码：
             public static Integer valueOf(int i) {
                if (i >= IntegerCache.low && i <= IntegerCache.high)
                    return IntegerCache.cache[i + (-IntegerCache.low)];
                return new Integer(i);
            }
    		说明：
    		1. 如果i 在 IntegerCache.low(-128)~IntegerCache.high(127), 
    				就直接从已存在的Ingeter数组中返回一个已存在的对象地址；
    		2. 如果不在 -128~127, 就直接 new Integer(i)，新建一个对象
             */
            Integer m = 1; // 底层 Integer.valueOf(1); 
            Integer n = 1;// 底层 Integer.valueOf(1);
            System.out.println(m == n); // True
    
    
            Integer x = 128;// x > 128, 底层 new Integer(128);
            Integer y = 128;// y > 128, 底层 new Integer(128);
            System.out.println(x == y);// False
    
        }
    }

> **例二：看下面代码，输出什么，并说明理由。**

public class WrapperExercise03 {
        
        public static void main(String[] args) {
        
            
            //示例一
            Integer i1 = new Integer(127);
            Integer i2 = new Integer(127);
            System.out.println(i1 == i2);// F
    
            //示例二
            Integer i3 = new Integer(128);
            Integer i4 = new Integer(128);
            System.out.println(i3 == i4);// F
    
            //示例三
            Integer i5 = 127;// 底层Integer.valueOf(127)
            Integer i6 = 127;
            System.out.println(i5 == i6); // T
    
            //示例四
            Integer i7 = 128;
            Integer i8 = 128;
            System.out.println(i7 == i8);// F
    
            //示例五
            Integer i9 = 127; // Integer.valueOf(127)
            Integer i10 = new Integer(127);
            System.out.println(i9 == i10);// F
    
            //示例六
            Integer i11 = 127;
            int i12 = 127;
            // 只有有基本数据类型，判断的是值是否相同
            System.out.println(i11 == i12); // T
    
            //示例七
            Integer i13 = 128;
            int i14 = 128;
            System.out.println(i13 == i14);// T
    
        }
    }

*  **小结：**

>  *  **Integer 类中 的存在一个 Integer对象数组，调用 value（i）方法时，如果传入的 i 的范围在 -128 – 127中，则该方法会直接从 已存在的Integer 对象数组中返回一个对象；否则，该方法会新建一个Integer 对象，再返回。**
>  *  **而使用 new Integer（i），则不用考虑 i 的范围，因为只要是 new ，都会直接创建了一个新的 Integer对象。**

# 总结 #

*  本文是小白博主在学习B站韩顺平老师的Java网课时整理总结的学习笔记，在这里感谢韩顺平老师的网课，如有有兴趣的小伙伴也可以去看看。
 *  本文详细解释了 包装类 的概念与使用，并讲解了 包装类与基本数据类型、String类 相互转换的方法和细节，还举了很多例子，希望小伙伴们看后能有所收获！
 *  最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！我们下一篇博文见吧！

[6a2700785f76494b9c65029792723b96.png]: https://img-blog.csdnimg.cn/6a2700785f76494b9c65029792723b96.png