一个权限按钮,昨天点着有反应,今天换了个账号就没反应了。代码只有一行判断:当前用户的角色编号是 1 就给按钮。查了半天日志,发现没反应的是角色编号 200 的用户,而角色编号 1 的用户一直正常。

那行代码写的是 if (user.getRoleId() == 1),其中 getRoleId() 返回的是 Integer,不是 int。角色编号 1 落在 Java 的整数缓存范围里,两个 Integer 恰好指向同一个对象,比较结果是 true;编号 200 在范围外,两个值相同但对象不同,比较结果就是 false。一个看起来只在「某些账号」出错的 bug,根子却在类型上。

这篇从这类真实故障出发,把 Java 最底层的几件事说清楚:代码放在哪个包里、编译出来的东西怎么被找到、基本类型和包装类到底差在哪、== 与 equals 各自比较什么、参数是怎么传进方法的,以及 static 和 final 常被误解的地方。读完你至少能做到:看到 Integer 和 int 混用,心里会警觉。

先看现象:同一个判断,换个数就失效

把上面的场景压缩成一个能跑的小例子。两个 Integer 都等于 127,用 == 比较得到 true;都等于 128,用 == 比较得到 false。这不是编译器算错了,也不是 JVM 抽风,而是 Java 对小的整数值做了一件事:把 -128 到 127 之间的包装对象提前创建好,重复使用。

这个设计本身没有错,它在很多场景下省了内存。问题在于它让「引用相等」和「数值相等」在小数值上碰巧一致,于是错误写法在开发和测试阶段一路绿灯。上线之后,用户编号、订单号、角色编号随便一个超过 127,判断就开始随机失灵。这类 bug 最难查的地方是它不稳定:同一份代码,有的数据对,有的数据错。

只要比较的是两个对象,就要先问一句「我要比的是不是同一个对象」。如果答案其实是「值一样就算」,那就用 equals,或者干脆把类型改成 int。靠 == 在小数值上碰巧正确,是最典型的定时炸弹。

下面按顺序拆开:先弄清楚 Java 代码的组织方式,再看类型本身,最后回到这个判断上。每一节都给一段能直接运行的代码,你可以边看边对照。

Java 代码放在哪:包、源文件与 classpath

Java 的源文件以 .java 结尾,里面通常有一个和文件名同名的 public class。编译之后得到的不是可执行文件,而是 .class 文件,里面是字节码。字节码由 JVM 解释和执行,这也是 Java 能跨平台的原因:换操作系统要换 JVM,不用重写代码。JVM 是一个运行 Java 字节码的虚拟机,你可以把它想成一台专门跑 Java 的「软件机器」。

一个 Java 类从源码到运行
写 Hello.java
javac 编译
得到 Hello.class
java 启动 JVM
加载并执行字节码

package 声明这个类属于哪个包。包的作用类似文件系统的目录,主要是为了避免重名:两个团队都写了一个 User 类,只要包名不同就能共存。包名习惯上用倒过来的域名,比如 com.example.order。源文件可以放在任意目录,但编译后的 .class 要按包名放进对应目录,JVM 才找得到。

classpath 是「去哪里找类」的路径列表。运行时用 -cp 指定,找不到类就报 ClassNotFoundException 或 NoClassDefFoundError。这两个错误经常被混为一谈:前者是主动按名字加载时没找到,后者通常是编译时还在、运行时某个依赖没带上的类。排查时都要先看 classpath 和实际打包内容,而不是盯着业务代码。

动手前先把版本确认掉。本机装的是 JDK 21,命令和输出如下:

java -version
openjdk version "21.0.13.0.2" 2026-10-22 LTS
OpenJDK Runtime Environment Microsoft-15780113 (build 21.0.13.0.2+1-LTS)
OpenJDK 64-Bit Server VM Microsoft-15780113 (build 21.0.13.0.2+1-LTS, mixed mode, sharing)

javac -version
javac 21.0.13.0.2

编译和运行的完整命令是 javac -encoding UTF-8 Hello.java 与 java -cp . Hello。-encoding UTF-8 不能省:Windows 上如果源文件是 UTF-8 无 BOM,而编辑器默认按 GBK 保存或读取,中文字符串就可能变成乱码,甚至直接报「非法字符」。本机验证时还遇到另一个细节:Windows 控制台默认代码页不是 UTF-8,Java 把中文写进控制台会显示成方块。加上 -Dstdout.encoding=UTF-8 就能正常显示,这个参数只影响输出编码,不影响程序逻辑。

源文件必须是「无 BOM 的 UTF-8」。带 BOM 时 javac 会把 BOM 当成源码的一部分,报 非法字符: '\ufeff'。用 PowerShell 写测试文件时,要显式使用不带 BOM 的 UTF8Encoding,否则默认行为可能和你以为的不一样。

8 种基本类型与它们的包装类

Java 的基本类型只有 8 种,大小在所有平台上都一样,这一点和 C 语言不同。基本类型直接存值,没有对象开销;每种基本类型都有一个对应的包装类,包装类把值装进对象里,可以参与泛型、放进集合、赋值为 null。

基本类型占用取值范围或说明包装类默认值
byte1 字节-128 到 127Byte0
short2 字节-32768 到 32767Short0
int4 字节-2147483648 到 2147483647Integer0
long8 字节约 -9.2e18 到 9.2e18Long0L
float4 字节单精度浮点,约 7 位有效数字Float0.0f
double8 字节双精度浮点,约 15 位有效数字Double0.0d
char2 字节0 到 65535,UTF-16 代码单元Character'\u0000'
boolean未规定true 或 falseBooleanfalse

几个容易忽略的点:char 是 2 字节的 UTF-16 代码单元,不等于一个「汉字」或一个「字符」。一个 emoji 或部分生僻字要占两个 char,用 length() 数出来是 2,用 codePointCount() 数出来才是 1。金额、精确计数不要用 double,用 long 存最小单位(分)或者 BigDecimal。

字段(成员变量)不赋值会有默认值,局部变量不赋值则直接编译不过。这是 Java 故意设计的:局部变量必须在确定赋值后才能读,避免读到垃圾值。包装类字段的默认值是 null,不是 0,这一点下面会引出空指针。

== 与 equals:一个比地址,一个比内容

基本类型的 == 比较值,引用类型的 == 比较「是不是指向同一个对象」。equals 是 Object 类上的方法,默认实现和 == 一样比地址,但很多类重写了它,改成比内容,例如 String、Integer 和大多数集合类。

== 运算符

基本类型比值;引用类型比地址。速度快,不需要方法调用。只要出现「两个对象值一样但地址不同」的情况,它就会给出 false。适合判断是不是同一个对象、是不是 null。

equals 方法

默认也比地址,但被重写后按业务含义比内容。调用前要保证接收者不是 null,或者用 Objects.equals(a, b) 把 null 也处理掉。需要和 hashCode 保持一致,否则放进哈希集合会出问题。

先看一段实际跑出来的结果:

String a = "hello";
String b = "hel" + "lo";
String c = new String("hello");
System.out.println(a == b);
System.out.println(a == c);
System.out.println(a.equals(c));
true
false
true

第一行是 true,因为 "hel" + "lo" 在编译期就被拼成了常量 "hello",直接复用字符串常量池里的同一个对象。第二行是 false,因为 new String("hello") 一定在堆上新建一个对象,哪怕内容一模一样。第三行是 true,因为 equals 逐字符比较内容。

字符串常量池是 JVM 里专门放字面量字符串的一块区域。用双引号写出来的字符串会自动进去,相同内容的字面量指向同一个对象;new String(...) 则强制在堆上另建一个。把运行时拼出来的字符串放进池子,可以调用 intern(),但不要拿它当常规优化手段,池子的回收行为不受你控制。

实际开发里更常见的错误是用 == 比较从接口、数据库或配置里读出来的字符串。这些字符串大多是运行时创建的,地址不保证相同,所以偶尔对、偶尔错。判断字符串相等,统一用 equals,并且把常量写在前面,例如 "ok".equals(status),这样 status 是 null 也不会抛异常。

重写 equals 有五条约定,最实用的两条是:相等的对象 hashCode 必须相同;equals 必须满足自反、对称、传递。只重写 equals 不重写 hashCode,对象放进 HashMap 后可能查不出来,因为哈希值对不上,落到了别的桶里。

Integer 缓存:为什么 127 对、128 错

回到开头的 bug,把相关代码跑一遍:

Integer small1 = 127, small2 = 127;
Integer big1 = 128, big2 = 128;
System.out.println(small1 == small2);
System.out.println(big1 == big2);
System.out.println(big1.equals(big2));

Integer boxed = null;
int v = boxed;
true
false
true
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "java.lang.Integer.intValue()" because "boxed" is null
	at JavaUnbox.main(JavaUnbox.java:4)

前两行就是缓存的效果。Integer.valueOf(127) 返回缓存里的对象,两次调用拿到同一个;Integer.valueOf(128) 每次新建,地址不同。注意第三行仍然 true,说明值确实相等,错的只是比较方式。第四行的异常信息是 JDK 21 的「有帮助的空指针」:它直接告诉你在哪个变量上、调用了哪个方法,比旧版本那句只有行号的空指针好查很多。

缓存范围由 java.lang.Integer.IntegerCache.high 控制,默认上限 127,下限固定 -128。可以通过启动参数调大上限,但不要依赖这个行为:不同 JDK、不同启动参数下结果可能不同,代码一旦依赖缓存,就变成了环境相关。

自动拆箱是编译器帮你加的一步:把 Integer 转成 int 时调用 intValue(),Integer 为 null 就抛空指针。下面这些写法都会触发:把包装类直接赋给基本类型、包装类参与算术运算、包装类和基本类型比较、三元表达式两边一个是包装类一个是基本类型。

Integer total = null;
total = total + 1;

Map<String, Integer> counts = new HashMap<>();
int current = counts.get("missing");

第二段更隐蔽:get 返回 Integer,赋给 int 时自动拆箱,键不存在就拿到 null,立刻空指针。正确写法是先判空,或者用 getOrDefault("missing", 0)。这类错误在「本地数据齐全」时永远不会出现,一到线上有缺失数据就爆。

还有两个数值陷阱,跑出来的结果如下:

int max = Integer.MAX_VALUE;
System.out.println(max + 1);
System.out.println(7 / 2);
System.out.println(0.1 + 0.2);
-2147483648
3
0.30000000000000004

整数溢出不会抛异常,会静默回绕成负数。算时间戳、文件大小、分页偏移时都可能踩到,需要更大范围就用 long,需要「溢出就报错」就用 Math.addExact。整数除法会直接截断小数,7 / 2 是 3 不是 3.5;要得到小数,至少有一个操作数得是浮点,例如 7 / 2.0。浮点数用二进制表示十进制小数,0.1 和 0.2 都无法精确表示,相加就有了尾差,所以金额计算不能用 double。

值传递、static 与 final:三个常见误解

Java 只有值传递,没有引用传递。方法调用时,实参的值被复制一份给形参。基本类型复制的是数值;对象复制的是「指向对象的引用」,也就是地址。所以方法里改对象的内容,调用方看得到;但方法里把形参重新指向另一个对象,调用方看不到。

static void fill(int[] arr) { arr[0] = 99; }
static void rebind(StringBuilder sb) { sb = new StringBuilder("换掉了"); }

int[] nums = {1, 2, 3};
fill(nums);
System.out.println(nums[0]);

StringBuilder sb = new StringBuilder("原对象");
rebind(sb);
System.out.println(sb);
99
原对象

数组的内容被改了,因为 arr 和 nums 指向同一个数组对象。而 sb 在方法里被重新赋值,只是让形参指向了新对象,调用方的变量还指着旧对象。很多人把第二个现象解释成「String 不可变」或「对象传引用」,都不准确;准确说法是「引用的值被复制了」。

static 表示这个成员属于类,不属于某个实例。静态字段被所有实例共享,改一处,所有地方都看到。它适合放常量、无状态工具方法,不适合放「每个用户各自一份」的数据。final 表示只能赋值一次:final 修饰基本类型,值不能再变;修饰引用,引用不能再指向别的对象,但对象内部仍然可以改。

基本类型变量变量里直接存数值。赋值就是改这个数值,复制就是复制这个数值。
引用类型变量变量里存的是对象地址。复制变量复制的是地址,两个变量指向同一个对象。
对象本身放在堆上,有对象头、字段和可能的对齐填充。对象不会跟着变量一起被复制,除非显式克隆或新建。

构造器的执行顺序也值得记一笔:先分配对象内存并把字段置默认值,再执行父类构造器,然后执行本类的字段初始化和构造器代码,最后回到子类继续。如果父类构造器里调用了可被子类重写的方法,子类字段还没初始化,读到的就是默认值。这类问题不会天天出现,但一旦出现,表现是「字段莫名其妙是 0 或 null」。

出问题时先看哪里

下面这张表把本篇涉及的现象集中起来。每一条都在真实项目里出现过,排查时按「先分层、再看类型」的顺序走。

现象真实原因第一步查什么
同一段判断,有的数据对有的错用 == 比较了两个包装类对象,小数值命中缓存,大数值没有看比较双方声明的类型;把 == 换成 equals,或统一改成基本类型
偶尔抛出 NullPointerException,堆栈指向一行普通赋值包装类为 null,赋值或运算时自动拆箱看异常信息里的变量名;查这个值来自 Map.get、接口返回还是数据库空列
金额算出来差几分钱用 double 或 float 表示十进制小数,二进制无法精确表示看字段类型;改用 BigDecimal 或 long 存分
时间戳或文件大小变成负数int 溢出后静默回绕看参与运算的类型;换成 long,关键计算用 Math.addExact
调用方法后,传入的对象被改了,调用方也变了传的是引用,方法内修改了同一个对象的内容确认方法是否修改入参;需要隔离就传副本或不可变对象
方法里给参数重新赋值,调用方没变化Java 只有值传递,形参只是引用的副本看方法是否返回新对象;需要改变调用方就通过返回值
两个实例互相影响,改一个另一个也变字段被声明成 static,被所有实例共享查字段修饰符;确认这个数据是不是应该每个实例一份
ClassNotFoundException 或 NoClassDefFoundError运行时 classpath 缺类,或打包时依赖没带上打印实际 classpath;检查构建产物的依赖目录和启动脚本

这张表背后的判断顺序是:先看值是不是 null,再看类型是基本类型还是包装类,最后看比较方式。三步走完,大部分「时好时坏」的问题都能定位。不要一上来就怀疑并发或 JVM,先排除类型问题,成本最低。

边界与代价

这套类型系统有明确的好处:基本类型大小固定,跨平台结果一致;包装类让基本类型能参与泛型和集合;值传递规则简单,不会出现「传进去的变量被改指向」。但代价也要提前知道。

  • 装箱有开销:每次把 int 装进 Integer 都可能创建对象。在百万次循环里频繁装箱,内存和 GC 压力都会上来,能用手写循环加基本类型的地方就别用 Stream<Integer> 硬凑。
  • 缓存是实现细节:-128 到 127 的缓存不是语言规范强制的行为,依赖它等于依赖 JDK 实现。代码正确性不应该建立在缓存上。
  • equals 可能为空:调用 a.equals(b) 前必须保证 a 不是 null。推荐 Objects.equals(a, b),或者把常量放前面。
  • 没有无符号类型:Java 的整数都是有符号的。需要处理无符号 32 位值时,只能用 long 或 Integer.toUnsignedLong 这类方法,别自己拿 int 硬扛。
  • char 不是字符:它是 UTF-16 代码单元。处理中文、emoji、生僻字时,按 char 遍历可能把一个字符拆成两半,要用 code point 相关 API。

最后提醒一句:final 不等于不可变。一个 final List 只是不能重新赋值,里面的元素照样能增删改。需要真正不可变,得用 List.of 这类不可变集合,或者自己保证不暴露修改入口。

当天能自己验证的练习

  1. 写一个类,分别用 Integer 的 127 和 128 做 == 比较,打印两次结果。再把类型换成 int,确认两次都是 true,理解差别来自类型而不是数值。
  2. 把 Integer boxed = null; int v = boxed; 放进 main,先直接运行看异常信息,再用 javac -g 重新编译,对比异常信息里变量名的变化。
  3. 用 System.out.println(0.1 + 0.2) 和 System.out.println(new BigDecimal("0.1").add(new BigDecimal("0.2"))) 各跑一次,观察两种结果的差别。
  4. 写一个方法接收 int[] 并修改第一个元素,另一个方法接收 StringBuilder 并重新赋值,分别打印调用方看到的结果,验证「改内容」和「改指向」的区别。
  5. 用 javac -encoding UTF-8 编译一个带中文注释和字符串的类,再用 java -Dstdout.encoding=UTF-8 运行;然后去掉参数再跑一次,观察控制台输出的变化。

小结

三句话收一下:Java 的引用类型变量存的是地址,== 比地址,equals 才比内容;包装类为 null 时参与运算会自动拆箱并抛出空指针;Java 只有值传递,方法改的是对象内容,改不了调用方的指向。

下一篇讲语言特性:泛型、注解、record 和 lambda。今天你已经看到「类型」能制造多少麻烦,接下来会看到编译器如何在编译期帮你挡掉一部分,又在运行时因为类型擦除把哪些检查悄悄放过。