Equality in java

Question

The == operator in java checks if two objects are at the same memory location. Dose this mean that if object1 != object2 then object1 is not linked with obejct2? By linked I mean that if object1 is changed then obejct2 is also changed.

Answer 1

It checks if two pointers are equal, ie. that they point to the same object.

Answer 2

== checks if two references are identical.

In other words: if that check returns true, there is only one object.

If it returns false, there are two objects.

But of course, one can easily write some code where a != b; but a.foo() will have an effect on b.

Like:

class Bar {
  private static int counter = 0;
  void foo() { counter++ };
  int getCounter() { return counter; }

When you now have:

Bar a = new Bar();
Bar b = new Bar();

then a != b; but still, when you do

System.out.println(b.getCounter());
a.foo();
System.out.println(b.getCounter());  

will print 0 and then 1.

So in essence, the answer to your second question is: a != b does not imply that "doing something with a" does nothing to b".

But for the record - that last sentence is the reason why static can be seen as abnormality in good OO design; exactly for such "strange" side effects.

Edit to answer on "what happens with containers and clone"?

Of course, when you have something like:

List<WhatEver> a = some list containing one object "X"
List<WhatEver> b = a "clone" of a

Then a != b; but of course; when you call a.get(0).foo() that affects b.get(0) ... because both lists internally point to the same X

And you see: in that case, a.equals(b) would return true; whereas a == b is false.

Answer 3

Firstly – object1 and object2 are not objects themselves, they each are variables that hold reference to an object (unless null). So, == does not check if two objects are in the same memory location (as this can't possibly happen), but checks whether two variables hold reference to the same object. Therefore if object1 != object2, the two variables do not contain a reference to the same object.

Answer 4

I think it would be easier to understand with an example, the best example IMHO is when you override equals, when you create instances of Human with a name and a age, the method equals reads:

• If (e.g John) is the same as John, then both humans are equal (a clone of John)
• If the Object passed is not human then return false, they are not the same ( e.g a dog, who knows)

• Then check field by field if the person is the same, there could be another John with the same age, even though they are different humans.

       public class Human {
  
          private final String name;
          private final int age;
  
          public Human(String name, int age) {
              this.name = name;
              this.age = age;
          }
  
          public String getName() {
              return this.name;
          }
  
          public int getAge() {
              return this.age;
          }
  
          @Override
          public boolean equals(Object o) {
              if (this == o) {
                  return true;
              }
  
              if (!(o instanceof Human)) {
                  return false;
              }
  
              Human that = (Human) o;
  
              if (this.age != that.age) return false;
              return this.name != null ? this.name.equals(that.name) : that.name == null;
  
          }
  
          @Override
          public int hashCode() {
              int result = name != null ? name.hashCode() : 0;
              result = 31 * result + age;
              return result;
          }
      }