Java包装类详解与应用指南

目录

一、什么是包装类

二、为什么需要包装类？

三、包装类的应用

1、Integer类常用方法

1.sum(int a, int b)

2.toString()系列方法

3.parseInt()系列方法

4.toBinaryString(int i)  ——将整数转换为二进制字符串

2、其他包装类常用方法

1.valueOf()  ——将基本类型值转换为包装类对象

2.xxxValue()  ——将包装类对象转换为对应的基本类型值

3.compareTo()  ——比较两个包装类对象的大小

4.equals()  ——判断两个包装类对象是否相等

四、装箱拆箱

五、Integer缓冲区（用于节省内存、提高性能）

六、小练习

---

一、什么是包装类

        将基本数据类型封装成对象的类，就是包装类

基本类型	包装类型
boolean	java.lang.Boolean
byte	java.lang.Byte
short	java.lang.Short
int	java.lang.Integer
long	java.lang.Long
float	java.lang.Float
double	java.lang.Double
char	java.lang.Character

二、为什么需要包装类？

        java的设计哲学是“一切皆对象”

        

        但是为了性能考虑

        还是保留了基本数据类型

        但是它们只能表示一些简单的数字，不是对象

        所以不能用来调用方法或属性

        同时某些情况下比如集合类只能存储对象

        这就有些捉襟见肘了

        于是包装类应运而生

三、包装类的应用

        包装类说到底它就是一个类，创建对象和其他类别无二致，我们主要通过案例介绍一些它们常用的方法。

1、Integer类常用方法

1.sum(int a, int b)

静态方法，计算两个 int 值的和，不会改变原始值

public class IntegerSumDemo {public static void main(String[] args) {// 使用Integer.sum方法计算两个整数的和int result = Integer.sum(15, 25);System.out.println("15 + 25 = " + result); // 输出: 15 + 25 = 40// 与直接使用+运算符效果相同，但提供了方法调用的形式int a = 100;int b = 200;int sum = Integer.sum(a, b);System.out.println(a + " + " + b + " = " + sum); // 输出: 100 + 200 = 300}
}

2.toString()系列方法

toString()  ——将 Integer 对象转换为字符串

public class IntegerToStringDemo {public static void main(String[] args) {Integer num = 123;// 将Integer对象转换为字符串String str1 = num.toString();System.out.println("Integer对象转字符串: " + str1); // 输出: Integer对象转字符串: 123// 等价于String str2 = Integer.toString(num);System.out.println("使用静态方法: " + str2); // 输出: 使用静态方法: 123}
}

toString(int i)  ——将 int 值转换为字符串

public class IntToStringDemo {public static void main(String[] args) {int value = 456;// 将int值转换为十进制字符串String str = Integer.toString(value);System.out.println("int转字符串: " + str); // 输出: int转字符串: 456}
}

toString(int i, int radix)  ——将 int 值转换为 指定（radix） 进制的字符串

public class IntToRadixStringDemo {public static void main(String[] args) {int value = 100;// 转换为不同进制的字符串System.out.println("十进制: " + Integer.toString(value, 10)); // 输出: 十进制: 100System.out.println("二进制: " + Integer.toString(value, 2));  // 输出: 二进制: 1100100System.out.println("八进制: " + Integer.toString(value, 8));  // 输出: 八进制: 144System.out.println("十六进制: " + Integer.toString(value, 16)); // 输出: 十六进制: 64}
}

3.parseInt()系列方法

parseInt(String s)  ——将十进制字符串转换为整数

public class ParseIntDemo {public static void main(String[] args) {String str = "123";// 将十进制字符串转换为整数int num = Integer.parseInt(str);System.out.println("字符串\"123\"转为整数: " + num); // 输出: 字符串"123"转为整数: 123// 处理无效输入try {int invalid = Integer.parseInt("abc");} catch (NumberFormatException e) {System.out.println("无法将\"abc\"转换为整数"); // 输出: 无法将"abc"转换为整数}}
}

parseInt(String s, int radix)  ——将指定进制字符串转换为整数

public class ParseIntWithRadixDemo {public static void main(String[] args) {// 将不同进制的字符串转换为十进制整数System.out.println("二进制\"1100100\"转十进制: " + Integer.parseInt("1100100", 2));  // 输出: 100System.out.println("八进制\"144\"转十进制: " + Integer.parseInt("144", 8));        // 输出: 100System.out.println("十六进制\"64\"转十进制: " + Integer.parseInt("64", 16));       // 输出: 100System.out.println("十进制\"100\"转十进制: " + Integer.parseInt("100", 10));       // 输出: 100}
}

4.toBinaryString(int i)  ——将整数转换为二进制字符串

public class ToBinaryStringDemo {public static void main(String[] args) {int value = 100;// 将整数转换为二进制字符串String binaryStr = Integer.toBinaryString(value);System.out.println("100的二进制表示: " + binaryStr); // 输出: 100的二进制表示: 1100100// 更多示例System.out.println("8的二进制: " + Integer.toBinaryString(8));   // 输出: 1000System.out.println("15的二进制: " + Integer.toBinaryString(15));  // 输出: 1111System.out.println("255的二进制: " + Integer.toBinaryString(255)); // 输出: 11111111}
}

2、其他包装类常用方法

1.valueOf()  ——将基本类型值转换为包装类对象

public class ValueOfDemo {public static void main(String[] args) {// 使用valueOf创建包装类对象Integer intObj1 = Integer.valueOf(100);Integer intObj2 = Integer.valueOf("200");Integer intObj3 = Integer.valueOf("1100100", 2); // 二进制字符串转IntegerSystem.out.println("valueOf(100): " + intObj1); // 输出: 100System.out.println("valueOf(\"200\"): " + intObj2); // 输出: 200System.out.println("valueOf(\"1100100\", 2): " + intObj3); // 输出: 100// valueOf与new的区别（缓存机制）Integer a = Integer.valueOf(127);Integer b = Integer.valueOf(127);System.out.println("valueOf缓存测试(127): " + (a == b)); // 输出: trueInteger c = Integer.valueOf(128);Integer d = Integer.valueOf(128);System.out.println("valueOf缓存测试(128): " + (c == d)); // 输出: false}
}

2.xxxValue()  ——将包装类对象转换为对应的基本类型值

public class XxxValueDemo {public static void main(String[] args) {Integer intObj = new Integer(100);// 将Integer对象转换为各种基本类型int intValue = intObj.intValue();long longValue = intObj.longValue();float floatValue = intObj.floatValue();double doubleValue = intObj.doubleValue();byte byteValue = intObj.byteValue();short shortValue = intObj.shortValue();System.out.println("intValue: " + intValue);     // 输出: 100System.out.println("longValue: " + longValue);   // 输出: 100System.out.println("floatValue: " + floatValue); // 输出: 100.0System.out.println("doubleValue: " + doubleValue); // 输出: 100.0System.out.println("byteValue: " + byteValue);   // 输出: 100System.out.println("shortValue: " + shortValue); // 输出: 100}
}

3.compareTo()  ——比较两个包装类对象的大小

public class CompareToDemo {public static void main(String[] args) {Integer a = 100;Integer b = 200;Integer c = 100;// compareTo返回值说明：// 负数：调用对象小于参数对象// 0：调用对象等于参数对象// 正数：调用对象大于参数对象System.out.println("100.compareTo(200): " + a.compareTo(b)); // 输出: -1System.out.println("200.compareTo(100): " + b.compareTo(a)); // 输出: 1System.out.println("100.compareTo(100): " + a.compareTo(c)); // 输出: 0// 实际应用示例Integer[] numbers = {5, 2, 8, 1, 9};for (int i = 0; i < numbers.length - 1; i++) {for (int j = i + 1; j < numbers.length; j++) {if (numbers[i].compareTo(numbers[j]) > 0) {// 交换元素Integer temp = numbers[i];numbers[i] = numbers[j];numbers[j] = temp;}}}System.out.println("排序后: " + java.util.Arrays.toString(numbers)); // 输出: [1, 2, 5, 8, 9]}
}

4.equals()  ——判断两个包装类对象是否相等

“==” 和 equals 的区别：

==：

        比较两个变量的值是否相等

        基本数据类型：比较数值

        引用数据类型：比较引用

        不能被重写

equals：

        比较两个对象的内容是否相等

        默认实现：比较引用（在Object类中，默认实现与==相同）

        常见重写：比较内容（比如String、Integer等包装类重写）

        可重写

public class EqualsDemo {public static void main(String[] args) {Integer a = new Integer(100);Integer b = new Integer(100);Integer c = 100;Integer d = 100;// equals比较的是值，而==比较的是引用System.out.println("new Integer(100).equals(new Integer(100)): " + a.equals(b)); // 输出: trueSystem.out.println("new Integer(100) == new Integer(100): " + (a == b));         // 输出: false// 自动装箱缓存机制的影响System.out.println("100 == 100 (自动装箱): " + (c == d));          // 输出: true (缓存范围内)System.out.println("100.equals(100) (自动装箱): " + c.equals(d));  // 输出: true// 超出缓存范围的情况Integer e = 200;Integer f = 200;System.out.println("200 == 200 (自动装箱): " + (e == f));          // 输出: false (超出缓存范围)System.out.println("200.equals(200) (自动装箱): " + e.equals(f));  // 输出: true}
}

四、装箱拆箱

        在Java 1.0版本发布时

        开发人员发现Vector类只能存储对象，而不能存储基本类型

        这导致了在处理大量数字数据时

        程序员必须手动将int转换为Integer对象，非常繁琐

        于是 jdk1.5 引入了自动装箱和拆箱机制。

自动装箱：基本数据类型值  自动转化为  包装类对象

自动拆箱：包装类对象  自动转化为  基本数据类型值

以 Integer 为例，其他也是如此：

public class Test{public static void main(String[] args){//jdk1.5 之前//Integer a = new Integer(1);//Integer a = Integer.valueOf(1);//jdk1.5 之后//自动装箱：这里会自动把1包装成Integer类型的对象Integer a = 1;//jdk1.5之前//Integer a = new Integer(1);//int i = a.intValue();//jdk1.5之后//Integer a = new Integer(1);//自动拆箱：这里会自动把对象a拆箱为一个int类型的数字，并把数字赋值给int类型的变量iint i = a;}
}

注意！

使用基本类型和包装类时，要考虑隐式类型转换。

不同类型的基本数据类型和包装类，不可以自动装箱拆箱

例如 int 和 long

public class Test{public void test1(int i) {}public void test2(Integer i){}public void test3(long i){}public void test4(Long i){}public static void main(String[] args){Test t = new Test();t.test1(1);    //编译通过，int i = 1; 正常赋值t.test2(1);    //编译通过，Integer i = 1;自动装箱t.test3(1);    //编译通过，long i = 1;隐式类型转换//编译报错//int 和 Long 没有任何关系//t.test4(1);t.test4(1L);    //编译通过，Long i = 1L;自动装箱     }
}

五、Integer缓冲区（用于节省内存、提高性能）

        java中 方法区 有一个叫 运行时常量池 的区域

        用于存储编译期间生成的各种字面量和符号引用

        Integer常量池 就存在运行时常量池里面

        Integer常量池 是一个特殊的缓存机制

        用于存储 [-128,127]范围内的Integer常量对象

        超出这个范围的整形常量不会被缓存

在自动装箱时

将一个整数赋值给一个 Integer 对象时

如果该整数在 [-128,127]范围内 且 已经存在

那么就会从 Integer常量池中获取一个已存在的对象

而不是创建一个新对象

如果没有就创建一个新对象

并且把这个数字放入常量池

通过 new关键字 创建的字符串对象

不会放入常量池中
而是在堆内存中创建一个新的对象

也不会从常量池中取

public class IntegerCacheDemo {public static void main(String[] args) {// 缓冲区范围：-128 到 127Integer a = 127;Integer b = 127;System.out.println("127 == 127: " + (a == b)); // 输出: true (使用缓存)Integer c = 128;Integer d = 128;System.out.println("128 == 128: " + (c == d)); // 输出: false (超出缓存范围)Integer e = -128;Integer f = -128;System.out.println("-128 == -128: " + (e == f)); // 输出: true (使用缓存)Integer g = -129;Integer h = -129;System.out.println("-129 == -129: " + (g == h)); // 输出: false (超出缓存范围)// 使用new关键字总是创建新对象Integer i = new Integer(100);Integer j = new Integer(100);System.out.println("new Integer(100) == new Integer(100): " + (i == j)); // 输出: falseSystem.out.println("new Integer(100).equals(new Integer(100)): " + i.equals(j)); // 输出: true}
}

六、小练习

        看了这么久，实践一下把~

public class Test {public static void main(String[] args) {Integer i1 = new Integer(97);Integer i2 = new Integer(97);System.out.println(i1 == i2); System.out.println(i1.equals(i2));Integer i3 = new Integer(148);Integer i4 = new Integer(148);System.out.println(i3 == i4);System.out.println(i3.equals(i4));Integer i5 = 97;Integer i6 = 97;System.out.println(i5 == i6);System.out.println(i5.equals(i6));Integer i7 = 148;Integer i8 = 148;System.out.println(i7 == i8);System.out.println(i7.equals(i8));int a = 148;int b = 97;Integer c = 97;System.out.println(i7 == a);System.out.println(b == c);}
}

结果：

        false

        true

        

        false

        true

        

        true

        true

        

        false

        true

        true        //Integer 与 int 比较时，自动拆箱

        true        //同理，自动拆箱

public class Test {public static void main(String[] args) {String str1 = "hello"; String str2 = "hello"; String str3 = new String("hello"); String str4 = new String("hello"); String str5 = "hellohello"; String str6 = str1 + str2; System.out.println(str1 == str2); System.out.println(str2 == str3); System.out.println(str3 == str4); System.out.println(str2.equals(str3)); System.out.println(str3.equals(str4)); System.out.println(str5.equals(str6)); System.out.println(str5 == str6);}
}

结果：

        true

        false

        false

       

        true

        ture

        true

        false

public class Test {public static void main(String[] args) {String s1 = "helloworld"; String s2 = "hello"; String s3 = "world"; String s4 = "hello" + "world"; String s5 = s2 + s3; String s6 = new String("helloword"); String s7 = "hello" + new String("world"); System.out.println(s1 == s4); System.out.println(s1 == s5); System.out.println(s1 == s6); System.out.println(s1 == s7);}
}

结果：

        true

        false

        false

        false        //运行时涉及到对象的连接操作，所以在堆内存中创建新的 String 对象