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 对象
