Equality

Question 1

What does == mean?

Answer 1

It compares primitives and compares if two references point to the same object.

It should not be used to compare Strings but it is legal. Be careful. Pay attention to objects in string pool vs separate objects.

String x = “Hello World”;
String y = “Hello World”;
System.out.println(x == y); // true because they are in pool

Question 2

What does .equals() do and when can it be used?

Answer 2

equals() is logical equality IN STRINGS and ARRAY LISTS. It compares the values inside two Strings. For other objects it compares reference equality just like ==. The method can be used to compare any two objects of the same type only String compares inside.

Question 3

What does == do with two Strings?

Answer 3

Calling == on String objects will check whether they point to the same object in the
pool.

Question 4

What does == do with two StringBuilder references?

Answer 4

Calling == on StringBuilder references will check whether they are pointing to the same StringBuilder object.

Question 5

What does .equals() do with two Strings?

Answer 5

Calling equals() on String objects will check whether the sequence of characters is the same.

Question 6

What does .equals() do with two StringBuilder references?

Answer 6

Calling equals() on StringBuilder objects will check
whether they are pointing to the same object rather than looking at the values inside.

Question 7

What is this result?
short s =9;
Integer k = 9;
System.out.print(s==k);

Answer 7

True. Autounboxing occurs then the primitive values are compared. One will be promoted if necessary.

Question 8

Is this valid?

System.out.println(Double.parseDouble(“3.0”).equals(Integer.parseInt(“3”)));

Answer 8

No, when the operations are performed they produce primitives. The .equals method cannot be used on primitives. This will not compile.

Question 9

What's the difference?
if (b2 = !b1 = b2){
if (b2 = !b1){   
if (b2 != b1 = b2){
//if (b2 = b1 != b2){

Answer 9

if (b2 = !b1 = b2){//does not compile because of !b1=b2.
!b1 is not a variable that can receive an assignment. It’s a value.

if (b2 = !b1){ // Ok, just assignment and it evaulates to a boolean

if (b2 != b1 = b2){ // compiler error because the first two create a boolean result then it tries to assign a value tp that result.

//if (b2 = b1 != b2){ //ok, assignment then comparison

Question 10

Is this valid?
System.out.println(new Double(3.0).equals(new Double(3.0)));

Answer 10

Yes because this is comparing two objects. It does not result in the comparison of primitives.

Question 11

Is this legal?

static int num = 1;
static int num2 = 1;

System.out.println(num.equals(num2));

Answer 11

No, can’t do .equals() on primitives

Question 12

What is the result?
System.out.println(new Double(3.0).equals(new Float(3.0)));

Answer 12

False. .equals looks at object type and inside

Question 13

What is the result?
System.out.println(new Double(3.0).equals(new Double(3.0)));

Answer 13

True .equals looks looks at object type and inside