equals()和==到底什么区别？
不是说equals比较的是内存地址么
class Test{
      public static void main(String[] args){
                 String s1="Monday";                  String s2="Monday";
                  String s3=new String("Monday");
               System.out.println(s1==s2);            ===ture
               System.out.println(s1==s3);            ===false
               System.out.println(s1.equals(s2));  ===ture
               System.out.println(s1.equals(s3));  ===ture
     }
}

==
在用于数值类型对比时是比较数值是否相等，用于其他类型比如字符时候是对比内存地址。
equals
我记得是用来对比类型内容例如字符串内容是否相等的。
我记得是这么理解。不知道对不对，我也是菜鸟啊。

论坛关于这俩的区别估计有不下几十个帖子，楼主请右上角  点击“帖子搜索”。 嘿嘿~ 请叫我红领巾！

其实就是比较只有两种：基本数据类型和引用对象。
前者用哪个结果都一样——相等为true 否则为false。
如果是引用对象就有区别了，就要比较栈内存地址是否相等。
你创建两个String对象的时候，内存地址不同，但你给它们赋了相同的值。
这时==比较内存地址，而equals比较值。
所以你得到上面那些输出结果。

equals是字符串特有的比较方法，通常被用来比较两个变量的引用地址，==是比较两边的数值，

lz,你的问题其实有两个。
1. 首先确定一下：equals比较的是内容， == 比较的是内存地址，这是肯定的
2. 你的代码中，s1和s2其实是一个对象，内存地址也相同，所以不论是用 equals和“==”，结果都是true
这是string的缓冲池的问题，创建字符串的时候，如果不是用new的方法而是这种String s1="Monday"
等出字符串的方法，jvm会在字符串缓冲池（个人理解为内存中一个区域）中寻找这个字符串有没有已经建立好的实例，
如，建立s2的时候，在缓冲池中找到了s1，所以他俩地址一样。
而s3就不一样了，它是new出的对象，重新占据了新的内存地址，故，s3和s1，equals比较内容为true
“==”比较地址为false

1. package com.itheima.mark;
   
2. 
   
3. public class test2 {
   
4.        
   
5.         public static void main(String[] args) {
   
6.                 /**
   
7.                  * lz,你的问题其实有两个。
   
8.                  * 1. 首先确定一下：equals比较的是内容， == 比较的是内存地址，这是肯定的
   
9.                  * 2. 你的代码中，s1和s2其实是一个对象，内存地址也相同，所以不论是用 equals和“==”，结果都是true
   
10.                  *              这是string的缓冲池的问题，创建字符串的时候，如果不是用new的方法而是这种String s1="Monday"
    
11.                  *              等出字符串的方法，jvm会在字符串缓冲池（个人理解为内存中一个区域）中寻找这个字符串有没有已经建立好的实例，
    
12.                  *              如，建立s2的时候，在缓冲池中找到了s1，所以他俩地址一样。
    
13.                  *              而s3就不一样了，它是new出的对象，重新占据了新的内存地址，故，s3和s1，equals比较内容为true
    
14.                  *           “==”比较地址为false
    
15.                  */
    
16.                 String s1="Monday";                  
    
17.                 String s2="Monday";
    
18.         String s3=new String("Monday");
    
19.         System.out.println(s1==s2);            //ture
    
20.         System.out.println(s1==s3);            //false
    
21.         System.out.println(s1.equals(s2));     //ture
    
22.         System.out.println(s1.equals(s3));     //ture
    
23.         }
    
24. }
    

复制代码

"=="运算符判断两个对象的引用内存地址是否相同. equals方法比较对象是否在逻辑上相等. equals默认比较的是对象的引用地址 等同于"==".一般情况下,自定义的对象需要复写equals方法来保证逻辑相等
String类equals将此字符串与指定的对象比较,复写了equals方法建立字符串自己的判断相同的依据,通过字符串对象中的内容来判断的

class Test{
      public static void main(String[] args){
                 String s1="Monday";                  String s2="Monday";
                  String s3=new String("Monday");
               System.out.println(s1==s2);            ===ture/比较的是内存中的地址值，因为s1和s2的具体对象是一样的  所以在内存中只会开辟一个空间  所以这个的结果是true
               System.out.println(s1==s3);            ===false//s1和s3是不一样的  s1是一个对象 而s2是有两个对象 所以在内存中不是同一块空间 所以他们的内存地址值是不一样的  所以结果为false
               System.out.println(s1.equals(s2));  ===ture//在字符串中重写了equals方法  比较的是具体的对象值 不在是地址值  因为s1和s2的具体对象值是相同的 所以结果为true
               System.out.println(s1.equals(s3));  ===ture//s1和s3的具体对象值也相同 所以结果也为true
     }


原因已写在代码中  
}

"==" 是判断符号两边的对象是否相等,即它们的内存地址是否相等;
equals() 是判断两个对象的值是否相等,而不管它们的内存地址是否相等.(当然,若它们的内存地址相等,值一定相等)；以下是典型示例：

1. public class Test2 {
   
2. public static void main(String[] args) {
   
3. String str1 = "apple"; ⁄*先查看字符串池里有没有这个值,若没有,则开辟一个空间用来存放这个值*/
   
4. String str2 = "apple"; ⁄*先查看字符串池里有没有这个值,若有,则str2指向这个内存地址*/
   
5. System.out.println("str1==str2:"+(str1==str2));  ⁄*因为str1与str2的内存地址一样,所以"=="的结果为true*/
   
6. System.out.println("str1 equals str2:"+str1.equals(str2));
   
7. 
   
8. String str3 = new String("banana");
   
9. String str4 = new String("banana"); ⁄*分别创建了两个不同的字符串对象,str3和str4*/
   
10. System.out.println("str3为"+str3+"\nstr4为"+str4);
    
11. System.out.println("str3==str4:"+(str3==str4));
    
12. System.out.println("str3 equals str4:"+(str3.equals(str4)));
    
13. ⁄*str3和str4分别代表两个不同的内存地址,所以"=="的结果为false*/
    
14. ⁄*这时应该看得出String类型的两种创建对象的方法之间的区别了吧!要注意的是第一种创建对象方法采用的池技术对象的值可以重复利用*/
    
15. 
    
16. int i1 = 10;
    
17. int i2 = 10;
    
18. System.out.println("i1==i2:"+(i1==i2));
    
19. ⁄*为什么结果为true?本人的理解是:int只是一个基本数据类型,不是一个封装类型.而它的封装类型Integer则符合上面的原理请看下面代码*/
    
20. 
    
21. Integer integer1 = new Integer(10);
    
22. Integer integer2 = new Integer(10);
    
23. System.out.println("integer1==integer2:"+(integer1==integer2));
    
24. System.out.println("integet1 equals integer2:"+integer1.equals(integer2));
    
25. 
    
26. Object obj1 = new Object();
    
27. Object obj2 = obj1;
    
28. System.out.println("obj1==obj2:"+(obj1==obj2));
    
29. //对象obj1和obj2都指向同一个内存地址.
    
30. }
    
31. }

复制代码

运行效果图：