初始化两个字符串：
String s1="abc";
String s2=new String("abc");
为什么s1==s2是false？而s1.equals(s2)却是true呢？

这两天查水贴严重，小心被抓！！！{:3_47:}。第一个比较的是地址值，第二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 = 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.     }

复制代码

s1和s2是引用数据类型，所以s1和s2的值其实是地址值，s1指向的是常量池中“abc”的地址值，s2指向的是堆内存中new出来的对象的地址值。所以==号比较的是地址值，地址值不同所以为false，而堆内存中的对象内引用的值是地址值是指向常量池中的“abc”，String中equals方法比较的是字符串是否相等，所以比较的是常量池中的“abc”，所以equals比较则为true

毕老师视频里面说的这句话String s2=new String("abc");是有两个对象，不蛮懂

==是判断两个对象是否是同一个对象
  equals是进行值的判断
  String   a   =   new   String( "aaa ");
String   b   =   new   String( "a ");
  b   +=   "aa ";
  则   a==b   //错误
       a.equals(b)//正确

除了String和封装器，equals()和“==”没什么区别
但String和封装器重写了equals()，所以在这里面，equals()指比较字符串或封装对象对应的原始值是否相等， "== "是比较两个对象是否为同一个对象

受教了  谢谢

==比较的是地址，而equals()方法在String中被重写了，所以他在地址不一样的情况下，可以比较内容，内容一样，也返回true

==比较的是地址（引用指向），
但是String s1="abc";//在栈存值
String s2=new String("abc");//在堆中存值
所以单纯比较地址肯定是错误的
而equals()方法在String中被重写了，所以即使在地址不一样的情况下，也是可以比较内容，内容一样，也返回true
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

s1是字符串类型的变量，赋初值是abc，在内存中的栈内存中，而s2是new了一个String类类型的对象，是引用类型，在内存的位子是堆内存中，并将对内存中的地址传给了s2，传入的参数是abc。而s1==s2比较的地址是否相同，所以结果是false，而s1.equal（s2）比较的是值进行比较，结果为true。

equals被复写了，对于引用型 == 判断的是地址值

两个不同的对象，他们的地址当然不一样，s1是存放在常量池中的，而new String（“abc”）是在堆中开辟的新内存空间

这个涉及到了内部存储的差别了.String s1 = "abc";从栈中获取空间后，在堆中可能会获取一个地址。而String s2=new String("abc");先要从栈中获取空间，然后在堆中会分配一个地址。第一个表达式返回的值null，而第二个表达式是地址。所以，s1.equals(s2)的值是false。

==是比较的地址值，equals比较的是对象里面的内容