“==”和equals方法究竟有什么区别？能用一个实例讲解吗？

1. public class Test {
   
2.        
   
3.         public static void main(String[] args){
   
4.                  String s1 = new String("abc");
   
5.                  String s2 = s1;
   
6.                  String s3 = new String("abc");
   
7.                  String s4 = "abc";
   
8.                  
   
9.                  System.out.println(s1==s2);//true 因为指向同一个对象,判断的是内存地址值
   
10.                  System.out.println(s1==s3);//false 虽然内容相同,不指向同一个对象,判断的是内存地址值
    
11.                  System.out.println(s1.equals(s3));//true 内容相同,判断的是内容,String类复写了equals方法
    
12.                  System.out.println(s1==s4);//false 虽然内容相同,不指向同一个对象,判断的是内存地址值
    
13.                  System.out.println(s1.equals(s4));//true 内容相同,判断的是内容,String类复写了equals方法
    
14.                
    
15.         }         
    
16. }

复制代码

从本质上来讲，“==”和 equals 都是比较的地址。
举个例子：

1. public class Demo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Person p1 = new Person();
   
6.                 Person p2 = new Person();
   
7.                 Person p3 = p1;
   
8.                 System.out.println(p1 == p2);
   
9.                 //返回的结果是false，因为两个实例化对象在内存中的地址是不同的，所以比较结果是false
   
10.                 System.out.println(p1.equals(p2));
    
11.                 //返回的结果是false，equals默认比较的是地址，因为两个实例化对象在内存中的地址是不同的，所以比较结果是false
    
12.                 System.out.println(p1 == p3);
    
13.                 //返回的结果是true，因为p3对象指向p1对象，所以它们所指向的内存中的地址是相同的，所以是true
    
14.                 System.out.println(p1.equals(p3));
    
15.                 //理由同上
    
16. 
    
17.         }
    
18. }
    
19. class Person
    
20. {
    
21.         
    
22. }

复制代码

而"=="和 equals 的最大的区别在于 “==”仅能比较地址。而equals会根据编程人员的设定，根据编程人员指定的比较方法进行比较。
equals使用的方法就是在要进行比较的两个对象所抽象出来的类中，复写自Object类中继承来的equals方法。
举例：（目的，让所有的Person的对象都相等）

1. public class Demo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Person p1 = new Person();
   
6.                 Person p2 = new Person();
   
7.                 Person p3 = p1;
   
8.                 System.out.println(p1 == p2);
   
9.                 //返回的结果是false，因为两个实例化对象在内存中的地址是不同的，所以比较结果是false
   
10.                 System.out.println(p1.equals(p2));
    
11.                 //返回的结果是true，equals默认比较的是地址，但是在此例子中，要根据Person类中复写的equals方法来进行判断。因为equals方法中返回的结果始终是true，所以任何两个对象比较返回的结果都是true，所以比较结果是true
    
12.                 System.out.println(p1 == p3);
    
13.                 //返回的结果是true，因为p3对象指向p1对象，所以它们所指向的内存中的地址是相同的，所以是true
    
14.                 System.out.println(p1.equals(p3));
    
15.                 //理由同p1.equals(p2)
    
16. 
    
17.         }
    
18. }
    
19. class Person
    
20. {
    
21.         
    
22.         public boolean equals(Object obj)
    
23.         {
    
24.                 return true;
    
25.         }
    
26.         
    
27. }

复制代码

此方法中需要说明的一点是，复写equals方法的时候传入的参数一定要是Object类型。

另外针对String类型的比较一定要主意下边这一点。
实例：

1. class Demo2
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 String str1 = new String("Hello World!");
   
6.                 String str2 = new String("Hello World!");
   
7.                
   
8.                 System.out.println(str1==str2);
   
9.                 //返回结果是false，因为通过new关键字产生的两个对象在内存中的地址是不一样的
   
10.                 System.out.println(str1.equals(str2));
    
11.                 //返回结果是true，因为字符串复写了Object类中的equals方法，其中比较的方法就是比较字符串内容，很明显，str1和str2的内容是相同的，

复制代码

equal方法是原始类Object中的方法，所以所有的类中就都继承了这个方法。该方法的源代码是：

1. public boolean equals(Object obj) {
   
2. return (this == obj);
   
3. }
   

复制代码

由此可以看出其实“==”和“equals”是一样的，equals方法使用的就是“==”，所以都是判断的地址是否相等，也就是说是不是同一个东西。
但是其他的类可以重写这个equals方法，来实现自己特有的功能，拿String类来说，它重写的equals方法源代码为：

1. public boolean equals(Object anObject) {
   
2.         if (this == anObject) {
   
3.             return true;
   
4.         }
   
5.         if (anObject instanceof String) {
   
6.             String anotherString = (String)anObject;
   
7.             int n = count;
   
8.             if (n == anotherString.count) {
   
9.                 char v1[] = value;
   
10.                 char v2[] = anotherString.value;
    
11.                 int i = offset;
    
12.                 int j = anotherString.offset;
    
13.                 while (n-- != 0) {
    
14.                     if (v1[i++] != v2[j++])
    
15.                         return false;
    
16.                 }

复制代码

可以看出，String类中的equals方法先用“==”判断，假如是同一个，那肯定是相等的，假如不是同一个，则判断字符串对象的长度和内容是否都相等，假如都相等，就返回true，所以，String类中的equlals判断的是内容是否相等，而不管地址是否相等。
对于String类，简单的说，“==”判断的是堆地址值是否相等，“equals”判断的只是内容是否相等。也就是说“==”判断这两个东西是不是同一个，而“equals”判断这两个东西是否一样。
那其他的类也都可以根据自己的需要来重写equals方法，你可以看看其他类中equals方法的源代码来帮助自己理解。

① ==在比较基本数据类型时是比较两个数的值是不是相等，相等则返回true.而在比较两个引用类数据类型号时，它是比较两个引用是不是指向同一个对象，若是则返回true否则返回false。
②equals()它是Object类中的一个方法，它用于两个引用类型的比较时，若两个引用指向的是同一个对象则返回true。但其它Object的子类可以重写equals这个方法。
③String类就重写了equals()方法，它里面的方法是描述的是把两个对象的每一个字符单独拿出来进行比较，若两它们全相同则返回true。
④既然讲到了String,就不得不讲String池的概念了，Java中有这样的一个机制，对一些可以共享的字符串对象，会先在String池中查找是否存在相同的String内容，如果有就直接返回，而不是直接创造一个新的String对象，以减少内存的耗用。
所以在使用String的equals()方法时一定要注意。像String s1=”abcdef”;String s2=”abcdef”;它们在内存中就是指的同一个对象。但如果是使用的String s2=new String(“abcdef”);String s2=new String(“abcdef”);那它们就不是指的同一个对象了。因为每new一个对象系统就会为它们分配空间，而不像上面一样在String池中去寻找。
代码示例：

1. public class Test {
   
2.     public static void main(String[] args) {
   
3.         Integer p = 1;
   
4.          Integer q = 1;
   
5.         Integer i = new Integer(1);
   
6.          Integer j = new Integer(1);
   
7.          if(p == q){
   
8.              System.out.println("integer:p == q"); //实际结果
   
9.            }else{
   
10.              System.out.println("integer:p != q");
    
11.           }
    
12.           if(p.equals(q)){
    
13.              System.out.println("integer:p.equals(q)"); //实际结果
    
14.           }else{
    
15.               System.out.println("integer:p.equals(q)");
    
16.           }
    
17.           if(i == j){
    
18.              System.out.println("int:i == j");
    
19.          }else{
    
20.              System.out.println("int:i != j"); //实际结果
    
21.          }
    
22.          if(i.equals(j)){
    
23.              System.out.println("integer:i.equals(j)");//实际结果
    
24.         }else{
    
25.             System.out.println("integer:!i.equals(j)");
    
26.         }
    
27.         String a = "abc";
    
28.         String b = "abc";
    
29.         String c = new String("abc");
    
30.         String d = new String("abc");
    
31.         if(a == b){
    
32.           System.out.println("abc对象相等"); //实际结果
    
33.         }else{
    
34.             System.out.println("abc对象不相等");
    
35.          }
    
36.          if(a.equals(b)){
    
37.              System.out.println("ab相等"); //实际结果
    
38.          }else{
    
39.               System.out.println("ab不相等");
    
40.          }
    
41.          if(c.equals(d)){
    
42.               System.out.println("cd相等"); //实际结果
    
43.          }else{
    
44.                System.out.println("cd不相等");
    
45.          }
    
46.          if(c == d){
    
47.               System.out.println("cd对象相等");
    
48.          }else{
    
49.              System.out.println("cd对象不相等"); //实际结果
    
50.          }
    
51.          }
    
52.          }
    
53. 
    

复制代码

他们说的非常详细，我就简便的回答下
==表示比较的是地址， 而equals比较的是内容
打比方：String s1 = new String ("a");
       String s2 = new String ("a");
s1==s2//输出false，因为创建了两个String对象，存在栈中的地址不一样
s1.equals(s2)//输出true，因为里面的内容都是“a”

我的理解是“==”和“equals”最明显的区别在于“==”是对比数据，int类型的数据是否相等，而“equals”则是对比字符串是否相同