“==”和equals 都用于表示两个对象相同，那么在编程的时候能不能互换使用，也就是在使用“==”时候，将该句所表达的内容用equals的语句表示，它们的使用各有什么限制吗？    求解惑。。。。

== 比较的是真实的地址值，equals其实是一个方法，在String中比较的是两个字符串的内容是否相等，因为String类重写了object中的equals方法，所以equals比较的什么要看你重写的方法了，你需要比较什么就重写equals来实现，equals方法默认比较的是哈希值

       A.==可用于基本类型和引用类型：当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同。
       B.对于String a = “a”; Integer b = 1;这种类型的特有对象创建方式，==的时候值是相同的。
       C.基本类型没有equals方法，equals只比较值（对象中的内容）是否相同（相同返回true）。
       D.一个类如果没有定义equals方法，它将默认继承Object中的equals方法，返回值与==方法相同。
详述：
       ①==和equals的实质。
       在JAVA中利用"=="比较变量时,系统使用变量在"栈"中所存的值作为比较的依据。
       基本数据类型在"栈"中存的是其内容值,而对象类型在"栈"中存的是地址,这些地址指向"堆"中的对象。
       java.lang包中的Object类有public boolean equals(Object obj)方法,它比较两个对象是否相等。
       其它对象的equals方法仅当被比较的两个引用指向的对象内容相同时,对象的equals()方法返回true。
       总之,"=="和"!="比较的是地址.也可认为"=="和"!="比较的是对象句柄;而equals()比较的是对象内容.或者说,,"=="和"!="比较的是"栈"中的内容,而equals()比较的是"堆"中的内容.
       ②==操作符。专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相当，只能用==操作符。
      Java的基本数据类型为(char，byte，short，int，long，float，double，boolean)。
      如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存(对内存)，变量本身也占用一块内存，例如Object obj = new Object()变量obj是一个内存，new Object()是一个内存，此时，变量所对应的内存中存储的数据就是对象占用的那块内存的首地址。对于指向对象内存的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
       ③构造器形成的差别。对于String和Integer来说，由于他们特有的创建对象的方式。使用构造器和不使用构造器得到一个对象，==方法比较所产生的结果是不同的。 String a = “abc”; String b = "abc"; 此时a==b得到结果为true。String a = new String("abc"); String b = new String("abc");此时a==b得到的结果为false。Integer a = 1; Integer b = 1;此时a==b的结果是true。Integer a = new Integer(1); Integer b = new Integer(1);此时a==b得到的结果为false。
       通过这一点其实我们也能够更加容易理解==对内存的实际操作，实际执行的是近似于基本类型比较。
       String对象和字符串连接池：
       引号内包含文本是String类特有创建对象的方式.但是"=="返回的结果是true,为什么呢?因为在JVM内,存在字符串池,其中保存着很多 String对象，并且可以被共享使用，因此它提高了效率.字符串池由String类维护，我们可以调用intern()方法来访问字符串池。当运用引号内包含文本创建对象时,所创建的对象是加入到字符串池里面的.如果要创建下一个字符串对象,JVM首先会到字符串池中寻找,是否存在对应的字符串对象,如果存在,则返回一个己存在对象的对象的引用给要创建的对象引用.如果不存在,才会创建一个新的对象,并返回一个新对象的对象引用给要创建的对象引用.以上这段话理解起来可能比较拗口.用代码理解就是str2和str1是两个对象引用,并指向了同一个对象.所以'=='返回的是true.
       只有引号内包含文本创建对象才会将创建的对象放入到字符串池。String str = new String("abc")这种方法创建的字符串对象是不放入到字符串池的。所以,引号内包含文本创建对象的性能要比后来那种方法创建字符串对象的性能要好。
String str1 = "abc";

String str2 = "abc";
String str3 = str1+str2;   //这种创建方式是不放入字符串池的.

String str4 = str1+"cd";   //这种创建方式是不放入字符串池的.

String str5 = "ab"+str2;   //这种创建方式是不放入字符串池的.

String str6 = "ab"+"cd"; //这种创建方式是放入字符串池的.这种情况实际上是创建了1个对象，abcd"1个对象
String str7 = "abcd";
System.out.println(str1==str2); //返回ture

System.out.println(str6==str7); //返回ture
       另一个问题：
我们首先来看一段 Java代码：

String str=new String("abc");  

紧接着这段代码之后的往往是这个问题，那就是这行代码究竟创建了几个String对象呢？相信大家对这道题并不陌生，答案也是众所周知的，2个。接下来我们就从这道题展开，一起回顾一下与创建String对象相关的一些JAVA知识。

我们可以把上面这行代码分成String str、=、"abc"和new String()四部分来看待。String str只是定义了一个名为str的String类型的变量，因此它并没有创建对象；=是对变量str进行初始化，将某个对象的引用（或者叫句柄）赋值给它，显然也没有创建对象；现在只剩下new String("abc")了。那么，new String("abc")为什么又能被看成"abc"和new String()呢？我们来看一下被我们调用了的String的构造器：

Java代码

public String(String original) {   
//other code ...   
}  
大家都知道，我们常用的创建一个类的实例（对象）的方法有以下两种：
我们正是使用new调用了String类的上面那个构造器方法创建了一个对象，并将它的引用赋值给了str变量。同时我们注意到，被调用的构造器方法接受的参数也是一个String对象，这个对象正是"abc"。

使用new创建对象是调用Class类的newInstance方法，利用反射机制创建对象。
       ④equals方法。用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：
String a=new String("foo");
String b=new String("foo");
两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，他们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b即返回false，而这两个对象中内容是相同的，所以，表达式a.equals(b)将返回true。
       在实际开发中，我们经常要比较传递进行来的字符串内容是否相等，许多人稍不注意就使用==进行比较了，这是错误的，有大量这样的错误。记住，字符串的比较基本都是使用equals方法。
       ⑤如果一个类没有定义equals方法。它将继承Object类的equals方法，Object类的equals方法的实现代码如下：
boolean equals(Object o){
return this==o;
}
这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object类继承的）就是使用==操作符，也是比较两个变量指向的对象是否是同一个对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可以认为两个对象的内容是相同的。
      
   

楼上摘的别处的，不过你可以看看，学习学习

菜鸟觉得，简单点来说，==是要求等号左右两边数值相等，返回true.而equals是不仅数值相等，而且数据类型也得相同，才能返回true

菜鸟总结：==是比较两个对象是否相等，equals比较的是对象中的内容是否相等（前提是该类重写了Object中的equals的方法），

==比较的是引用地址 equals比较的是对象的内容

个人认为：==是比较运算符 ，符号两边可以是基本数据类型和引用数据类型，引用数据类型方面一般比较的引用地  址值
                equals是个方法，通常比较连个对象的内容是否相同，但不同方法中的equals方法是不同的，比如说，object中的equals方法和==运算符比较的都是某个对象的地址值，而想String中的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. public static void main(String[] args) {
   
2.                 // 基本类型：short、long、int、double、float、char、byte、boolean
   
3.                 int i = 0, j = 0;
   
4.                 /* 1.基本类型只有"=="方法,没有equals方法 */
   
5.                 System.out.println(i == j);
   
6.                 // 基本类型对应的对象有equals方法
   
7.                 /* 2."=="比较的是内存地址;equals比较的是对应内存中存的值 */
   
8.                 System.out.println(new Integer(1) == new Integer(1));// 结果为false，因为比较的是内存中的地址
   
9.                 System.out.println(new Integer(1).equals(new Integer(1)));// 结果为true，因为比较的是内存中的值
   
10.                
    
11.                 System.out.println(new Test01().equals(11));
    
12.         }
    
13. 
    
14.         /* 3.重写equals方法 */
    
15.         public boolean equals(Object obj) {
    
16.                 /*
    
17.                  * 这个里面可以有各种操作
    
18.                  */
    
19.                 System.out.println("重写方法");
    
20.                 return false;
    
21.         }

复制代码

哎，人家只是问问两个的区别，上面的就长篇大论，会死人的，
我来说的话就是“==”比较的是内存地址是否相同，而“equals”比较的是两个对象里的内容是否相同，equals方法是可以重写的，相比较什么就比较什么！

我是个人理解啊，你看看你能不能看的明白：在我看来==是比较内存地址这是无可争议的问题，但是equals呢，他是Object中的方法，对吧，这个既然是方法，而且Object是所有类的父类，所以也就是说所有类中都可一定义自己的equals方法，如果我定义了一个类，这个类中的的equals，不是单纯的比较内存地址呢？其实在java内部的好多类中都重写了equals方法

简单地说，equals比较的是内容，而==比较的是地址

equals用于引用数据类型，比较的是两个对象的内容
==用于基本数据类型和引用数据类型，比较的是数值是否相等

==比较的是内存地址,equals比较的是对象的成员属性

==是用来判断字节码对象的，使用字符串判断的时候注意不要使用==，而是要使用equals

equals是用于比较两个独立对象的内容是否相等，就好比比较两个人长的是否一样，比较的对象是两个独立个体。经常用于比较 传递的字符串内容是否相等。  

诺之忧 发表于 2014-9-14 14:41
==是用来判断字节码对象的，使用字符串判断的时候注意不要使用==，而是要使用equals ...

equals是用于比较两个独立对象的内容是否相等，就好比比较两个人长的是否一样，比较的对象是两个独立个体。经常用于比较 传递的字符串内容是否相等。  

==操作符专门用于比较两个量的值是否相等，也就是比较变量所对应的内存中所存储的数值是否相等，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符；

equals是用于比较两个独立对象的内容是否相等，就好比比较两个人长的是否一样，比较的对象是两个独立个体。经常用于比较 传递的字符串内容是否相等 。
是不是可以这么理解？    貌似更言简意赅。

     记住一点就好了，  == 比较的是哈希值（地址）， equals比较的是值。   

呵呵!大家学习的都很细致啊！