想搞懂==和equals比较都有什么区别。

equals 方法（是String类从它的超类Object中继承的）被用来检测两个对象是否相等，即两个对象的内容是否相等，区分大小写。
==用于比较引用和比较基本数据类型时具有不同的功能：
比较基本数据类型，如果两个值相同，则结果为true
而在比较引用时，如果引用指向内存中的同一对象，结果为true

equals特点:
1、自反性：x.equals（x）返回true；
2、对称性：若x.equals（y）为true，则y.equals（x）亦为true；
3、传递性：若x.equals（y）为true且y.equals（z）也为true，则x.equals（z）亦为true；
4、一致性：x.equals（y）的第一次调用为true，那么x.equals（y）的第二次、第三次、第n次调用也均为true，前提条件是没有修改x也没有修改y；
5、对于非空引用x，x.equals（null）返回为false。

在比较字符型数据时,==比较的是内存中的地址,是对象的句柄 而equals()比较的是地址内的内容,比较的是对象.

==是比较的两个对象的地址，而equals则比较的是两个对象的内容。

这是我以前总结的，希望对你有帮助！
==与equals区别和用法
==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同。
比如2个字符串对象

1. String s1 = new String("str");
   
2. String s2 = new String("str");

复制代码

如果用==号比较，会返回false，因为创建了两个对象，他们在内存中地址的位置是不一样的。
equals的情况比较复杂，它是java.lang.Object类中的一个方法。因为java中所有的类都默认继承于Object，所以所有的类都有这个方法。
Java源代码Object类中如是定义：

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

复制代码

同样使用==号进行内存地址的比较。但是许多java类中都重写了这个方法，比如String
Java源代码String类中如是定义：

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 = value.length;
   
8.                 if (n == anotherString.value.length) {
   
9.                         char v1[] = value;
   
10.             char v2[] = anotherString.value;
    
11.             int i = 0;
    
12.             while (n-- != 0) {
    
13.                 if (v1[i] != v2[i])
    
14.                         return false;
    
15.                 i++;
    
16.             }
    
17.             return true;
    
18.         }
    
19.     }
    
20.     return false;
    
21. }

复制代码

String里的方法，如果==号比较不相等，还会进行一下值的比较。

总结：
==用于比较变量所对应的内存中所存储的数值是否相同
equals方法具体的作用要看当前的那个类是如何实现重写父类中该方法的。如果没有重写该方法，那么他和==号等价。

equals用来比较内容是否相同，==用来比较对象在内存中的地址是否相同。例如：

                String s1 = new String("abc");
                String s2 = "abc";
                String s3 = s1;
                String s4 = "def";
                String s5 = new String("def");

               
                System.out.println(s1 == s2);        //false，因为s1和s2是两个不同的对象，故内存地址不同
                System.out.println(s1.equals(s2));        //true，因为s1和s2的内容相同，都是“abc”
               
                System.out.println(s1 == s3);//true，因为s3指向了s1对象，故两者在内存中地址相同，也就是说s1和s3是同一个对象
                System.out.println(s1.equals(s3));//true，显然内容是相同的

                System.out.println(s1 == s4);//false，因为s1和s4是两个不同的对象，所以内存地址不同
                System.out.println(s1.equals(s4));//false，s1和s4内容显然是不同的
               
                System.out.println(s1 == s5);//false，s1和s5是两个不同的对象
                System.out.println(s1.equals(s5));//false，s1和s5的内容不同


另外还有个小知识，就是直接赋值字符串和new一个String对象的区别，如下所示：
String s4 = "def";
String s5 = new String("def");
String s6 = "def";

System.out.println(s4 == s6);//true，因为这里s4和s6是同一个对象
System.out.println(s4.equals(s6));//true，显然s4和s6的内容也是相同的
               
System.out.println(s5 == s6);//false，s1和s5是两个不同的对象
System.out.println(s5.equals(s6));//true，因为s5和s6的内容相同，都是“def”

对于直接赋值字符串的方式·  java有一个字符串缓冲区 你新建一个的时候它会先找缓冲区里有没有这个字符串 如果有 直接返回引用 没有就在里面新建
对于new String()的方式 ：要新建一个String对象 它首先也会去缓冲区里边查找  不管有没有 它都会在堆里新建一个  如果缓冲区里面没有 则在缓冲区里面也新建一个

希望可以帮到你

解释一下==号，他比较的是一个对象在内存中的地址值，
比如2个字符串对象
String s1 = new String("str");
String s2 = new String("str");
如果用==号比较，会返回false，因为创建了两个对象，他们在内存中地址的位置是不一样的。

equals的情况比较复杂，它是java.lang.Object类中的一个方法。因为java中所有的类都默认继承于Object，所以所有的类都有这个方法。

在Object类源码中是这样写的。
public boolean equals(Object obj) {
return (this == obj);
}
他同样使用==号进行内存地址的比较。但是许多java类中都重写了这个方法，比如String。
public boolean equals(Object anObject) {
if (this == anObject) {
     return true;
}
if (anObject instanceof String) {
     String anotherString = (String)anObject;
     int n = count;
     if (n == anotherString.count) {
  char v1[] = value;
  char v2[] = anotherString.value;
  int i = offset;
  int j = anotherString.offset;
  while (n-- != 0) {
      if (v1[i++] != v2[j++])
   return false;
  }
  return true;
     }
}
return false;
    }

String里的方法，如果==号比较不相等，还会进行一下值的比较。
所以equals方法具体的作用要看当前的那个类是如何实现重写父类中该方法的。如果没有重写该方法，那么他和==号等价。