Java的包装类及其缓存机制

​ Java 的包装类（Wrapper Classes）是为每种基本数据类型提供的对象表示。基本数据类型（如 int、double 等）是非对象类型，而包装类为它们提供了对应的对象版本，以便可以在需要对象的地方使用这些基本类型。包装类都位于 java.lang 包中，使用时无需显式导入。

一、Java的包装类

1、基本数据类型与对应的包装类

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

2、包装类的用途

1. 对象化：包装类允许基本数据类型在需要对象的上下文中使用。例如：

   • 在集合类（如 ArrayList、HashMap）中存储和操作基本数据类型时，因为集合只能存储对象。

   java">ArrayList<Integer> list = new ArrayList<>();
   list.add(10); // 自动装箱
   list.add(20);
   

2. 提供实用方法：包装类包含许多有用的方法，比如：

   • 字符串和基本数据类型的相互转换。
   • 获取类型的最大值和最小值。
   • 类型的静态常量和元信息。

3. 自动装箱与拆箱（从 Java 5 开始）：

   • 自动装箱：将基本数据类型自动转换为对应的包装类对象。
   • 自动拆箱：将包装类对象自动转换为对应的基本数据类型。

3、包装类的重要功能

3.1 静态方法

包装类提供了许多静态方法，用于基本数据类型的常见操作。例如：

• parseXXX(String)：将字符串转换为对应的基本数据类型。

  java">int num = Integer.parseInt("123");
  double d = Double.parseDouble("45.67");
  

• valueOf(String)：将字符串转换为包装类对象。

  java">Integer num = Integer.valueOf("123");
  

• toString()：将包装类对象转换为字符串。

  java">Integer num = 100;
  String str = num.toString(); // "100"
  

3.2 常量

包装类提供了一些静态常量，比如：

• 最大值和最小值：

  java">int max = Integer.MAX_VALUE; // 2147483647
  int min = Integer.MIN_VALUE; // -2147483648
  

3.3 自动装箱与拆箱

从 Java 5 开始，可以直接将基本数据类型与包装类互换，无需手动创建对象或调用方法：

• 自动装箱：

  java">Integer num = 100; // 等效于 Integer.valueOf(100)
  

• 自动拆箱：

  java">int value = num; // 等效于 num.intValue()
  

3.4 比较

• equals()：比较两个包装类对象的值是否相等。

  java">Integer num1 = 100;
  Integer num2 = 100;
  System.out.println(num1.equals(num2)); // true
  

• compareTo()：用于比较两个包装类对象，返回：

  • 正数：当前对象大于指定对象。
  • 负数：当前对象小于指定对象。
  • 0：两者相等。

  java">Integer num1 = 10;
  Integer num2 = 20;
  System.out.println(num1.compareTo(num2)); // -1
  

注意事项

1. 值的缓存（Integer、Short、Byte、Character 和 Boolean）：

   • 对于值在 -128 到 127 范围内的 Integer，会从缓存中返回对象，而不创建新对象。

   • 示例：

     java">Integer num1 = 127;
     Integer num2 = 127;
     System.out.println(num1 == num2); // true，指向同一个缓存对象Integer num3 = 128;
     Integer num4 = 128;
     System.out.println(num3 == num4); // false，不在缓存范围内，创建了新对象
     

2. 性能开销：

   • 包装类的使用涉及对象创建和拆箱过程，性能比直接使用基本数据类型稍慢。

综合示例

java">public class WrapperExample {public static void main(String[] args) {// 自动装箱与拆箱Integer num = 100; // 自动装箱int value = num;   // 自动拆箱// 静态方法String str = "123";int intValue = Integer.parseInt(str);Double doubleValue = Double.valueOf("45.67");// 比较Integer num1 = 127;Integer num2 = 127;System.out.println(num1 == num2); // true (缓存)Integer num3 = 128;Integer num4 = 128;System.out.println(num3 == num4); // falseSystem.out.println("最大值：" + Integer.MAX_VALUE);System.out.println("最小值：" + Integer.MIN_VALUE);}
}

Java中基本数据类型的缓存机制

​ 在 Java 中，不同基本数据类型的包装类对值的缓存范围和机制有所不同。以下是各包装类的缓存策略：

---

1. Integer 缓存

• 范围：-128 到 127。

• 实现：Integer 类通过静态内部类 IntegerCache 实现缓存。

• 适用场景：当使用 valueOf() 方法或自动装箱时，如果值在缓存范围内，直接返回缓存对象；否则，创建新对象。

• 代码验证：

  java">Integer num1 = 127;
  Integer num2 = 127;
  System.out.println(num1 == num2); // true，来自缓存Integer num3 = 128;
  Integer num4 = 128;
  System.out.println(num3 == num4); // false，超出缓存范围
  

---

2. Short 缓存

• 范围：-128 到 127。

• 实现：与 Integer 类似，Short 也通过静态缓存实现。

• 验证代码：

  java">Short s1 = 127;
  Short s2 = 127;
  System.out.println(s1 == s2); // trueShort s3 = 128;
  Short s4 = 128;
  System.out.println(s3 == s4); // false
  

---

3. Byte 缓存

• 范围：-128 到 127。

• 实现：由于 byte 的值范围本身就是 -128 到 127，所以所有的 Byte 对象都使用缓存。

• 验证代码：

  java">Byte b1 = 127;
  Byte b2 = 127;
  System.out.println(b1 == b2); // trueByte b3 = -128;
  Byte b4 = -128;
  System.out.println(b3 == b4); // true
  

---

4. Long缓存

• 范围：-128 到 127。

• 实现：与 Integer 类似，Long 通过静态缓存实现。

• 验证代码：

  java">Long l1 = 127L;
  Long l2 = 127L;
  System.out.println(l1 == l2); // trueLong l3 = 128L;
  Long l4 = 128L;
  System.out.println(l3 == l4); // false
  

---

5. Character 缓存

• 范围：\u0000（0）到 \u007F（127，即 ASCII 字符）。

• 实现：Character 通过静态缓存实现。

• 验证代码：

  java">Character c1 = 127;
  Character c2 = 127;
  System.out.println(c1 == c2); // trueCharacter c3 = 128;
  Character c4 = 128;
  System.out.println(c3 == c4); // false
  

---

6. Boolean 缓存

• 范围：仅缓存 true 和 false 两个值。

• 实现：Boolean 直接缓存了两个对象（Boolean.TRUE 和 Boolean.FALSE）。

• 验证代码：

  java">Boolean bool1 = true;
  Boolean bool2 = true;
  System.out.println(bool1 == bool2); // trueBoolean bool3 = false;
  Boolean bool4 = false;
  System.out.println(bool3 == bool4); // true
  

---

7. Float 和 Double

• 没有缓存机制：

  • 因为 float 和 double 的值范围较大，且分布不均，未实现缓存机制。
  • 每次创建包装类对象时，都会分配新的对象。

• 验证代码：

  java">Float f1 = 1.0f;
  Float f2 = 1.0f;
  System.out.println(f1 == f2); // falseDouble d1 = 1.0;
  Double d2 = 1.0;
  System.out.println(d1 == d2); // false
  

---

总结：缓存范围对比

包装类	缓存范围	备注
Byte	-128 到 127	全部缓存
Short	-128 到 127	部分缓存
Integer	-128 到 127	部分缓存
Long	-128 到 127	部分缓存
Character	\u0000 到 \u007F	部分缓存（ASCII 范围）
Boolean	true 和 false	完全缓存
Float	无缓存	每次创建新对象
Double	无缓存	每次创建新对象

---

结论

• 整数型包装类（Byte、Short、Integer、Long）都缓存了 -128 到 127 范围的值。
• Character 仅缓存 ASCII 范围的字符。
• Boolean 缓存了两个固定值：true 和 false。
• 浮点型包装类（Float 和 Double）没有缓存机制。