What is the difference between == and equals() in Java?

difference between equals() and in java javatpoint
difference between == and === in java
and equals in java string
difference between equals and in c#
equals() method in java example
java equals override
equals vs c#
difference between equals and contains in java

I wanted to clarify if I understand this correctly:

  • == is a reference comparison, i.e. both objects point to the same memory location
  • .equals() evaluates to the comparison of values in the objects

What is the difference between == and equals() in Java?, Both equals() method and the == operator is used to compare two objects in Java​. == is an operator and equals() is method. But == operator compares reference  First difference between equality operator and equals method is that “ == ” is an operator in Java where as equals is a method. Equality operator can be used to compare primitives as well as objects. Equals method can only be used with objects.

With respect to the String class:

The equals() method compares the "value" inside String instances (on the heap) irrespective if the two object references refer to the same String instance or not. If any two object references of type String refer to the same String instance then great! If the two object references refer to two different String instances .. it doesn't make a difference. Its the "value" (that is: the contents of the character array) inside each String instance that is being compared.

On the other hand, the "==" operator compares the value of two object references to see whether they refer to the same String instance. If the value of both object references "refer to" the same String instance then the result of the boolean expression would be "true"..duh. If, on the other hand, the value of both object references "refer to" different String instances (even though both String instances have identical "values", that is, the contents of the character arrays of each String instance are the same) the result of the boolean expression would be "false".

As with any explanation, let it sink in.

I hope this clears things up a bit.

Difference between == and equals() method in Java, Both equals() and "==" operator in Java is used to compare objects to check equality but the main difference between equals method and the  · First difference between them is, equals() is a method defined inside the java.lang.Object class and == is one type of operator and you can compare both primitive and objects using equality operator in Java.

Difference between equals method and "==" operator , 1. Primitives or Objects : == operator is used to compare primitives while equals() method is used to check equality of objects. Main difference between == and equals in Java is that "==" is used to compare primitives while equals() method is recommended to check equality of objects. String comparison is a common scenario of using both == and equals method.

The difference between == and equals confused me for sometime until I decided to have a closer look at it. Many of them say that for comparing string you should use equals and not ==. Hope in this answer I will be able to say the difference.

The best way to answer this question will be by asking a few questions to yourself. so let's start:

What is the output for the below program:

String mango = "mango";
String mango2 = "mango";
System.out.println(mango != mango2);
System.out.println(mango == mango2);

if you say,

false
true

I will say you are right but why did you say that? and If you say the output is,

true
false

I will say you are wrong but I will still ask you, why you think that is right?

Ok, Let's try to answer this one:

What is the output for the below program:

String mango = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango3);
System.out.println(mango == mango3);

Now If you say,

false
true

I will say you are wrong but why is it wrong now? the correct output for this program is

true
false

Please compare the above program and try to think about it.

Ok. Now this might help (please read this : print the address of object - not possible but still we can use it.)

String mango = "mango";
String mango2 = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango2);
System.out.println(mango == mango2);
System.out.println(mango3 != mango2);
System.out.println(mango3 == mango2);
// mango2 = "mang";
System.out.println(mango+" "+ mango2);
System.out.println(mango != mango2);
System.out.println(mango == mango2);

System.out.println(System.identityHashCode(mango));
System.out.println(System.identityHashCode(mango2));
System.out.println(System.identityHashCode(mango3));

can you just try to think about the output of the last three lines in the code above: for me ideone printed this out (you can check the code here):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

Oh! Now you see the identityHashCode(mango) is equal to identityHashCode(mango2) But it is not equal to identityHashCode(mango3)

Even though all the string variables - mango, mango2 and mango3 - have the same value, which is "mango", identityHashCode() is still not the same for all.

Now try to uncomment this line // mango2 = "mang"; and run it again this time you will see all three identityHashCode() are different. Hmm that is a helpful hint

we know that if hashcode(x)=N and hashcode(y)=N => x is equal to y

I am not sure how java works internally but I assume this is what happened when I said:

mango = "mango";

java created a string "mango" which was pointed(referenced) by the variable mango something like this

mango ----> "mango"

Now in the next line when I said:

mango2 = "mango";

It actually reused the same string "mango" which looks something like this

mango ----> "mango" <---- mango2

Both mango and mango2 pointing to the same reference Now when I said

mango3 = new String("mango")

It actually created a completely new reference(string) for "mango". which looks something like this,

mango -----> "mango" <------ mango2

mango3 ------> "mango"

and that's why when I put out the values for mango == mango2, it put out true. and when I put out the value for mango3 == mango2, it put out false (even when the values were the same).

and when you uncommented the line // mango2 = "mang"; It actually created a string "mang" which turned our graph like this:

mango ---->"mango"
mango2 ----> "mang"
mango3 -----> "mango"

This is why the identityHashCode is not the same for all.

Hope this helps you guys. Actually, I wanted to generate a test case where == fails and equals() pass. Please feel free to comment and let me know If I am wrong.

Difference Between == and equals method in Java with Example , The equals() method compares this string to the specified object. The result is true if and Difference between == and equals() method in Java. That’s all on the difference between equals method and == operator in Java. As I said the main difference between them is that one of them is an operator and other is a method and == is used to compare both primitive and objects while equals() method is used to check equality of objects only.

The == operator tests whether two variables have the same references (aka pointer to a memory address).

String foo = new String("abc");
String bar = new String("abc");

if(foo==bar)
// False (The objects are not the same)

bar = foo;

if(foo==bar)
// True (Now the objects are the same)

Whereas the equals() method tests whether two variables refer to objects that have the same state (values).

String foo = new String("abc");
String bar = new String("abc");

if(foo.equals(bar))
// True (The objects are identical but not same)

Cheers :-)

Difference between == and equals() method in Java., In java both == and equals() method is used to check the equality of two variables or objects. Following are the important differences between  3) While comparing variable using strict equality operator in Java, two object are strictly equal to each other if both are of same type and they refer to same instance. Similarly two String are equal to each other if contents of each others are same e.g. same characters at same position.

Differences between == and equals() method in Java, Difference between equals() and == in java. == is operator whereas equals is method in java. == is recommended to compare primitives  In this post ,we will try to understand hashcode () and equals () method in java. These methods can be found in the Object class and hence available to all java classes.Using these two methods, an object can be stored or retrieved from a Hashtable, HashMap or HashSet. You might know if you put entry in HashMap, first hashcode is calculated and

Difference between equals() and == in java, Difference between equals() method and equality operator “==” in Java is asked quite frequently in beginner level Java interviews. Since both  Difference between equals() and == in java. == is operator whereas equals is method in java. == is recommended to compare primitives whereas equals method is recommended to compare the actual content of objects. Equals method can be overridden but you can’t override behavior of “==” operator.

Difference Between “==" Operator And equals() Method in Java , equals() , on the other hand is a method in the Object class which is used for comparing objects. It behaves similar to the == operator if not overridden by a class. equals is a method in Java that acts similar to the == operator, which is to test for object identity rather than object equality. hashCode is a method by which a class implicitly or explicitly break down the data stored in an instance of the class into a single hash value.

Comments
  • yeah, pretty much
  • Yes, spot on. You can think of .equals() as meaningfully equivalent
  • Possible duplicate of How do I compare strings in Java?
  • A sentence like "both objects point to the same memory location" is sloppy language, which can make understanding more difficult. You mean: "both variables refer to the same object". Note that a variable is not an object; a variable is a reference to an object. Objects don't "point to" anything.
  • if == checks for memory reference then why am I getting this strange behavior in [this][1][1]: docs.google.com/document/d/… I expected output to be true. can clear my confusions
  • @JSK print the values of d1 and d2 and I think you'll see why you're returning false.
  • @BoDidely I figured it out. It was because all the wrapper classes are immutable.
  • The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true). <br/> Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes. (docs.oracle.com/javase/7/docs/api/java/lang/…)
  • Unrelated: Today I put up a meta question ( meta.stackoverflow.com/questions/372795/… ) regarding good/effective/... "auto" messages when commenting low quality newbie questions. The feedback I received felt pretty much "you are doing the totally wrong thing". Now I am simply wondering how you look at this? Do you have "generic" messages in your quiver, or do you write solely specific comments in such cases?
  • so for strings == is reference equals aswell? ie works the same as for other objects?
  • (Thread necromancy, I know...) For Strings, == is reference equals as well, yes, but it usually works (as in two Strings with the same content will usually be == to each other), because of how Java handles Strings. It won't always, and it's certainly bad practice, but it's a common mistake, particularly from people coming from other languages.
  • To add on to Tonio's comment. String build from string literal will be added to something called the String constant pool, e.g. String s1 = "someString"; String s2 = "someString;" both s1 & s2 will share the same reference. s1 == s2 will return true. But if they were constructed via the String constructor, e.g. String s1 = new String("someString"); String s2 = new String("someString"); then they will not share the same reference. s1 == s2 will return false.
  • Interesting example. Different perspective from the above answers. Thanks!
  • Best answer in my opinion, as it's clearer than the other full-text answers without losing the explanation (if you undertand class and static concepts, of course)