Difference Between .equals() and == in Java
Have you ever wondered about the difference between .equals() and == in Java? While == is used for comparing references or primitive values to see if they point to the same object or have the same value, .equals() is designed to compare the contents or state of two objects, offering a deeper level of equality checking that can be customized in user-defined classes. Let's understand more!
In Java .equals() and == are both used for comparison, but they serve different purposes and work in distinct ways. In this blog, we will understand the major differences between them in detail!
Read LaterBest-suited Java courses for you
Learn Java with these high-rated online courses
Difference Between .equals() and == in Java
Below is a table differentiating between .equals() and == in Java.
| Aspect |
== |
.equals() |
| Purpose |
Used to compare primitives or check if two references point to the same object. |
Used to compare the content or state of two objects. |
| Usage |
For primitive data types, it compares the values. For object references, it compares the reference locations (memory addresses). |
Compares the values stored in two objects, based on the implementation of the .equals() method in the object's class. |
| Default Behavior |
For objects, checks reference equality. For primitives, checks value equality. |
In the Object class, it behaves the same as ==, checking reference equality. However, it is often overridden in child classes to check content equality. |
| Overridable |
No, == is an operator and its behaviour cannot be changed. |
Yes, Classes can override the .equals() method to define their own criteria for equality. |
| Primitive Comparison |
Applicable and compares values directly. |
Not applicable directly to primitives. Primitives must be wrapped as objects (e.g., Integer, Character) to use .equals(). |
| Object Comparison |
Checks if two reference variables point to the same object instance. |
Checks if the contents of two objects are logically equivalent, depending on the implementation of .equals(). |
What is .equals() in Java?
The .equals() method in Java is used to compare two objects for equality based on the data or content of the objects rather than their reference identities. By default, the .equals() method in the Object class compares the memory addresses or references of the objects, essentially checking if the two references point to the same object in memory. However, the .equals() method is often overridden in user-defined classes to perform a content-based comparison, checking if the data within two objects is the same.
For example,
In the String class .equals() is overridden to compare the sequence of characters in two strings. If the sequences of characters are the same .equals() returns true; otherwise, it returns false.
Example demonstrating its use:
String str1 = "hello";String str2 = "hello";String str3 = new String("hello");
// Using .equals() to compare content of stringsboolean result1 = str1.equals(str2); // true, because their contents are the sameboolean result2 = str1.equals(str3); // true, even though str3 is a different object
System.out.println(result1); // Outputs trueSystem.out.println(result2); // Outputs true
This behaviour is particularly useful when you need to compare the values of objects for equality rather than their identities, which is what the == operator does by default.
What is == in Java?
The == operator in Java is used to compare the references of two objects, not their contents. It checks whether two references point to the same object in memory, meaning it's used to determine if two variables refer to the same object instance.
For primitive data types (like int, char, float, etc.), the == operator compares the values stored in the variables. However, for objects, it compares the memory addresses or references of the objects, not the actual data or contents of the objects.
Example to illustrate its use with objects:
String str1 = "hello";String str2 = "hello";String str3 = new String("hello");
// Using == to compare referencesboolean result1 = str1 == str2; // true, because they refer to the same instance in the string poolboolean result2 = str1 == str3; // false, because str3 is a new object with a different memory address
System.out.println(result1); // Outputs trueSystem.out.println(result2); // Outputs false
An example with primitive data types:
int a = 5;int b = 5;
// Using == to compare primitive valuesboolean result = a == b; // true, because the values of a and b are the same
System.out.println(result); // Outputs true
Thus, the == operator is straightforward and efficient for comparing primitive values or checking if two variables refer to the exact same object instance. However, for object content comparison, it's recommended to use the .equals() method, as it can be overridden to compare the data within the objects.
Check out Java Courses here to learn more!
FAQs
What is the fundamental difference between .equals() and == in Java?
In Java, == is an operator that compares the references or memory addresses of objects to determine if they are the same, whereas .equals() is a method that compares the contents of the objects to check for value equality.
How does == behave with primitive types compared to .equals()?
For primitive types like int, char, float, etc., == compares the actual values, since primitives do not have methods. The .equals() method is not applicable to primitives directly; it is used with objects.
Can .equals() be overridden, and how does it affect comparison?
Yes, .equals() can be overridden. By default, the .equals() method in the Object class compares the references, just like ==. However, it can be overridden to compare the actual content or state of an object, as done in classes like String, Integer, etc.
Why does == return false when comparing two distinct String objects with the same content?
The == operator compares the memory addresses of the two String objects. If they are two distinct objects (i.e., not interned strings), they will have different addresses in memory, hence == will return false, despite their content being the same.
Is there a scenario where .equals() and == will behave the same for object comparison?
If two reference variables point to the exact same object in memory, both .equals() and == will return true. This is because the default implementation of .equals() behaves the same as ==, and if an object's .equals() method is not overridden, it will compare references.
Top Picks & New Arrivals
