操作符"=="和object的equals方法究竟有什么区别？ 能举个小例子说明最好。

==  比较的是两个对象在内存中的地址是否相同
equals 比较的是两个对象的内容是否相同

equals如果没有被重写的话，和==的作用是一样的，都是判断两个对象引用是否指向同一个地址。一般情况下，重写了equals（）方法就表示比较它们“实际意义上相等”，比较的是内容，而不是引用地址。举个例子：
String hei = new String("黑马");
String ma = new String("黑马");
System.out.println(hei==ma);结果为false
因为他们是两个对象，在堆中是占有不同区域的。但是如果用重写的equals()方法，此处则比较他们的内容，都是“黑马”，则返回true。

如果Object的equals方法没有被重写的话，是一样的，比较的都是对象的地址值。
如果类中这个方法重写equals方法，就不一定了
如果你比较内容相等，那么区别就说出来了

== 一般用来比较基本类型的，它比较的是内存的地址，当不是基本类型时，数据实际上是存在堆上的，而引用是存在栈上，==比较的是栈指向堆中的地址是否相等，所以当不是基本类型时就要使用equals，来比较堆中的数据值是否相等。示例：
                      int a=130;
                int b=130;
                Integer a1=new Integer(130);
                Integer a2=new Integer(130);
                System.out.println("a==b:"+(a==b));
                System.out.println("a1==a2:"+(a1==a2));
                System.out.println("a1.equals(a2):"+a1.equals(a2));
Integer是int的封装类型，也就不是基本数据类型。
上例运行结果为：
a==b:true
a1==a2:false  //比较的是栈指向堆的地址是否相等，由于是new的空间，所以地址不相等。
a1.equals(a2):true//比较的是堆内存的值


==还可以比较String
但仅限不是new的变量。看下面示例：

String str1="abc";
                String str2="abc";
                String str3=new String("bcd");
                String str4=new String("bcd");
                System.out.println("str1==str2:"+(str1==str2));
                System.out.println("str1.equals(str2):"+str1.equals(str2));
                System.out.println("str3==str4:"+(str3==str4));
                System.out.println("str3.equals(str4):"+str3.equals(str4));
运行结果为：
str1==str2:true
str1.equals(str2):true
str3==str4:false
str3.equals(str4):true
       

在基本数据类型中==是比较俩个数的值，在对象中是比较地址值。object中比较的是是地址值，比较是不是同一个对象

"==" 在基本数据类型中比较的是两个数值是否相等，
“==”在引用数据类型中比较是的是引用变量指向堆内存中该对象的首地址，如果首地址相同（也就是指向同一个对象）时
返回true，否则返回false。
Object类中的equals方法和“==”在引用类型中的用法是一样的，比较的是对象的首地址。
好多类都重写了Object类的equals方法，都有自己的比较的方式。
如：String类就重写了equals方法，重写后比较的是两个对象的实际字符串。
String str1 = new String("string");
String str2 = new String("string");
System.out.println(str1.equals(str2));//返回true
System.out.println(str1==str2));//返回false
重写equals方法必须重写hashCode方法，该方法声明相等的对象必须有相同的哈希码。
希望能帮助楼主理解。

举一反三,根据不同情况为你解释其比较方式的不同,具体如下:
|--对于基本数据类型
    |--只有"==",没有equals()方法,比较两者内容是否相等
|--对于字符串
    |--String类不是基本数据类型
    |--"=="比较两者内存地址是否相等,equals()方法是重写了Object类中的equals()方法,比较两者内容是否相等.
    |--字符串被存储在方法区内的常量池中,只要值相等其指的都是同一个内存地址,"=="和equals()方法的结果无区别(源代码中有所体现)
|--对于对象实例
    |--"=="比较两者内存地址是否相等,equals()方法是重写了Object类中的equals()方法,比较两者内存地址是否相等,但通常我们会自己重写equals()方法,将其改变为比较两者内容是否相等(String类的equas()就是这个！)
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
总结:具体"=="与equals()方法所比较的是什么并非固定,而是根据不同情况进行区分的,千万不要一概而论!!!


LZ要是还不明白，请看下这个帖子：

http://bbs.itheima.com/forum.php?mod=viewthread&tid=15708&page=1#pid89070

希望能帮到你！

==操作符专门用来比较变量的值是否相等。比较好理解的一点是：
int a=10;
int b=10;
则a==b将是true。
但不好理解的地方是：
String a=new String("foo");
String b=new String("foo");
则a==b将返回false。

根据前一帖说过，对象变量其实是一个引用，它们的值是指向对象所在的内存地址，而不是对象本身。a和b都使用了new操作符，意味着将在内存中产生两个内容为"foo"的字符串，既然是“两个”，它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值，所以使用"=="操作符，结果会是false。诚然，a和b所指的对象，它们的内容都是"foo"，应该是“相等”，但是==操作符并不涉及到对象内容的比较。
对象内容的比较，正是equals方法做的事。

看一下Object对象的equals方法是如何实现的：
boolean equals(Object o){

return this==o;

}
Object对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法，那你的类使用equals和使用==会得到同样的结果。同样也可以看出，Object的equals方法没有达到equals方法应该达到的目标：比较两个对象内容是否相等。因为答案应该由类的创建者决定，所以Object把这个任务留给了类的创建者。

看一下一个极端的类：
Class Monster{
private String content;
...
boolean equals(Object another){ return true;}

}
我覆盖了equals方法。这个实现会导致无论Monster实例内容如何，它们之间的比较永远返回true。

所以当你是用equals方法判断对象的内容是否相等，请不要想当然。因为可能你认为相等，而这个类的作者不这样认为，而类的equals方法的实现是由他掌握的。如果你需要使用equals方法，或者使用任何基于散列码的集合（HashSet,HashMap,HashTable），请察看一下java doc以确认这个类的equals逻辑是如何实现的。

=对象所在的内存地址，而不是对象本身  
而equals 比较的是值当2个new的对象出来 用=会出现false 但是String 中equals则为true
除非你覆写了hasCode 的方法

徐炯 发表于 2012-5-30 19:51
举一反三,根据不同情况为你解释其比较方式的不同,具体如下:
|--对于基本数据类型
    |--只有"==",没有equa ...

:lol  哈哈哈

欧阳梦南 发表于 2012-5-30 18:56
== 一般用来比较基本类型的，它比较的是内存的地址，当不是基本类型时，数据实际上是存在堆上的，而引用是 ...

==在基本数据类型中不是比较地址的吧，例如a=3,b=3,这两个3的地址是不一样的，但是System.out.println(a==b)返回的确是true，==在基本数据类型中比较的应该是数值！

==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。
如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如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方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

Kristy_Li 发表于 2012-5-31 09:38
==在基本数据类型中不是比较地址的吧，例如a=3,b=3,这两个3的地址是不一样的，但是System.out.println(a= ...

嗯 笔误，基本数据类型比较的是数值~

                        Equals 和 ==的一些总结

EqualsTest.java 测试类
public class EqualsTest {

        public static void main(String[] args) {

                //==================
                //字符串 之  equals 和   == 比较
               
                // 如果是字符串比较 则 equals 和 == 效果一样
                String a = "aaa";
                String b = "aaa";
                System.out.println(a.equals(b)); //true
                System.out.println(a == b);                  //true

                //--------------------------------
               
                // 如果是对象比较 则 equals 比较的是 对象的内容是否相同，
而 == 比较的是 引用地址是否相同
                String aa = new String("aaa");
                String bb = new String("aaa");
                System.out.println(aa.equals(bb));  //true
                System.out.println(aa == bb);       //false
       
                String aaa = new String("aaa");
                String bbb = new String("bbb");
                System.out.println(aaa.equals(bbb));  //false
                System.out.println(aaa == bbb);      //false
               
               
                //=======================================
                //实体对象 之    equals 和   == 比较
               
                //Object的equals方法
                /*
                public boolean equals(Object obj) {
                        return (this == obj);
                }
               
                // Object hashcode 方法
                        public native int hashCode();

                */
               
                User user1 = new User("dd", 15, "hz");
                User user2 = new User("yy", 20, "nj");
               
                User user11 = new User("aaron", 15, "hz");
                User user22 = new User("aaron", 15, "hz");

                // 看是否重写Object的equals方法 ，默认比较两个对象的地址
                // 如果重写 Object方法, 则比较两个对象的所有字段的内容是否相同
如果相同,则返回 true
System.out.println("user1.equals(user2) is " + user1.equals(user2)); //不重写 false  重写 false

System.out.println("user11.equals(user22) is " + user11.equals(user22));//不重写 false  重写 true

                // 比较对象地址 地址不同 返回 false
                        System.out.println("user1 == user2 is " + (user1 == user2));
// false
System.out.println("user11 == user22 is " + (user11 == user22)); // false

                // hashcode
                System.out.println("user1 hashcode is " + user1.hashCode());                        //不重写 29115481         重写   3248962
                System.out.println("user2 hashcode is " + user2.hashCode());                        //不重写 19621457         重写   3413159
                System.out.println("user11 hashcode is " + user11.hashCode());                        //不重写 4872882            重写   95830131
                System.out.println("user22 hashcode is " + user22.hashCode());                        //不重写 25724761         重写    95830131        }
}

Note：

equals()返回true，则hashCode()一定相等；反之不然



实体对象类 User.java

public class User {

        private String name;
        private int age;
        private String addres;

        public User(String name, int age, String addres) {
                this.name = name;
                this.age = age;
                this.addres = addres;
        }


        @Override
        public boolean equals(Object obj) {
                if (this == obj) {
                        return true;
                }
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                User other = (User) obj;
                if (addres == null) {
                        if (other.addres != null)
                                return false;
                } else if (!addres.equals(other.addres))
                        return false;
                if (age != other.age)
                        return false;
                if (name == null) {
                        if (other.name != null)
                                return false;
                } else if (!name.equals(other.name))
                        return false;
                return true;
        }

        // @Override
        // public int hashCode() {
        // final int prime = 31;
        // int result = 1;
        // result = prime * result + ((addres == null) ? 0 : addres.hashCode());
        // result = prime * result + age;
        // result = prime * result + ((name == null) ? 0 : name.hashCode());
        // return result;
        // }

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }

        public int getAge() {
                return age;
        }

        public void setAge(int age) {
                this.age = age;
        }

        public String getAddres() {
                return addres;
        }

        public void setAddres(String addres) {
                this.addres = addres;
        }
}

== 是比较运算符   只有2个结果 true flase

举个简单的例子吧   1 == 2   输出结果 就是 flase  错误的 不对的  如果是 1 == 1  true 对 正确的

==是比较两个变量本身的值，就是说两个对象在内存中的首地址是否相同。而equals是比较字符串中所包含的内容是否相同。
如果是基本类型，只能用==来比较，不能用equals。
例如：
String s1,s2 = "abc", s3 ="abc" ;
　　s1 = new String("abc");
　　s2 = new String("abc");

s1==s2 是 false　　　
因为两个变量的内存地址不一样，它们指向的对象不一样，所以是不相等的。
s1.equals(s2) 是 true     
因为两个变量的所包含的内容是abc，所以相等。

一个地址 一个内容

==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同(比较两个引用变量 所指向的内存地址是否相同)，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。