What is the difference between equals() method and == operator

== operator:

•  == operator used to compare objects references.
• used to compare data of primitive data types
• if  we are comparing two objects using "==" operator if reference of both are same then it will returns true otherwise returns false.
• obj1==obj2;
• If we are comparing primitive data type variables then it compares data of those two variables
• Ex: int a=12; int b=12; if(a==b) returns true

Comparing primitive values: 

1. package com.instanceofjava;
2.  
3. Class Demo{ 
4.  
5. public static void main (String args[]) {
6. 
   
7. int a=12;
8. int b=13;
9. int c=12;
10.  
11. if(a==b){
12. System.out.println("a and b are equal");
13. } 
14.  
15. if(b==c){
16. System.out.println("a and b are equal");
17. } 
18.  
19. }
20. }
     

Comparing Objects:

1. package com.instanceofjavaforus;
2.  
3. Class Demo{ 
4.  
5. public static void main (String args[]) {
6.  
7.  Demo obj1= new Demo();
8. Demo obj2=new Demo();
9.  
10. if(obj1==obj2){ // here both are two different objects(memory allocation wise);
11.  
12. System.out.println("obj1 and obj2 are referring to same address");
13.  
14. }else{
15.  
16.  System.out.println("obj1 and obj2 are referring to different address");
17.  
18. }
19. }
20. }

Comparing String Objects:

1. package com.instanceofjava;
2.  
3. Class ComapreStringDemo{ 
4.  
5. public static void main (String args[]) {
6.  
7.  String s1=new String("abc");
8. String s2=new String("abc");
9.  
10. if(s1==s2){ // here it returns false
11. System.out.println("obj1 and obj2 are referring to same address");
12. }else{
13.  System.out.println("obj1 and obj2 are referring to different address");
14. } 
15.  
16. }
17. }

Comparing String Literals:

•  If we declared two string literals with same data then those will refer same reference.
• means if we create any object using string literal then it will be created in string pool 
• then if we are created another literal with same data then it wont create another object rather refers same object in pool.
• so if compare two string literals with same data using "==" operator then it returns true.

1. package com.instanceofjava;
2.  
3. Class ComapreStringLiteralDemo{ 
4.  
5. public static void main (String args[]) {
6.  
7.  String s1="abc";
8. String s2="abc";
9.  
10. if(s1==s2){ // here it returns true
11.  
12. System.out.println("obj1 and obj2 are referring to same address");
13.  
14. }else{
15.  
16.  System.out.println("obj1 and obj2 are referring to different address");
17.  
18. }
19. }
20. }

equals() method:

• equals() method defined in "object" class.
• By default equals methods behaves like "==" operator when comparing objects.
• By default equals() method compares references of objects.
• But All wrapper classes and String class overriding this equals method and comparing data .
• Means in String class and in All wrapper classes this equals() methods is overridden so that to compare data of those class objects. 

Comparing String Objects:

1. package com.instanceofjava;
2.  
3. Class ComapreStringDemo{ 
4.  
5. public static void main (String args[]) {
6.  
7.  String s1=new String("abc");
8. String s2=new String("abc");
9.  
10. if(s1.equals(s2)){ // here it returns true
11.  
12. System.out.println(" data present in obj1 and obj2 is same");
13.  
14. }else{
15.  
16.  System.out.println(" data present in obj1 and obj2 is different");
17.  
18. }
19. }
20. }

 Comparing custom objects:

• If we want to compare custom objects means our own objects data.
• Then we need to override equals method and in that we need to compare data.

1. package com.instanceofjavaforus;
   
   public class Patient {
      String name;
      Patient(String name){
          this.name=name;
      }
         public boolean equals(Patient obj){
         
          if(this.name.equals(obj)){
              return true;
          }else{
              return false;
          }
      }
          public static void main(){
           Patient obj1= new Patient("sam");
          
           Patient obj2= new Patient("sam");
          
           System.out.println(obj1.equals(obj2)); //returns true
       }
          
   }

Important points to note about equals() and "==":

• "==" used to compare data for primitive data type variables .
• "==" operator compares objects references
• By default equals() method behaves like "==" operator for objects means compares objects references.
• All wrapper classes and String class overriding this equals() method and compares data of two objects. if same returns true.(when ever we overrides equals() method we need to override hashcode() method too and if two objects on equal method same then both should have same hashcode).
• And in equals() method in string class logic includes "==" operator too.

1. package com.instanceofjava;
2.  
3. public boolean equals(Object anObject) {
4.    if (this == anObject) {
5.       return true;
6.      }
7.  if (anObject instanceof String) {
8.      String anotherString = (String) anObject;
9.      int n = value.length;
10.     if (n == anotherString.value.length) {
11.     char v1[] = value;
12.      char v2[] = anotherString.value;
13.   int i = 0;
14. while (n-- != 0) {
15.    if (v1[i] != v2[i])
16.            return false;
17.            i++;
18.        }
19.          return true;
20.         }
21.     }
22.        return false;
23.   }