In Java, developers often encounter situations where they need to compare objects for equality. However, understanding the nuances between using the == operator and the .equals() method is crucial for writing correct and efficient code. This article delves into the relationship between these two approaches in the java.lang package, providing insights into their differences, similarities, and best practices.

Understanding the == Operator

The == operator in Java is primarily used for comparing primitive data types and object references. When applied to primitive types such as int, double, or char, it compares their values directly. For example:

int a = 5;
int b = 5;
boolean result = (a == b); // result will be true

However, when it comes to objects, the == operator behaves differently. It compares object references rather than their actual contents. Two object references are considered equal if they point to the same memory location, i.e., if they refer to the same object instance. For instance:

String str1 = new String("softAai");
String str2 = new String("softAai");
boolean result = (str1 == str2); // result will be false

Here, str1 and str2 point to different memory locations, even though their contents are the same. Therefore, the == operator returns false.

Understanding the .equals() Method

In Java, the .equals() method is used to compare the contents of objects for equality. The java.lang.Object class, which is the root class for all Java classes, provides a default implementation of the .equals() method. This default implementation compares object references similar to the == operator.

However, many classes in Java override the .equals() method to provide custom equality comparison based on the contents of objects rather than their references. For example, the String class overrides the .equals() method to compare the actual string contents:

String str1 = new String("Hello");
String str2 = new String("Hello");
boolean result = str1.equals(str2); // result will be true

In this case, the .equals() method compares the contents of str1 and str2, resulting in true since they contain the same string.

Relation between == Operator and .equals() Method

The relationship between the == operator and the .equals() method can be summarized as follows:

• If two objects are determined to be equal by the == operator, it’s guaranteed that they will also be equal when compared using the .equals() method.
  • This means that if r1 == r2 evaluates to true, then r1.equals(r2) will always be true as well.

• However, if two objects are not deemed equal by the == operator, we cannot make any assumptions about the outcome of the .equals() method. It may return either true or false.
  • In other words, if r1 == r2 evaluates to false, r1.equals(r2) may return true or false, and we cannot predict the exact result.

• Similarly, if two objects are determined to be equal by the .equals() method, we cannot infer anything about the == operator. It may return true or false.
  • So, if r1.equals(r2) is true, then r1 == r2 may return true or false, and we cannot determine the exact outcome.

• Conversely, if two objects are not equal according to the .equals() method, they will always not be equal when compared using the == operator.
  • Therefore, if r1.equals(r2) evaluates to false, then r1 == r2 will always be false as well.

Example

String s1 = new String("softAai");
String s2 = new String("softAai");
StringBuffer sb1 = new StringBuffer("softAai");
StringBuffer sb2 = new StringBuffer("softAai");

System.out.println(s1 == s2);  //false
System.out.println(s1.equals(s2)); //true
System.out.println(sb1 == sb2);  //false
System.out.println(sb1.equals(sb2)); //false
// System.out.println(s1 == sb1);  //CE: incomparable types: java.lang.String and java.lang.StringBuffer
System.out.println(s1.equals(sb1)); //false

Note: To use the == operator, there must be some relation between argument types (either child to parent, parent to child, or the same type); otherwise, we will get a compilation error saying “incomparable types.” If there is no relation between argument types, then the .equals() method won’t raise any runtime or compile-time errors; it simply returns false.

Differences between the == operator and .equals() method

The differences between the == operator and .equals() method can be summarized as follows:

== operator

• It is an operator applicable for both primitives and object types
• In the case of object references, the == operator is meant for reference comparison, which entails comparing memory addresses.
• We can’t override the == operator for content comparison
• To use the == operator, there must be a relationship between the argument types (either child to parent, parent to child, or the same type); otherwise, we will receive a compile-time error indicating “incomparable types.”

.equals() method

• It is a method applicable only for object types and not for primitives.
• By default, the .equals() method present in the object class is also intended for reference comparison.
• We can override the .equals() method for content comparison.
• If there is no relation between argument types, then .equals() won’t raise any compile-time or runtime errors and simply returns false.

In general, use the == operator for reference comparison and .equals() for content comparison;

For any object reference “r,”

both “r == null” and “r.equals(null)” always return false.

// Example:
Thread t = new Thread();
System.out.println(t == null); // false
System.out.println(t.equals(null)); // false

Also, one more thing,

Hashing-related data structures follow the following fundamental rules:

Two equivalent objects should be placed in the same bucket, but not all objects present in the same bucket need to be equal.

Contract between .equals() and hashCode()

If two objects are equal by the .equals() method, then their hashcodes must be equal; that is, two equivalent objects should have the same hashcode. Therefore, if “r1.equals(r2)” is true, then “r1.hashCode() == r2.hashCode()” is always true. The Object class’s .equals() and hashCode() methods follow these contracts; hence, whenever we override .equals(), it is compulsory to override hashCode() to satisfy these contracts. This ensures that two equivalent objects have the same hashcode.

If two objects are not equal by .equals(), then there are no restrictions on their hashcodes; they may be equal or not equal. If the hashcodes of two objects are equal, we cannot conclude anything about .equals(); it may return true or false. However, if the hashcodes of two objects are not equal, then these objects are always not equal by the .equals() method.

Note: To satisfy the contract between equals and hashCode methods, whenever we are overriding .equals(), it is compulsory to override the hashCode method; otherwise, we won’t get any compile-time or runtime error, but it is not a good programming practice.

In the String class, .equals() is overridden for content comparison, hence the hashCode method is also overridden to generate a hashcode based on content. For example:

String s1 = new String("softAai");
String s2 = new String("softAai");
System.out.println(s1.equals(s2)); // true
System.out.println(s1.hashCode()); // 95950491
System.out.println(s2.hashCode()); // 95950491

In the StringBuffer class, .equals() is not overridden for content comparison, and hence the hashCode method is also not overridden. For example:

StringBuffer sb1 = new StringBuffer("softAai");
StringBuffer sb2 = new StringBuffer("softAai");
System.out.println(sb1.equals(sb2)); // false
System.out.println(sb1.hashCode()); // 19621457
System.out.println(sb2.hashCode()); // 4872882

It is highly recommended to override the hashCode() method. In all collection classes, in all wrapper classes, and in the String class, .equals() is overridden for content comparison; hence, it is highly recommended to override .equals() as well for content comparison.

Best Practices

To ensure correctness and efficiency in your Java code, consider the following best practices:

1. Use the == operator for primitive types and object reference comparison.
2. Use the .equals() method for comparing the contents of objects, especially when dealing with strings, arrays, and custom classes.
3. Override the .equals() method in custom classes to provide meaningful content comparison.
4. Be cautious when comparing objects of different types, as the behavior of == and .equals() may vary depending on the implementation.

Conclusion

Understanding the relationship between the == operator and the .equals() method is essential for writing robust and efficient Java code. By knowing when to use each approach and following best practices, developers can ensure correct object comparison and avoid common pitfalls. Whether comparing object references or their contents, choosing the appropriate method is key to achieving desired behavior in Java applications.