黑马程序员技术交流社区

标题: 自学时的问题-----关与hashset [打印本页]
作者: soarky    时间: 2014-4-11 17:05
标题: 自学时的问题-----关与hashset
hashset为什么要重写hashCode() 和 equals() 方法？以及重写时的代码解析？
作者: K.L.Zous    时间: 2014-4-11 17:11
object对象中的 public boolean equals(Object obj)，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true；
注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。如下：
(1)当obj1.equals(obj2)为true时，obj1.hashCode() == obj2.hashCode()必须为true
(2)当obj1.hashCode() == obj2.hashCode()为false时，obj1.equals(obj2)必须为false
如果不重写equals，那么比较的将是对象的引用是否指向同一块内存地址，重写之后目的是为了比较两个对象的value值是否相等。特别指出利用equals比较八大包装对象
（如int，float等）和String类（因为该类已重写了equals和hashcode方法）对象时，默认比较的是值，在比较其它自定义对象时都是比较的引用地址
hashcode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进行判断是否相同的。
这样如果我们对一个对象重写了euqals，意思是只要对象的成员变量值都相等那么euqals就等于true，但不重写hashcode，那么我们再new一个新的对象，
当原对象.equals（新对象）等于true时，两者的hashcode却是不一样的，由此将产生了理解的不一致，如在存储散列集合时（如Set类），将会存储了两个值一样的对象，
导致混淆，因此，就也需要重写hashcode()
作者: 歌诗王道    时间: 2014-4-11 17:32
hashset判断集合中的元素是否唯一，是通过元素的两个方法，hashCode和equals方法来完成，如果元素的HashCode值相同，才会判断equals是否为true，如果元素的HashCode值不同，才会调用equals,复写这两个方法的代码解析如下：
  1. public static int hashCode()  //这是复写hashcode方法，原本是通过hash算法得出不同的hash值，现在为了保证哈希地址值一致，统一返回一个数，可以是任意的
  2.     {
  3.          return 60;
  4.      }
  5.     public boolean equals(Object obj)  //这是复写equals方法，用传入person类作为参数作为一个例子
  6.     {
  7.          if(!(obj instanceof Person))  //先判断一下传进来的参数是否为Person类的对象，是的话才能判断
  8.               return false;
  9.          Person p = (Person)obj;  //多态的局限性，object类里并没有person的属性，需要强转为person类型
  10.          return this.name.equals(p.name);  //比较一下字符串是否相同，并返回
  11.      }
复制代码
作者: caijunsong    时间: 2014-4-11 22:37
  1. 1、HashSet如何添加元素
  2.          当向一个HashSet集合添加元素的时候，HashSet会调用对象的hashCode()方法来得到哈希值，然后根据HashCode值决定该对象在HashSet中的存储位置，如果

  4.         对应哈希值的内存中没有元素，则添加成功；如果对应的哈希值得内存中有了元素，则调用对象的equals方法和内存中元素比较，如果一样，就不无法添加；

  6.         如果不一样，则也能添加成功（只是在这个内存中，两个元素以链表的形式组织),当然如果相同的对象他们的哈希值不同，也能把元素添加进去

  8. [java] view plaincopyprint?import java.util.*;  
  9. import java.util.*;  
  10. class A  
  11. {  
  12.     //模拟哈希值相同，对象元素相同情况   
  13.     private String name;  
  14.     A(String name){this.name=name;}  
  15.     public int hashCode()  
  16.     {  
  17.         return name.hashCode();  
  18.     }  
  19.     public boolean equals(Object o)  
  20.     {  
  21.         A p=(A)o;  
  22.        return p.name.equals(name);  
  23.     }  
  24.     public String toString()  
  25.     {  
  26.         return name;  
  27.     }  
  28. }  
  29. class B  
  30. {  
  31.     //模拟哈希值相同，对象元素不同的情况   
  32.     private String name;  
  33.     B(String name){this.name=name;}  
  34.     public int hashCode()  
  35.     {  
  36.         return 1;  
  37.     }  
  38.     public boolean equals(Object o)  
  39.     {   
  40.        B p=(B)o;  
  41.        return false;  
  42.     }  
  43.     public String toString()  
  44.     {  
  45.         return name;  
  46.     }  
  47. }  
  48. class C  
  49. {  
  50.     //模拟哈希值不同，但对象元素相同的情况   
  51.     private String name;  
  52.     boolean b=false;  
  53.     C(String name){this.name=name;}  
  54.     public int hashCode()  
  55.     {  
  56.         if(b==false)  
  57.         {  
  58.           b=true;  
  59.           return 1;  
  60.         }  
  61.         else  
  62.             return 3;  
  63.     }  
  64.     public boolean equals(Object o)  
  65.     {  
  66.         return true;  
  67.     }  
  68.     public String toString()  
  69.     {  
  70.         return name;  
  71.     }  
  72. }  
  73. public class SetDemo  
  74. {  
  75.     public static void main(String[]agrs)  
  76.     {  
  77.          
  78.         //哈希值相同，但元素相同无法插入无语   
  79.         HashSet book1=new HashSet();  
  80.         book1.add(new A("xiaocai"));  
  81.         book1.add(new A("xiaocai"));  
  82.         System.out.println(book1);  
  83.         
  84.         //当哈希值相同，但元素比较不同，仍可以插入集合   
  85.         HashSet book2=new HashSet();  
  86.         book2.add(new B("xiaocui"));  
  87.         book2.add(new B("xiaocui"));  
  88.         System.out.println(book2);  
  89.   
  90.         //虽然哈希值不同，当元素相同，仍然可以插入集合   
  91.         HashSet book3=new HashSet();  
  92.         book3.add(new B("xiaosun"));  
  93.         book3.add(new B("xiaosun"));  
  94.         System.out.println(book3);  
  95.     }  
  96. }  
  97. import java.util.*;
  98. import java.util.*;
  99. class A
  100. {
  101.         //模拟哈希值相同，对象元素相同情况
  102.         private String name;
  103.         A(String name){this.name=name;}
  104.     public int hashCode()
  105.         {
  106.                 return name.hashCode();
  107.         }
  108.         public boolean equals(Object o)
  109.         {
  110.         A p=(A)o;
  111.            return p.name.equals(name);
  112.         }
  113.         public String toString()
  114.         {
  115.         return name;
  116.         }
  117. }
  118. class B
  119. {
  120.         //模拟哈希值相同，对象元素不同的情况
  121.         private String name;
  122.         B(String name){this.name=name;}
  123.     public int hashCode()
  124.         {
  125.                 return 1;
  126.         }
  127.         public boolean equals(Object o)
  128.         {  
  129.        B p=(B)o;
  130.            return false;
  131.         }
  132.     public String toString()
  133.         {
  134.         return name;
  135.         }
  136. }
  137. class C
  138. {
  139.         //模拟哈希值不同，但对象元素相同的情况
  140.         private String name;
  141.         boolean b=false;
  142.         C(String name){this.name=name;}
  143.         public int hashCode()
  144.         {
  145.                 if(b==false)
  146.                 {
  147.                   b=true;
  148.                   return 1;
  149.                 }
  150.                 else
  151.                         return 3;
  152.         }
  153.         public boolean equals(Object o)
  154.         {
  155.                 return true;
  156.         }
  157.     public String toString()
  158.         {
  159.         return name;
  160.         }
  161. }
  162. public class SetDemo
  163. {
  164.         public static void main(String[]agrs)
  165.         {
  166.                
  167.                 //哈希值相同，但元素相同无法插入无语
  168.         HashSet book1=new HashSet();
  169.         book1.add(new A("xiaocai"));
  170.         book1.add(new A("xiaocai"));
  171.                 System.out.println(book1);
  172.       
  173.                 //当哈希值相同，但元素比较不同，仍可以插入集合
  174.                 HashSet book2=new HashSet();
  175.         book2.add(new B("xiaocui"));
  176.         book2.add(new B("xiaocui"));
  177.                 System.out.println(book2);

  179.                 //虽然哈希值不同，当元素相同，仍然可以插入集合
  180.         HashSet book3=new HashSet();
  181.         book3.add(new B("xiaosun"));
  182.         book3.add(new B("xiaosun"));
  183.                 System.out.println(book3);
  184.         }
  185. }   当然我们更希望的是HashSet集合中的每个对应的哈希值中只存放一个元素，因此我们就必须正确重写对象的hashCode和equals方法，通常我们尽量保证两个对象通过equals()方法比较返回true时，他们的hashCode()方法返回值也相等      

复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2