equals method usage in string and list

on the oracle java documentation, equals() from list says two lists are defined to be equal if they contain the same elements. But from object class equals() return true only if their hash code is equal. It means equals() from list overrides equals method from object class. And it's same for equals() from string. As long as they have same characters, they return true.

so whenever I declare a type as String, or use list classes like arraylist equals() are overriden automatically righT?

728x90

3 Answers equals method usage in string and list

equals() are overridden automatically righT?

Answer : Yes absolutely right, If you are asking overriden .equals() method is invoked automatically at run time

**Object class is parent class for every class in java and it consist of .equals() method which compares the object references

But String class, Wrapper classes (Integer,Long etc..) and Collections Classes (ArrayList, hashSet etc..) are overridden .equals() method to compare content in object instead of object references

to avoid confusions here is the clear example

public class Main2 {
public static void main(String[] args) {
    List<String> l1 = new ArrayList<>();
    l1.add(new String("hello"));
    List<String> l2 = new ArrayList<>();
    l2.add(new String("hello"));

    System.out.println(l1.equals(l2)); //true

    List<Test> t1 = new ArrayList<>();
    t1.add(new Test());
    List<Test> t2 = new ArrayList<>();
    t2.add(new Test());

    System.out.println(t1.equals(t2)); //false
    }
}

 class Test{
  }

In the above example comparing List<String> will return true because .euqals() method in String is overridden to compare content

But while comparing Lits<Test> will return false even though both objects are empty, since .equals() method in Test class is not overridden by default it will invoke Object class .equals() method which compares reference of objects as == does

Google Question object class equals method compares hashcode ?

Answer

The java.lang.Object class requires that any two objects that compare equal using the equals() method must produce the same integer result when the hashCode() method is invoked on the objects [API 2014]. The equals() method is used to determine logical equivalence between object instances.Feb 12, 2018

4 months ago

No, .equals() would not magically get overwritten when String are getting compared in list.

the String Class in java already has the .equals() method overwritten in its definition to compare characters by default.

meaning, even without a list if you do this:

String a = new String("abc");
String b = new String("abc");
System.out.println(a.equals(b)); 

Then, your output would be true

refer this: https://docs.oracle.com/javase/7/docs/api/java/lang/String.html

4 months ago

equals() are overriden automatically righT?

No. Methods are not overwritten "automatically".

You can look at the code - both classes have their own implementation of equals and hashCode. This implementation is what is used at runtime. If you're writing your own class, you will likely implement equals and hashCode.

But from object class equals() return true only if their hash code is equal.

I think you (and the original version of the other answer) are misunderstanding the documentation on equals:

Indicates whether some other object is "equal to" this one.

The equals method implements an equivalence relation on non-null object references:

    It is reflexive: for any non-null reference value x, x.equals(x) should return true.
    It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
    It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
    It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
    For any non-null reference value x, x.equals(null) should return false. 

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).

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.

The only part of this that refers to hashCode is at the end, which specifies that equal objects must have equal hash codes - this isn't automatic, it's by convention so things like HashMap will work.

Comparing hashCode values is NOT the default implementation of equals, and should NEVER be the implementation of equals - it is possible to have multiple non-equal objects with the same result for hashCode. The rule is to make sure your hashCode implementation returns the same value if objects are equal.

As an example, both of these will output the same hashCode, but are clearly not equal:

    System.out.println("Aa".hashCode());
    System.out.println("BB".hashCode());

Recommended further reading: this related question.

4 months ago