Kindly Somebody explain me, Why the answer is true & false
public class IntegerTest {
public static void main(String[] args) {
Integer x = 1000;
long y = 1000;
Integer z = 1000;
System.out.println(x == y);
System.out.println(x == z);
}
}
x == y is a value comparison (because y is a primitive type), so 1000==1000 -> true.
x == z is an object reference comparison - object x is not an object z. They hold the same values, but they are still two completely different objects. So if you compare them you get false.
Boxing & Unboxing conversions in JLS section 5.1.7.
This has to do with the fact that Java has primitive types (like int) and reference types (like Integer).
When a reference type is compared to a primitive type, the reference types actual value is compared to the value of the primitive type. However when two reference types are compared, the references themselves are compared, not the values.
System.out.println(x == y);//this will compare referance
System.out.println(x == z);//this will compare value
referances are different and values are same so it gives such op
you may would like to read Auto boxing and Unboxing
The first is true cause its exactly the same value. that's clear right? the second is false cause an long is a floating point value which is 1000.0. so if you work with comparing floting point values with integers you need to add a type cast or use compareTo()
Hope that helps
Checks if the values of two operands are equal or not, if yes then condition becomes true. Equality Test Operators ==, !=
The == operator tests if two values are the same, so (x == 6) is true if x contains the value 6. The not-equal operator, !=, is the opposite, evaluating to true if the values are different. Typically, you use == and != with primitives such as int and boolean, not with objects like String and Color. With objects, it is most common to use the equals() method to test if two objects represent the same value.
The similarity of == and .equals() can be confusing, so here is a suggested rule: Every value in Java is either a primitive (e.g. int) or an object (e.g. String). Use ==, <, >=, etc.. with primitives like int. Use .equals() with objects like String and Color. Since the dereference dot (.) only works with objects, you can remember it this way: if it can take a dot then use .equals() (e.g. a String), otherwise use == (e.g. an int).
It is also possible to use == with objects. In that case, what == does is test if two pointers point to exactly the same object. Such as use of == is a little rare in Java code, and so it's simpler to concentrate on using equals() with objects, and == only with primitives.
When you ask Java to compare x == y you ask it to compare Integer (class) with 1000 (long , which is a primitive type). In this case Java will auto unbox x and try to compare the values.
However when you try to compare two classes (even two Integers), Java will compare the addresses, which will be false.
Integer is a wrapper type, an Object type associated with the primitive type int, so, although it is an object type, it can behave as a primitive type.
When comparing with a primitive type using ==, the Integer object behaves as a primitive type and the values of both variables x and y are compared returning true.
When comparing with another object, using == we are asking is both objects are identical, which is not the same as being equal. Integer objects are equals if their value if the same, and this can be checked using .equals() . So x.equals(z) would be true. But x and z are not identical, if we change the value of z, the value of x keeps the same, they are different objects so x==z is false.
