Java中==、equals、hashcode的区别与重写equals以及hashcode方法实例

1、重写equals方法实例   部分代码参考http://blog.csdn.net/wangloveall/article/details/7899948

重写equals方法的目的是判断两个对象的内容(内容可以有很多,比如同时比较姓名和年龄,同时相同的才是用一个对象)是否相同

如果不重写equals,那么比较的将是对象的引用是否指向同一块内存地址,重写之后目的是为了比较两个对象的value值是否相等。特别指出利用equals比较八大包装对象
(如int,float等)和String类(因为该类已重写了equals和hashcode方法)对象时,默认比较的是值,在比较其它自定义对象时都是比较的引用地址。
package com.lk.C;

class User {
private String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(null == obj) {
return false;
}
if(this.getClass() != obj.getClass()) {
return false;
} User user = (User) obj;
if(this.name.equals(user.name)&&this.age == user.age) {
return true;
}
return false;
} } public class Test6 {
public static void main(String[] args) {
User userA = new User();
userA.setName("王明");
userA.setAge(10); User userB = new User();
userB.setName("王明");
userB.setAge(10); User userC = new User();
userC.setName("王亮");
userC.setAge(10); System.out.println("userA equals userB:" + userA.equals(userB));
System.out.println("userA equals userC:" + userA.equals(userC));
}
}
userA equals userB:true
userA equals userC:false

在Java中,问什么说重写了equals方法都要进而重写Hashcode方法呢?

原因如下:当equals此方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。如下:
(1)当obj1.equals(obj2)为true时,obj1.hashCode() == obj2.hashCode()必须为true 
(2)当obj1.hashCode() == obj2.hashCode()为false时,obj1.equals(obj2)必须为false

hashcode是用于散列数据的快速存取,如利用HashSet/HashMap/Hashtable类来存储数据时,都是根据存储对象的hashcode值来进行判断是否相同的。

这样如果我们对一个对象重写了euqals,意思是只要对象的成员变量值都相等那么euqals就等于true,但不重写hashcode,那么我们再new一个新的对象,当原对象.equals(新对象)等于true时,两者的hashcode却是不一样的,由此将产生了理解的不一致。

2、看看下面的三段程序

package com.lk.C;

public class Test7 {
public static void main(String[] args) {
int a = 10;
int b = 10;
System.out.print("基本类型a==b:");
System.out.println(a == b);
System.out.println("-----"); String s1 = "abc";
String s2 = "abc";
System.out.print("String类型是s1==s2:");
System.out.println(s1 == s2);
System.out.println("-----"); String s3 = new String("abc");
String s4 = new String("abc");//可以看出==比较的是栈的地址是否相同
System.out.print("String类型用new String()是s1==s2:");
System.out.println(s3 == s4);
System.out.println(s1 == s3);
System.out.println("-----"); Integer i1 = 1;
Integer i2 = 1;
System.out.print("包装类型是i1==i2:");
System.out.println(i1 == i2);
System.out.println("-----"); Integer i3 = 128;
Integer i4 = 128;//此时输出false是因为Integer在-128-127之间会缓存,超出这个范围就不会缓存了
System.out.print("包装类型是i3==i4:");
System.out.println(i3 == i4);
System.out.println("-----"); Integer i5 = new Integer("1");
Integer i6 = new Integer("1");
System.out.print("包装类型用new Integer()是i5==i6:");
System.out.println(i5 == i6);//用new Integer()多少都不会缓存
System.out.println("-----"); A a1 = new A(1);
A a2 = new A(1);
A a3 = a2;
System.out.print("普通引用类型a1 == a2:");
System.out.println(a1 == a2);
System.out.println(a2 == a3);//对象赋给新对象连地址都是相同的
System.out.println("-----");
}
} class A{
int i;
public A(int i){
this.i = i;
}
}
基本类型a==b:true
-----
String类型是s1==s2:true
-----
String类型用new String()是s1==s2:false
false
-----
包装类型是i1==i2:true
-----
包装类型是i3==i4:false
-----
包装类型用new Integer()是i5==i6:false
-----
普通引用类型a1 == a2:false
true
-----
package com.lk.C;

public class Test8 {

    public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("基本类型没有equals方法");
System.out.println("-----"); String s1 = "abc";
String s2 = "abc";
System.out.print("String类型的equals方法:");
System.out.println(s1.equals(s2));
System.out.println("-----"); String s3 = new String("abc");
String s4 = new String("abc");//可以看出比较equals方法比较的是堆里的值是否相同
System.out.print("String类型的new String()的equals方法:");
System.out.println(s3.equals(s4));
System.out.println("-----"); System.out.print("String用==赋值和用new String()赋值的比较:");
System.out.println(s1.equals(s3));
System.out.println("-----"); Integer i1 = 1;
Integer i2 = 1;
System.out.print("包装类的equals方法:");
System.out.println(i1.equals(i2));
System.out.println("-----"); Integer i3 = new Integer(1);
Integer i4 = new Integer(1);
System.out.print("包装类的new Integer()用equals方法:");
System.out.println(i3.equals(i4));
System.out.println("-----"); System.out.print("Integer用==赋值和用new Integer()赋值的比较:");
System.out.println(i1.equals(i3));
System.out.println("-----");
} }
基本类型没有equals方法
-----
String类型的equals方法:true
-----
String类型的new String()的equals方法:true
-----
String用==赋值和用new String()赋值的比较:true
-----
包装类的equals方法:true
-----
包装类的new Integer()用equals方法:true
-----
Integer用==赋值和用new Integer()赋值的比较:true
-----
package com.lk.C;

public class Test9 {

    public static void main(String[] args) {
// TODO Auto-generated method stub
Student s1 = new Student("阿坤",21);
Student s2 = new Student("阿坤",21);
Student s3 = new Student();
Student s4 = new Student();
Student s5 = s1;
System.out.print("普通类对象的==非默认构造:");
System.out.println(s1 == s2);
System.out.println(s1 == s5);
System.out.println("-----"); System.out.print("普通类对象的equals非默认构造:");
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s5));
System.out.println("-----"); System.out.print("普通类对象的==默认构造:");
System.out.println(s3 == s4);
System.out.println("-----"); System.out.print("普通类对象的equals默认构造:");
System.out.println(s3.equals(s4));
System.out.println("-----"); System.out.print("对普通对象的属性进行比较equals:");
System.out.println(s1.name.equals(s2.name));
System.out.print("对普通对象的属性进行比较==:");
System.out.println(s1.name == s2.name);
} }
class Student{
public String name;
public int age;
public Student(){ }
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void test(){
System.out.println(this.name);
System.out.println(this.age);
}
}
普通类对象的==非默认构造:false
true
-----
普通类对象的equals非默认构造:false
true
-----
普通类对象的==默认构造:false
-----
普通类对象的equals默认构造:false
-----
对普通对象的属性进行比较equals:true
对普通对象的属性进行比较==:true

从以上的三个程序可以看出:

1)对于==:在简单类型中(int等),这能使用该方法进行比较,这种类型没有equals方法,int的值是存在栈中的,==比较的是栈的内容是否相同。在String类型中,比较特殊,用String=“”;这种进行赋值时,两个相同的值用==比较也是相同的。但是用new String(),赋值就不相同。说明String=“”时,java会检查在堆中是否由相同的值,如果有,把新对象的地址也同老对象的地址赋为相同,因此==比较会相同。但是new String()开辟的就是两个栈,因此用==比较不会相同。对于包装类,如Integer=“”;时,在-128-127会有缓存,请看上面程序。其他的情况与String类似。

2)对于equals:当时String类型或者是包装类,如Integer时,比较的就是堆中的值,Integer也无缓存之说。对于普通类,equals比较的内存的首地址,这时候和==是一样的,即比较两边指向的是不是同一个对象。详细请见程序三。

以上程序都是亲自测试过。希望能对大家有帮助。

以下是一些在百度中找到的说法:http://zhidao.baidu.com/link?url=AMYxGo3NunWY7irH5XLPlHUa0ywvyqgYEAdDUMKJlQvklm686MC_D7ZjT3dX9BmuZWXXjWRV2QHelGJ8GzAxBK

java中,
(1)对于字符串变量来说,equal比较的两边对象的内容,所以内容相同返回的是true。
至于你没问到的“==”,比较的是内存中的首地址,所以如果不是同一个对象,“==”不会返回true 而是false。
举个简单的例子,
String s1="abc", s2="abc";
String s3 =new String("abc");
String s4=new String("abc");
s1==s2 //true,
s1.equals(s2) //true,
s3.equals(s3) //true,equal比较的是内容
s3==s4//false,==比较的是首地址,所以是false
(2)对于非字符串变量,equals比较的内存的首地址,这时候和==是一样的,即比较两边指向的是不是同一个对象,

Sample sa1 = new Sample();
Sample sa2 = new Sample();
sa1.equals(sa2) //false,因为不是同一对象
注意,如果加上
sa1=sa2;
那么
sa1.equals(sa2) //true

Java中==、equals、hashcode的区别与重写equals以及hashcode方法实例(转)的更多相关文章

  1. 【转】Java中==、equals、hashcode的区别与重写equals以及hashcode方法实例

    原文地址:http://www.cnblogs.com/luankun0214/p/4421770.html 感谢网友的分享,记录下来只为学习. 1.重写equals方法实例   部分代码参考http ...

  2. Java中==、equals、hashcode的区别与重写equals以及hashcode方法实例

    1.重写equals方法实例   部分代码参考http://blog.csdn.net/wangloveall/article/details/7899948 重写equals方法的目的是判断两个对象 ...

  3. java中==与equel的区别

    值类型是存储在内存中的堆栈(以后简称栈),而引用类型的变量在栈中仅仅是存储引用类型变量的地址,而其本身则存储在堆中. ==操作比较的是两个变量的值是否相等,对于引用型变量表示的是两个变量在堆中存储的地 ...

  4. java中ArrayList 、LinkList区别

    转自:http://blog.csdn.net/wuchuanpingstone/article/details/6678653 个人建议:以下这篇文章,是从例子说明的方式,解释ArrayList.L ...

  5. Java-杂项: Java中Array和ArrayList区别

    ylbtech-Java-杂项: Java中Array和ArrayList区别 1.返回顶部 1. 1)精辟阐述:可以将 ArrayList想象成一种“会自动扩增容量的Array”. 2)Array( ...

  6. java中a++与++a区别

    java中a++与++a区别 a++与++a的区别,如果单独使用没有任何区别,如果在运算中就有区别了,a++是先运算在赋值,而++a是先赋值在运算!! 先看a++的代码哦 class demo1 { ...

  7. c#与java中byte字节的区别及转换方法

    原文:c#与java中byte字节的区别及转换方法 在java中  byte的范围在 [-128,127] 在C#中  byte的范围在 [0,255] 所以 java程序与C#程序 进行数据传输的时 ...

  8. Java中的“&”和“&&”的区别

    Java中的"&"和"&&"的区别 1."&"是位运算符,"&&"是逻辑 ...

  9. java中PriorityBlockingQueue 和DelayedWorkQueue 区别

    java中PriorityBlockingQueue 和DelayedWorkQueue 区别

随机推荐

  1. JS移动端滑屏事件

    来看看在pc上面的几个事件:onmousedown,onmousemove,onmouseup 我相信大家对这几个事件一定不陌生,第一个onmousedown表示鼠标按下,第二个onmousemove ...

  2. (adhoc) process launch failed: timed out waiting for app to launch

    I had a similar issue when trying to debug an App with Ad-Hoc provisioning... Check which provisioni ...

  3. NavMesh名字、层索引、层值之间的转换

    // Nav层名字-->层的值,1.2.4.8.16 public static int AgentLayerNameToValue(string name) { int idx = NavMe ...

  4. 调用Ajax返回500错误的解决方法

    看代码: public ActionResult UserLogin(LogOnModel model) { #region 验证码验证 #endregion OperationResult resu ...

  5. VirtualBox的网络设置(6种方式)

    VirtualBox 可以为每一个虚拟机分配8个网卡.每一个网卡的连接方式可以选为下列之一: Not attached Network Address Translation (NAT) Bridge ...

  6. 使用 PSD Validator 在线校验 PSD 文件的质量

     PSD Validator 可以帮助你在线校验 PSD 文件的质量,使用的规则来自 Photoshop Etiquette.Photoshop Etiquette 整理了 PSD 文件的规范,例如删 ...

  7. 新开博客 http://wylhyz.github.io/

    刚刚使用hexo在github pages上建立了静态博客,地址 http://wylhyz.github.io/

  8. Java中接口式的匿名内部类的构造方法

    在使用多线程的时候,时常会使用两种方式实现,一种是直接继承Thread类来实现多线程,另外一种就是实现Runnable接口. 我们都知道,接口是没有构造方法的,同时匿名内部类也是没有构造方法的.原因有 ...

  9. C#关键字

    关键字 abstract as base bool break byte case catch char checked decimal default delegate continue doubl ...

  10. 大话设计模式-->模板方法设计模式

    在学习java的过程中,我们肯定听到过设计模式这名词,在行业中有这么一句话,若您能熟练的掌握23种设计模式,那么你便是大牛! 好了,废话不多说,今天我跟大家分享一下23种设计模式之一的  模板方法 设 ...