==是不是比较的是两个对象的引用，而equals比较的是引用还有内容？求助。

我刚才的回答好像是错了。。。。

据我了解，==是调用equals方法，如果没有复写，那么默认是比较内存地址，还有很多类应该是复写了equals方法，比如String,还有Integer

回答的不够好，我给你写一段我以前的笔记吧。希望能帮到你

1. //双等号的作用，判断两个引用是否指向堆内存的同一个地址。
   
2. //eaulas用力啊比较两个对象的内容是否相等。
   
3. //   通常情况下，对象的内容相等需要符合两个条件
   
4. //                1 对象的类型相同（可以使用instanceof操作符进行比较）
   
5. //                2.两个对象的成员变量的值完全相同
   
6. class Person{
   
7.         String name ;
   
8.         int age;
   
9.         public boolean equals(Object obj){
   
10.          if(this ==obj){    //这里的this值得是调用equals的对象
    
11.                  return true;
    
12.          }
    
13.         
    
14.          boolean b = obj instanceof Person;
    
15.          if(b){
    
16.                  Person ps = (Person)obj;
    
17.                  if(this.age==ps.age && this.name.equals(ps.name)){
    
18.                          return true;
    
19.                  }
    
20.                  else{
    
21.                          return false;
    
22.                  }
    
23. 
    
24.          }
    
25.          else{
    
26.                  return false;
    
27.          }
    
28. 
    
29.         }
    
30. }
    
31. //...............................................................
    
32. class Test{
    
33.    public static void main(String[] args) {
    
34.                Person p1 = new Person();
    
35.                Person p2 = new Person();
    
36.                Person p3 = new Person();
    
37.               p1.name = "Tony";
    
38.               p1.age = 23;
    
39. 
    
40.               p2.name = "Brother";
    
41.               p2.age = 26;
    
42. 
    
43.               p3.name = "Tony";
    
44.               p3.age = 23;
    
45. 
    
46.               boolean b1 = p1.equals(p2);
    
47.               boolean b2 = p1.equals(p3);
    
48.               System.out.println(b1);
    
49.               System.out.println(b2);
    
50.              
    
51.    }
    
52. 
    
53. }

复制代码

==比较的是内存的地址是否相等
没有重写Object的equals（）默认仍然比较的地址，重写后的比较是引用的内容是否相同。

　　　==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。
　　如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
　　equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：
　　String a=new String("foo");
　　String b=new String("foo");
　　两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。
　　在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。
　　如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：
　　boolean equals(Object o){
　　　return this==o;
　　}
　　这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

1、==可用于基本类型和引用类型：当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同。
2、对于String a = “a”; Integer b = 1;这种类型的特有对象创建方式，==的时候值是相同的。
3、基本类型没有equals方法，equals只比较值（对象中的内容）是否相同（相同返回true）。
4、一个类如果没有定义equals方法，它将默认继承Object中的equals方法，返回值与==方法相同。
细节上将的话：
       ==和equals的实质。
       在JAVA中利用"=="比较变量时,系统使用变量在"栈"中所存的值作为比较的依据。
       基本数据类型在"栈"中存的是其内容值,而对象类型在"栈"中存的是地址,这些地址指向"堆"中的对象。
       java.lang包中的Object类有public boolean equals(Object obj)方法,它比较两个对象是否相等。
       其它对象的equals方法仅当被比较的两个引用指向的对象内容相同时,对象的equals()方法返回true。
       总之,"=="和"!="比较的是地址.也可认为"=="和"!="比较的是对象句柄;而equals()比较的是对象内容.或者说,,"=="和"!="比较的是"栈"中的内容,而equals()比较的是"堆"中的内容.

-----------------------------------------------------------------------------------------
以前我也没搞清楚，不过后来仔细查找了本质就知道了

equals是object的方法 如果哪个类需要有比较性 都可以按照自己的标准来重新euqals  比如说String就重新了euqals
==可以用于两个引用的比较（当然必须是同种引用） 也可以用于基本数据类型的比较

首先要区分两种类型：
1，值类型是存储在内存中的栈
2，引用类型在栈中仅仅是存储引用型变量的地址，其本身是存在内存堆中
==比较变量时，比较的是两个变量的值是否相同；比较两个引用型变量时，比较的是两个变量在堆中的地址是否相同，即栈总的内容是否相同
equals 比较的是两个变量是否指向的同一个对象
简单说：==比较的是两个对象的内存地址，equals比较的是2个对象的内容
equals为true，==不一定为true

把Object的equals方法源代码直接附上：
public boolean equals(Object obj) {
        return (this == obj);
}
源代码你看了就不需要别人再说什么了！
其实，很多类都重写了Object的equals方法。
比如：String的equals就是比较字符串内容是否相等。

==比较的是内存首地址
没有重写Object的equals（）默认任然比较内存首地址

String类重写了equals（）方法，所以String的equals（）比较的是内容

当自定义类想调用equals（）方法并比较内容的话就需要重写该equals（）。

在JAVA中利用"=="比较变量时,系统使用变量在"栈"中所存的值作为比较的依据。
基本数据类型在"栈"中存的是其内容值,而对象类型在"栈"中存的是地址,这些地址指向"堆"中的对象。
java.lang包中的Object类有public boolean equals(Object obj)方法,它比较两个对象是否相等。
其它对象的equals方法仅当被比较的两个引用指向的对象内容相同时,对象的equals()方法返回true。
总之,"=="和"!="比较的是地址.也可认为"=="和"!="比较的是对象句柄;而equals()比较的是对象内容.或者说,,"=="和"!="比较的是"栈"中的内容,而equals()比较的是"堆"中的内容.

你是比较的字符串吧?==比较的是对象是不是同一个.而equals在String类中被复写,用于比较两个字符串是不是相同
字符串一旦确定,就在常量池另不可改变了.所以用==比较的同一个对象.
而equals比较的是两个对象的内容是不是一样.
最简单的例子你得看毕老师讲的String s1="abc";//一个对象
String s2=new String("abc");//两个对象