Thread: Difference between == and equals.

Hi guys,

Here is my sample code,

public class EqualsCheck {
 
	public static void main(String[] args) {
		EqualsCheck eq = new EqualsCheck();
		eq.checkBytes();
	}
 
	public void checkBytes() {
		Byte myByte = new Byte("111");
 
		if (myByte.toString() == myByte.toString()) {
			System.out.println("== is True");
		} else {
			System.out.println("== is False");
		}
 
		if (myByte.toString().equals(myByte.toString())) {
			System.out.println("equals is True");
		} else {
			System.out.println("equals is False");
		}
	}
}

When I run it, I get the following output,

== is False
equals is True

I am confused, because myByte.toString() always gives back the String value "111". Then how come == returns false and equals returns true.

I know that == checks the references and equals checks the actual objects, but where are those references that == checks which are not the same.

Can someone please clarify this for me?

Thanks in advance!
Goldest

Read this, it is a common question: http://www.javaprogrammingforums.com...html#post18725

== is also used for comparing the values of primitives. The equals method cannot be used directly on primitives (They must be wrapped).

int a = 5;
int b = 5;
if(a == b)
{
    System.out.println("a and b exist in different locations in memory, but are ==");
}

The same thing may or may not apply with primitives that have been wrapped (assume it's not).

Integer a = new Integer(5);
Integer b = new Integer(5);
if(a == b)
{
    System.out.println("a and b are the same integer object. In this case this is not true.");
}
if(a.equals(b))
{
    System.out.println("a and b contain the same value.");
}

For strings, it's often difficult to determine if two string are the same object in memory, so it's almost always a good idea to compare strings using equals().

Thanks for the replies guys.

What I understood is that, when we want to compare the references of primitives, we should use == operator. If both the references have the same value stored, then they will return true, else false. Like,

int x = 5;
int y = 5;
System.out.println("x == y : "+(x == y));

which returns

x == y : true

Now when we want to compare the contents of objects, like the Wrapper primitives, Strings or any other objects, we should use the equals() method. Like,

String l = new String("Goldest");
String m = new String("Goldest");
System.out.println("l == m : " +(l == m));
System.out.println("l equals m : " +l.equals(m));

which returns

l == m : false
l equals m : true

Because there are 2 new String objects created on heap and both l and m are referring to them individually. So there reference comparison returns false. But as they both contains same value, "Goldest", there equals returns true.

But when we come to Strings with plain values, like,

String a = "Goldest";
String b = "Goldest";
System.out.println("a == b: "+(a == b));
System.out.println("a equals b : " +a.equals(b));

which returns

a == b: true
a equals b : true

Here, as Strings are IMMUTABLE, when we create same value strings only one gets created on the heap. Whenever we create new String objects to refer to value "Goldest" all of them refers to the ONLY String "Goldest" present on the heap. And thats why both a and b returns true when we apply the == test on them. And the equals test will anyways give true as the contents are same.

And in my original example, when myByte.toString() gets compared to myByte.toString(), what happens internally is that 2 different String objects get created by JVM to store the String values that are returned by the toString() method. And later, both of them are compared with each other by using the == operator. Like,

String x = myByte.toString();
String y = myByte.toString();
System.out.println("x == y: " +(x == y));

which returns

x == y: false

And because of that ultimately "== is False" is printed.

Please let me know whether I have grasped it correctly or not.

Thanks in advance,
Goldest

Ohh yeah!

Thanks a lot for all your help and support.

Goldest