从字节码视角拆解 Java 中 "==" 与 equals() 的底层判定逻辑

在 Java 中，"==" 操作符和 equals() 方法用于比较对象，但其底层逻辑有本质区别。以下从 Java 字节码（JVM 指令）视角逐步拆解其底层判定机制。字节码是 JVM 执行的中间代码，通过反汇编工具（如 javap）可查看。分析基于 Java 规范，确保逻辑真实可靠。

1. "==" 操作符的字节码逻辑

"==" 在 Java 中分为两类：基本类型比较值和引用类型比较内存地址。字节码指令直接对应此行为。

• 基本类型（如 int, char）：

  • 字节码使用数值比较指令，如 if_icmpeq（比较两个 int 值是否相等）。
  • 示例代码：

    int a = 10;
    int b = 10;
    boolean result = (a == b); // true
    

  • 字节码反汇编（简化）：

    bipush 10     // 将常量 10 压入栈
    istore_1      // 存储到变量 a
    bipush 10     // 同上
    istore_2      // 存储到变量 b
    iload_1       // 加载 a 的值
    iload_2       // 加载 b 的值
    if_icmpeq L1  // 比较栈顶两个 int 值：相等则跳转到 L1（true）
    iconst_0      // 否则压入 false
    goto L2
    L1: iconst_1  // 压入 true
    L2: istore_3  // 存储结果
    

  • 核心逻辑：if_icmpeq 直接比较栈中的数值，不涉及对象元数据。

• 引用类型（如 Object, String）：

  • 字节码使用引用比较指令 if_acmpeq（比较两个引用是否指向同一内存地址）。
  • 示例代码：

    String s1 = "hello";
    String s2 = new String("hello");
    boolean result = (s1 == s2); // false，不同对象
    

  • 字节码反汇编（简化）：

    ldc "hello"   // 加载字符串常量到栈
    astore_1      // 存储到 s1
    new String    // 创建新 String 对象
    dup           // 复制引用
    ldc "hello"   // 加载常量
    invokespecial #<String 构造方法> // 调用构造方法
    astore_2      // 存储到 s2
    aload_1       // 加载 s1 的引用
    aload_2       // 加载 s2 的引用
    if_acmpeq L1  // 比较引用地址：相等则跳转 L1
    iconst_0      // 否则压入 false
    goto L2
    L1: iconst_1  // 压入 true
    L2: istore_3  // 存储结果
    

  • 核心逻辑：if_acmpeq 仅检查两个引用是否指向同一堆内存地址，不比较对象内容。

2. equals() 方法的字节码逻辑

equals() 是 Object 类的方法，默认行为与 "==" 相同，但可被覆盖以比较内容。字节码涉及方法调用和实现。

• 方法调用：

  • 使用 invokevirtual 指令动态调用 equals() 方法，基于对象的实际类型。
  • 示例代码：

    String s1 = "hello";
    String s2 = new String("hello");
    boolean result = s1.equals(s2); // true，内容相同
    

  • 字节码反汇编（简化）：

    aload_1        // 加载 s1 的引用
    aload_2        // 加载 s2 的引用
    invokevirtual #<String.equals> // 调用 equals 方法
    istore_3       // 存储结果
    

  • 核心逻辑：invokevirtual 触发方法分派，实际执行取决于对象的类。

• 默认实现（Object 类）：

  • Object.equals() 的字节码本质使用 "==" 比较引用。
  • 反汇编 Object.equals()（伪代码）：

    aload_0        // 加载 this 引用
    aload_1        // 加载参数 obj 引用
    if_acmpne L1   // 比较引用：不等则跳转 L1（返回 false）
    iconst_1       // 否则压入 true
    ireturn        // 返回
    L1: iconst_0   // 压入 false
    ireturn
    

  • 结果：默认行为与 if_acmpeq 相同，仅比较地址。

• 覆盖实现（如 String 类）：

  • String.equals() 覆盖后比较字符内容，字节码包含循环和字符比较。
  • 反汇编 String.equals()（简化）：

    aload_0        // this 引用
    aload_1        // obj 引用
    if_acmpeq L_true // 先比较地址：相同则返回 true
    instanceof String // 检查 obj 是否为 String
    ifeq L_false   // 不是则返回 false
    aload_1        // 加载 obj
    checkcast String // 强制转型
    astore_2       // 存储
    aload_0        // 加载 this.value (char[])
    aload_2        // 加载 obj.value (char[])
    if_acmpne L_loop // 若数组引用不同，进入循环比较
    ...            // 循环比较每个字符（使用 if_icmpeq）
    L_true: iconst_1
    ireturn
    L_false: iconst_0
    ireturn
    

  • 核心逻辑：先快速检查地址（优化），再逐字符比较内容，涉及多次 if_icmpeq 指令。

3. 关键区别总结（字节码视角）

• "=="：
  • 基本类型：直接数值比较（if_icmpeq 等）。
  • 引用类型：直接地址比较（if_acmpeq），指令简单高效。
• equals()：
  • 调用：动态分派（invokevirtual），成本较高。
  • 实现：默认使用地址比较（同 "=="），覆盖后可能涉及复杂逻辑（如循环比较）。
• 性能与风险：
  • "==" 恒定 $O(1)$ 时间，但引用比较可能误判（如不同 String 对象相同内容）。
  • equals() 可能 $O(n)$ 时间（如 String 比较），但可确保语义正确。

通过字节码分析，可见 "==" 是 JVM 原生操作，而 equals() 依赖方法覆盖，开发者应根据需求选择。示例代码可通过 javap -c 验证。