Java中equals()方法实现为何始终先执行自引用检查？即使该步骤看似冗余

Great question! It’s totally valid to wonder why this seemingly redundant check is included in almost every equals() implementation—after all, if this and o are the same reference, the subsequent property checks will also return true. Let’s break down the key reasons:

1. Performance Optimization (The Big One) #

This is the primary motivation. Checking reference equality is an extremely fast operation (it’s just comparing memory addresses under the hood). If we can short-circuit the rest of the equals() logic here, we avoid the overhead of:

• Checking the class type of o
• Casting o to the current class
• Comparing every single property of the object (which can get expensive if you have many properties, or properties that require their own costly equals() checks—like long strings, nested objects, or collections)

In real-world code, comparing an object to itself is more common than you might think (e.g., adding an object to a collection and then checking if it’s present, or accidental self-comparisons in loops). Skipping the full property check in these cases saves valuable CPU cycles.

2. Avoiding Potential Exceptions #

While your example’s User class doesn’t have this issue, some equals() implementations might have property checks that could throw exceptions if they run on the same object reference. For example:

• If a property is null, calling property.equals(other.property) would throw a NullPointerException—but if this == o, we never reach that line.
• Even with null-safe checks like Objects.equals(), avoiding unnecessary method calls still eliminates tiny bits of overhead.

The reference check acts as a safety net to bypass any risky or costly property comparisons entirely when we already know the objects are identical.

3. Code Convention & Readability #

This check has become a standard part of equals() implementations across Java codebases. Most IDEs (IntelliJ, Eclipse, etc.) automatically include it when generating equals() methods, and experienced developers expect to see it. It makes the intent clear at a glance: "If this is the exact same object, it’s definitely equal—no need to check anything else."

This consistency helps other developers read and maintain your code without having to think through whether self-comparison is handled later.

内容的提问来源于stack exchange，提问作者mason