Java 原始类型（primitive）与包装类（wrapper）详解

本文档按以下结构组织：简明对照表 → 各类型多角度说明（定义、位宽、取值范围、默认值、用途、注意事项）→ 为什么需要包装类（多角度原因）→ 装箱/拆箱的副作用与性能考虑 → 常见陷阱与示例 → 何时使用原始类型/何时使用包装类 → 参考/补充说明。

---

一览表（简明）

原始类型	位宽	语义 / 取值范围	对应包装类	字面量后缀 / 备注	字段默认值
byte	8	有符号整数：-128 … 127	Byte	—	0
short	16	有符号整数：-32768 … 32767	Short	—	0
int	32	有符号整数（最常用）：-2^31 … 2^31-1	Integer	—	0
long	64	有符号长整数：-2^63 … 2^63-1	Long	后缀 L 或 l	0L
float	32	单精度浮点（IEEE 754）	Float	后缀 f 或 F	0.0f
double	64	双精度浮点（IEEE 754，默认浮点字面量类型）	Double	（默认）	0.0d 或 0.0
char	16	无符号 16 位 Unicode code unit：0 … 65535	Character	单引号字面量 'a'	'\u0000'
boolean	1（语义）	布尔：true / false	Boolean	—	false

说明：表中“字段默认值”指的是类成员（field）的默认初始化值；局部变量无默认值，必须显式赋值后使用。

---

各类型详细说明

byte / Byte

• 原始类型（primitive）：byte，8 位带符号整数，范围 -128 到 127。
• 用途：处理二进制数据、网络/文件流、节省内存场景（大量小整数）、位运算时的较小单位。
• 注意：算术运算时会提升为 int（例如 byte + byte → int），需要显式类型转换才能赋回 byte。
• 包装类 Byte：对象形式，提供 parseByte、valueOf、byteValue 等方法；可为 null，可放入集合。

示例：

byte b = 10;
byte c = (byte)(b + 20); // 算术运算提升为 int，需强转回 byte
Byte boxed = Byte.valueOf(b);

short / Short

• 原始类型：short，16 位带符号整数。
• 用途：内存紧张且数值范围超出 byte 时；在现代 JVM 中使用较少，通常优先 int。
• 包装类 Short：与 Byte 类似，提供解析与转换工具。

int / Integer

• 原始类型：int，32 位带符号整数，是 Java 中最常用的整型（循环计数、索引、算术等）。
• 包装类 Integer：常用静态方法：parseInt、valueOf、toString；包含常量 MIN_VALUE、MAX_VALUE；实现 Comparable<Integer>。
• 缓存：Integer.valueOf(int) 通常会缓存 -128 到 127 的值（由 JVM/标准库实现提供），可以减少装箱对象分配；不要依赖 == 来比较包装类的数值。

示例：

int x = Integer.parseInt("123");
Integer y = Integer.valueOf(123); // 可能返回缓存对象

long / Long

• 原始类型：long，64 位带符号整数，适用于需要较大整数范围的场景（时间戳、文件大小、全局计数器）。
• 包装类 Long：与 Integer 类似，字面量超出 int 范围需加 L。

示例：

long t = System.currentTimeMillis();
Long L = 123L;

float / Float 与 double / Double

• float：32 位单精度浮点数，约 6-7 位十进制有效数字，适用于对精度要求不高、内存或带宽敏感的场景（图形、科学计算的某些部分）。
• double：64 位双精度浮点数，约 15 位十进制有效数字，是 Java 中默认的浮点类型，通常优先使用 double。
• 浮点陷阱：浮点数采用 IEEE 754，存在舍入误差；不适合做精确货币计算，需使用 BigDecimal。
• 包装类：提供 parseDouble、isNaN、isInfinite 等方法。

示例：

double a = 0.1 + 0.2; // 可能不是精确的 0.3
Float f = 1.23f; // 需要 f 后缀

char / Character

• 原始类型：char，16 位无符号，表示 UTF-16 的一个 code unit（范围 0…65535）。
• 注意：某些 Unicode 字符使用“代理项对”（surrogate pair），由两个 char 表示一个 Unicode code point。
• 用途：单个字符处理、字符分类（结合 Character 的工具方法）。
• 包装类 Character：提供 Character.isLetter、isDigit、compareTo 等方法。

示例：

char c = '中';
int code = c; // 隐式转换为 int，得到 UTF-16 code unit 值

boolean / Boolean

• 原始类型：boolean，只有两个语义值：true 与 false。
• 包装类 Boolean：常量 Boolean.TRUE / Boolean.FALSE，静态方法 parseBoolean、valueOf。
• 注意：包装类可为 null，拆箱 null 会导致 NullPointerException。

示例：

boolean flag = true;
Boolean box = Boolean.valueOf(flag);

---

为什么需要包装类

1. 泛型与集合要求对象类型：Java 泛型不支持原始类型（List<int> 非法），必须使用包装类（List<Integer>）。
2. 可以表示 null（三态语义）：在数据库映射、API 参数、可选值场景中，包装类可以表达“无值/未知”，原始类型不行。
3. 提供工具方法与常量：parseXxx、valueOf、MIN_VALUE、MAX_VALUE、格式化/转换等实用工具。
4. 反射与框架兼容：很多反射 API、序列化框架、注解处理器以 Object 为单位工作，仅支持对象类型或在方法签名中需要 Class<?> 对象。
5. 实现接口（比如 Comparable）：包装类实现了标准接口，方便排序、比较与集合操作。
6. 便捷的自动装箱/拆箱语法：自 Java 5 起，编译器自动处理装箱/拆箱，使使用包装类更便利（同时带来性能/语义注意点）。

---

装箱（boxing）与拆箱（unboxing）：副作用与性能考量

• 对象分配开销：装箱通常会分配对象，增加堆内存和 GC 压力（除非命中缓存）。
• 性能影响：在高频数值计算或紧密循环中频繁装箱/拆箱会带来可测量的性能下降。优先使用原始类型数组（int[]）或原始类型局部变量。
• 空指针风险：Integer x = null; int y = x; 在拆箱时抛出 NullPointerException。
• 比较语义问题：对包装类使用 == 比较实际上比较引用，容易出错；应使用 equals() 或拆箱为原始类型后使用 ==。
• 缓存机制：标准库方法（如 Integer.valueOf）通常缓存小整数（默认 -128 到 127），减少装箱对象；但缓存范围除 -128…127 外并非可靠跨实现行为（JVM/实现可扩展）。

---

常见陷阱与示例

Integer a = 1000, b = 1000;
System.out.println(a == b);       // 很可能 false（不同对象）
System.out.println(a.equals(b));  // true

Integer x = 100, y = 100;
System.out.println(x == y);       // 可能 true（小整数缓存）

Integer n = null;
int m = n; // 抛出 NullPointerException（拆箱 null）

Collection<Integer> coll = new ArrayList<>();
coll.add(1); // 装箱发生（int -> Integer）

int[] a1 = new int[1000000];
Integer[] a2 = new Integer[1000000];
// a2 会在填充时产生大量 Integer 对象，内存与 GC 开销显著大于 a1

---

何时使用原始类型，何时使用包装类

• 优先使用原始类型：数值运算、循环计数、性能敏感或大规模数据（int、long、double 等），以及数组（int[]）场景。

• 使用包装类的场景：

  • 放入集合或泛型（List<Integer>、Map<String, Long>）。
  • 需要 null 表示“缺失/未知”的字段（数据库/序列化/DTO）。
  • 与反射、第三方框架或 API 需要对象类型时。
  • 需要调用包装类提供的工具方法或常量时（Integer.parseInt、Double.isNaN 等）。

---

实践与注意事项

• 在性能或内存敏感路径避免装箱/拆箱；使用原始类型数组或使用专门的原生集合库（如 Trove、HPPC，或 JDK 的 IntStream/LongStream 等替代方案）。
• 比较包装类值时使用 equals()，或拆箱后使用 ==。不要依赖缓存行为。
• 避免在Nullable 数值上进行算术或比较操作前不做 null 检查。
• 对于货币计算，使用 BigDecimal 而不是 float/double。

---

代码示例集

// 推荐：使用 List<Integer>
List<Integer> list = new ArrayList<>();
list.add(1); // 装箱发生
int sum = 0;
for (int v : list) { // 拆箱在此发生
    sum += v;
}

// 避免：大量装箱导致高开销
Integer[] boxed = new Integer[1_000_000];
for (int i = 0; i < boxed.length; i++) boxed[i] = i; // 产生 1_000_000 个 Integer 对象

// 使用原始数组节省内存
int[] prim = new int[1_000_000];
for (int i = 0; i < prim.length; i++) prim[i] = i; // 不产生额外对象