Java Integer Comparison: Why Does `==` Sometimes Fail, and When Should I Use `.equals()`?

Java: Integer Equality Conundrum - equals vs. ==

While integers and their corresponding wrapper class, Integer, can often be used interchangeably, a peculiar behavior has been encountered when comparing two Integer values using the equality operator (==).

Unexpected Result

Consider the following code snippet:

Integer cdiCt = ...;
Integer cdsCt = ...;
...
if (cdiCt != null && cdsCt != null && cdiCt != cdsCt)
    mismatch = true;

Surprisingly, this conditional appeared to incorrectly set mismatch to true even when the underlying values of cdiCt and cdsCt were equal (e.g., both containing the value 137).

Autoboxing Issue

The culprit behind this puzzling behavior lies in Java's autoboxing mechanism. When comparing primitives (e.g., int) with their corresponding wrapper classes (e.g., Integer), autoboxing automatically converts the primitive to its wrapper object. However, this conversion introduces a subtle complication.

JVM Caching

For performance reasons, the JVM caches Integer values between -128 and 127. When creating an Integer object within this range, the JVM simply returns the cached instance instead of creating a new one. This caching mechanism ensures that all references to the same primitive value (within the cached range) point to the same Integer instance.

== Comparison Failure

When comparing two Integer objects using the equality operator (==), Java checks if they refer to the same object in memory. If they do, the comparison returns true; otherwise, it returns false. However, when comparing two Integer objects that are both within the cached range and hold the same primitive value, they will reference the same cached instance, leading to a false positive in the == comparison.

Solution: Use equals Method

To avoid this issue, it is recommended to use the equals method when comparing Integer objects. The equals method performs a value-based comparison, ensuring that two Integer objects are considered equal only if they have the same primitive value.

if (cdiCt != null && cdsCt != null && !cdiCt.equals(cdsCt))
    mismatch = true;

Conclusion

While using == to compare Integer objects within the cached range (-128 to 127) may appear to work, it can lead to unexpected results. To ensure reliable equality comparisons, always utilize the equals method instead.

The above is the detailed content of Java Integer Comparison: Why Does `==` Sometimes Fail, and When Should I Use `.equals()`?. For more information, please follow other related articles on the PHP Chinese website!