Compare two objects with .equals() and == operator

You should override equals

 public boolean equals (Object obj) { if (this==obj) return true; if (this == null) return false; if (this.getClass() != obj.getClass()) return false; // Class name is Employ & have lastname Employe emp = (Employee) obj ; return this.lastname.equals(emp.getlastname()); } 

The best way to compare 2 objects is by converting them into json strings and compare the strings, its the easiest solution when dealing with complicated nested objects, fields and/or objects that contain arrays.

sample:

import com.google.gson.Gson; Object a = // ...; Object b = //...; String objectString1 = new Gson().toJson(a); String objectString2 = new Gson().toJson(b); if(objectString1.equals(objectString2)){ //do this } 

The overwrite function equals() is wrong. The object "a" is an instance of the String class and "object2" is an instance of the MyClass class. They are different classes, so the answer is "false".

It looks like equals2 is just calling equals, so it will give the same results.

Your equals2() method always will return the same as equals() !!

Your code with my comments:

public boolean equals2(Object object2) { // equals2 method if(a.equals(object2)) { // if equals() method returns true return true; // return true } else return false; // if equals() method returns false, also return false } 

The "==" operator returns true only if the two references pointing to the same object in memory. The equals() method on the other hand returns true based on the contents of the object.

Example:

String personalLoan = new String("cheap personal loans"); String homeLoan = new String("cheap personal loans"); //since two strings are different object result should be false boolean result = personalLoan == homeLoan; System.out.println("Comparing two strings with == operator: " + result); //since strings contains same content , equals() should return true result = personalLoan.equals(homeLoan); System.out.println("Comparing two Strings with same content using equals method: " + result); homeLoan = personalLoan; //since both homeLoan and personalLoan reference variable are pointing to same object //"==" should return true result = (personalLoan == homeLoan); System.out.println("Comparing two reference pointing to same String with == operator: " + result); 

Output: Comparing two strings with == operator: false Comparing two Strings with same content using equals method: true Comparing two references pointing to same String with == operator: true

You can also get more details from the link: http://javarevisited.blogspot.in/2012/12/difference-between-equals-method-and-equality-operator-java.html?m=1

Statements a == object2 and a.equals(object2) both will always return false because a is a string while object2 is an instance of MyClass

If you dont need to customize the default toString() function, another way is to override toString() method, which returns all attributes to be compared. then compare toString() output of two objects. I generated toString() method using IntelliJ IDEA IDE, which includes class name in the string.

public class Greeting { private String greeting; @Override public boolean equals(Object obj) { if (this == obj) return true; return this.toString().equals(obj.toString()); } @Override public String toString() { return "Greeting{" + "greeting='" + greeting + '\'' + '}'; } } 

Your class might implement the Comparable interface to achieve the same functionality. Your class should implement the compareTo() method declared in the interface.

public class MyClass implements Comparable<MyClass>{ String a; public MyClass(String ab){ a = ab; } // returns an int not a boolean public int compareTo(MyClass someMyClass){ /* The String class implements a compareTo method, returning a 0 if the two strings are identical, instead of a boolean. Since 'a' is a string, it has the compareTo method which we call in MyClass's compareTo method. */ return this.a.compareTo(someMyClass.a); } public static void main(String[] args){ MyClass object1 = new MyClass("test"); MyClass object2 = new MyClass("test"); if(object1.compareTo(object2) == 0){ System.out.println("true"); } else{ System.out.println("false"); } } } 

Your implementation must like:

public boolean equals2(Object object2) { return a.equals(object2.a); } 

With this implementation your both methods would work.

the return type of object.equals is already boolean. there's no need to wrap it in a method with branches. so if you want to compare 2 objects simply compare them:

boolean b = objectA.equals(objectB); 

b is already either true or false.

When we use == , the Reference of object is compared not the actual objects. We need to override equals method to compare Java Objects.

Some additional information C++ has operator over loading & Java does not provide operator over loading. Also other possibilities in java are implement Compare Interface .which defines a compareTo method.

Comparator interface is also used compare two objects

Here the output will be false , false beacuse in first sopln statement you are trying to compare a string type varible of Myclass type to the other MyClass type and it will allow because of both are Object type and you have used "==" oprerator which will check the reference variable value holding the actual memory not the actual contnets inside the memory . In the second sopln also it is the same as you are again calling a.equals(object2) where a is a varible inside object1 . Do let me know your findings on this .

In short, == compares two POINTERS.

If the two pointers are equal, then they both point to same object in memory (which, obviously has the same value as itself).

However, .equals will compare the VALUES of whatever is pointed to, returning true iff they both evaluate to the same value.
Thus, two separate strings (i.e., at different addresses in memory) are always != but are .equal iff they contain the same (null-terminated) sequence of chars.

You should override "equals" method and use "EqualsBuilder" and "HashCodeBuilder" from this Java Utility Apache Commons Lang

My two cents for those who wish to compare every non-static fields of two objects (shallow comparison only).

public <T> Boolean isEqual(T o1, T o2) throws IllegalAccessException { boolean result = true; Map<String, String> map = new HashMap<>(); Field[] fields = o1.getClass().getDeclaredFields(); for (Field field : fields) { if (!java.lang.reflect.Modifier.isStatic(field.getModifiers())) { String fieldName = field.getName(); field.setAccessible(true); Object value1 = field.get(o1); Object value2 = field.get(o2); if (value1 != value2) { map.put(fieldName, value1 + "!=" + value2); result = false; } } } if(!map.isEmpty()) println("Debug", "Mismatch: " + map); return result; }