← 课程目录 🚀 从零到一
📐 学习维度 阶段1 · 第3章 面向对象 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

3.5 常见坑:== 与 equals、null 判断

审校 2026-09-26 · 素材来源:面试题库Q04-Java基础与面向对象(底稿改写)
📑 本篇章节导航 (共14节,点击直达)
== 比的是什么equals 比的是什么字符串的常量池陷阱重写 equals 必须带上 hashCodeInteger 的 -128 到 127null:空指针的头号来源三目运算符的拆箱暗坑equals 的四条契约一个真实剧本:订单去重失灵装箱的性能账防御式编程的日常清单null 从哪来:治理源头优于到处设防踩坑清单一句话总结

两类 bug 占了新手线上事故的大头:明明内容一样,比较却是 false;明明看着有值,一跑就空指针。前者没分清 == 和 equals,后者没防好 null。这篇把两个坑一次填平。

== 比的是什么

一句话:基本类型比值,引用类型比地址。


int a = 10, b = 10;
a == b;                 // true,比的就是数值

Student s1 = new Student("张三");
Student s2 = new Student("张三");
s1 == s2;               // false!两栋不同的房子,长得再像也不是同一栋

equals 比的是什么

equals 是 Object 的方法,默认实现就是 ==(比地址)。但 String、Integer 这些类重写了它,改成「比内容」:


s1.equals(s2);                        // false:Student 没重写,还在比地址

String x = new String("hi");
String y = new String("hi");
x == y;                               // false:两个对象
x.equals(y);                          // true:String 重写了 equals,比内容

结论:对象判等,一律 equals;== 留给基本类型和「是不是同一个对象」这种特殊问题。

字符串的常量池陷阱

String 有个特殊待遇:常量池(放字符串字面量的缓存区,4.1 节细讲)。直接赋值走池、new 走堆,== 的结果就开始玄学:


String a = "hi";
String b = "hi";
a == b;                 // true:字面量进常量池,a b 指向同一个

String c = new String("hi");
a == c;                 // false:new 在堆里新建了对象
a.equals(c);            // true:内容相同

背下这张对照:字面量 == 字面量,看池子给不给同一个;其他一律 equals。面试爱考,生产更多是暗坑——比如把字符串 == 写进了 if 判断,测试环境全过(恰好都是字面量),上线偶尔 false。

重写 equals 必须带上 hashCode

自己写的类想按内容判等,就重写 equals。但必须同时重写 hashCode,否则 HashMap、HashSet 全部失灵:


class Student {
    String name;
    Student(String name) { this.name = name; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        return name.equals(((Student) o).name);
    }

    @Override
    public int hashCode() { return name.hashCode(); }   // 等价对象必须同码
}

原因:HashSet 先按 hashCode 找格子,再用 equals 认人。只重写 equals 的话,两个「相等」的对象算出不同 hash,被分进不同格子,contains 永远说 false。IDE 一键生成两个方法,永远成对写。规范上 equals 还要满足自反、对称、传递、一致四条,生成的代码基本不用操心。

Integer 的 -128 到 127

自动装箱时 IntegerCache 会缓存 -128 到 127 的对象,这个区间 == 恰好为 true,区间外必 false:


Integer a = 127, b = 127;
a == b;                 // true,命中缓存同一个对象

Integer c = 128, d = 128;
c == d;                 // false,超出缓存各造各的

最险的是它「偶尔对」:小数值测试全过,大金额生产报错。包装类型判等,equals 或者先拆成基本类型。

null:空指针的头号来源

NPE(NullPointerException,空指针异常)的惯犯有四个:


order.getUser().getName();        // ①链式调用,中间一环为 null 当场炸
int age = user.getAge();          // ②自动拆箱,Integer 为 null 时炸
map.get("key").trim();            // ③ get 没找到返回 null
str.equals("A");                  // ④ str 为 null 时炸

对应的防守姿势:


// ① 常量放前面,或用工具类
"A".equals(str);                       // 常量在前永不怕 null
Objects.equals(a, b);                  // 工具类,双 null 也安全

// ② 拆箱前判空
Integer age = user.getAge();
if (age != null) { int v = age; }

// ③ 返回集合别返回 null,调用侧给默认值
map.getOrDefault("key", "默认值");

// ④ 入口处快速失败
this.name = Objects.requireNonNull(name, "name 不能为空");

更现代的层层判空写法是 Optional(5.3 节),此处先记住两条铁律:字段能不 null 就给默认值;判空永远在解引用之前。

三目运算符的拆箱暗坑

条件表达式两分支一边基本类型、一边包装类型时,包装那边会自动拆箱;它要是 null,当场空指针:


Integer bonus = user.getLevel() >= 3 ? user.getBonus() : 0;
// getBonus() 返回 null 时,为了和 0 对齐被拆箱,炸

阴险在代码看着人畜无害。守则一条:两个分支都用包装类型或都用基本类型,别混。顺带把概念说全:int 变 Integer 是装箱,Integer 变 int 是拆箱,编译器偷偷调 valueOf 和 intValue。凡是混用的地方,多问一句「这边会不会是 null」。

equals 的四条契约

重写 equals 不是随便写个比较,它对外承诺四条:自反(自己等于自己)、对称(a 等于 b,则 b 也等于 a)、传递(a=b 且 b=c,则 a=c)、一致(字段没改,多次比较结果不变)。外加一条硬规定:equals 相同,hashCode 必须相同。IDE 生成的模板天然满足;手写最容易在继承上破掉对称——父类对象和子类对象互相 equals,方向不同结果不同。所以能用工具生成就别手搓。

一个真实剧本:订单去重失灵

场景:两分钟内重复提交的订单要拦。同事用 HashSet<Order> 装「订单号+用户」判断重复,测试全过,上线后重复单照来。排查发现 Order 重写了 equals 忘了 hashCode:两个内容相同的订单被 hash 到不同格子,contains 永远说 false,拦截形同虚设。补上 hashCode 复测,重单才拦住。

这个剧本的教训不止「成对重写」:contains 的行为是 equals 和 hashCode 合伙定的,少一个就悄悄变味——不报错、不抛异常,只输出错误的结果。这类静默 bug 比崩溃更危险,得靠单元测试守着,第 10 章测试篇接上这段。

装箱的性能账

高并发计数场景,int 比 Integer 快得多:Integer 在缓存区间外每次装箱都 new 对象,内存和 GC 双重开销。JDK 专门的 LongAdder、AtomicLong 就是为绕开这笔账设计的,第 7 章见。平时的选型直觉很简单:字段能用基本类型就用基本类型,包装类型只用在「必须接受 null」的场合——数据库可空字段、接口可缺省参数。

防御式编程的日常清单

把这篇的防守招数收成清单,写代码时过一遍:

这套动作的价值在「便宜」二字:每条都是一两行的事,而修一个线上 NPE 要复盘、回滚、补数据。防御不是胆小,是把事故成本提前付清。

null 从哪来:治理源头优于到处设防

防 null 防得辛苦,常因为 null 是自己请进来的。三个惯犯源头:数据库字段允许 null,查出来直接塞进对象;map.get 没找到自动返回 null;方法走到没考虑的分支,返回值忘了赋。对应的源头治理:表设计时字段尽量 not null 加默认值;取值换 getOrDefault;返回值先初始化再改。

防 null 最便宜的位置不是调用处,而是生产 null 的地方——源头堵住了,下游一大片判空代码直接消失。「治理源头优于到处设防」这个思路,以后排查一切问题都通用。

踩坑清单

一句话总结

== 比地址、equals 比内容,重写 equals 必须成对带上 hashCode;null 要在解引用前防——常量前置、Objects 工具、getOrDefault 兜底,三板斧够用。