基本完全一样,没有提供任何额外的方法。
Set集合不允许包含相同的元素,如果试图把两个相同元素加入到同一个Set集合中,则添加失败,add方法返回false,且
新元素不会被加入。
Set判断两个对象相同不是使用==运算符,而是根据equals方法。也就是说,如果只要两个对象用equals方法比较返回
true,Set就不会接受这两个对象;反之,只要两个对象用equals方法比较返回false,Set就会接受这两个对象(甚至这
两个对象是同一个对象,Set也可把它们当成两个对象处理)。下面是使用Set的程序实例。
- public class TestSet {
- public static void main(String[] args) {
- Set books = new HashSet();
- books.add(new String("张大三"));
- System.out.println(books);//打印结果:[张大三]
- //再次添加一个字符串对象
- //因为这连个字符串对象通过equals方法比较相等,所以添加失败,返回false
- boolean result = books.add(new String("张大三"));
- //下面看到集合中只有一个元素
- System.out.println(result);
- System.out.println(books);//打印结果:[张大三]
- }
- }
从上面程序中可以看出,books集合两次添加的字符串对象明显不是同一个对象(因为两个都调用了new关键字来创建对象)
,这两个字符串对象使用==运算符判断肯定返回false,但它们通过equals比较返回true,所以添加失败。最后输出books
集合时,将会看到输出结果只有一个元素。
上面介绍的Set集合的通用知识,因为完全适合HashSet、TreeSet、EnumSet三个实现类,只是三个实现类还各有特色。
HashSet类
HashSet是Set接口的典型实现,大多数时候使用Set集合时就是使用这个实现类。HashSet按Hash算法来存储集合中的元素,因此具有很好的存取和查找功能。
HashSet具有以下的特点:
== 不能保证元素的排列顺序,顺序有可能发生变化
== HashSet不是同步的,如果多个线程同时访问一个Set集合,如果多个线程同时访问一个HashSet,如果有2条或者
2条以上线程同时修改了HashSet集合时,必须通过代码来保证其同步
== 集合元素可以是null
当像HashSet集合中存入一个元素时,HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,然后根据
该hashCode值来决定该对象在HashSet中存储位置。如果两个元素通过equals比较返回true,但它们的hashCode()方法返回值
不相等,HashSet将会把它们存储在不同位置,也可以添加成功。
简单说,HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等,并且两个对象的hashCode()方法
返回值也相等。
下面程序分别提供了三个类A、B、C,他们分别重写了equals、hashCode两个方法的一个或全部,通过下面程序
可以看到HashSet判断集合元素相同的标准。
- public class TestHashSet {
- public static void main(String[] args) {
- HashSet books = new HashSet();
- books.add(new A());
- books.add(new A());
- books.add(new B());
- books.add(new B());
- books.add(new C());
- books.add(new C());
- System.out.println(books);//打印结果:[B@1, B@1, C@2, A@4f1d0d, A@1fc4bec]
- }
- //A类中的equals方法总是返回true,但没有重写其hashCode()方法
- public class A{
- public boolean equals(Object obj){
- return true;
- }
- }
- //类B的hashCode()方法总是返回1,但没有重写其equals()方法
- class B{
- public int hashCode(){
- return 1;
- }
- }
- //类c的hashCode()方法总是返回2,重写其equals()方法
- class C{
- public int hashCode(){
- return 2;
- }
- public boolean equals(Object obg){
- return true;
- }
- }
- }
上面程序中books集合分别添加了2个A对象、2个B对象和2个C对象,其中C对象重写了equals()方法总是返回true、
hashCode()方法总是返回2,这将导致HashSet将会把2个C对象当成同一个对象。运行上面程序,看到如下结果:
[B@1, B@1, C@2, A@4f1d0d, A@1fc4bec]
这里有一个问题需要注意:如果需要把一个对象放入HashSet中时,如果重写该对象对应类的equals方法时,也应该重写
其hashCode()方法,其规则是:如果2个对象通过equals方法比较返回true时,这两个对象的hashCode值也应该相同。
如果两个对象通过equals方法比较返回true时,但这两个对象的hashCode()方法返回不同的hashCode时,这将导致
HashSet将会把这两个对象保存在HashSet的不同的位置,从而两个对象都可以添加成功,这与Set集合的规则有点出入。
如果两个对象的hashCode()方法返回的hashCode相同,但它们通过equals方法比较返回false时将更麻烦:因为两个
对象的hashCode值相同,HashSet将试图把它们保存在同一个位置,但实际上又不行(否则将只剩下一个对象),所以处理
起来比较麻烦;而且HashSet访问集合元素时是根据元素的hashCode值来访问的,如果HashSet中包含两个元素有相同的hashCode
值,将会导致性能下降。
hashCode方法对于HashSet的作用是什么?
首先要理解hash算法的功能:它能保证通过一个对象快速查找到另一个对象。hash算法的价值在于速度,它可以保证
查询得到快速执行。当需要查询集合中某一个元素时,hash算法可以直接根据该元素的值得到该元素保存在何处,从而
可以让程序快速找到该元素。为了理解这个概念,我们先看数组(数组是所有能存储一组元素里最快的数据结构):数组可以
包含多个元素,每个元素也有索引,如果需要访问某个数组元素,只需提供该元素的索引,该索引即指出了该元素在数组内存
区里的位置。
表面上看起来,HashSet集合里的元素都没有索引,实际上当程序向HashSet集合中添加元素时,HashSet会根据该元素
的hashCode值来决定它的存储位置--也就是说,每个元素的hashCode值就是它的“索引”。
为什么不直接使用数组,还需要使用HashSet呢?因为数组元素的索引是连续的,而且数组的长度是固定的,无法自由
增加数组的长度。而HashSet就不一样了,HashSet采用每个元素的hashCode值作为其索引,从而可以自由增加数组的长度
,并可以根据元素的hashCode来访问元素。因此,当从HashSet中访问元素时,HashSet先计算该元素的hashCode值(也就是
该对象的hashCode()方法返回的值),最后直接到HashSe对应的位置去取出该元素。
HashSet中每个能存储元素的“槽位(slot)”通常称为“桶(bucket)”,如果有多个元素的hashCode相同,但它们通过
equals方法比较返回false,就需要在一个“桶”里放多个元素,从而导致性能下降。
下面给出重写hashCode()方法的基本规则:
==当两个对象通过equals方法比较返回true时,这两个对象的hashCode应该相等。
==对象中用作equals比较标准的属性,都应该用来计算hashCode值。
如果想HashSet中添加一个可变对象后,并且后面程序修改了该可变对象的属性,可能导致它与集合中其他元素相同
(即两个对象通过equals方法比较返回true,两个对象的hashCode值也相等),这就有可能导致HashSet中包含两个相同的
对象。下面程序演示了这种情况。
- public class R {
- int count;
- public R(int count){
- this.count = count;
- }
- public String toString(){
- return "R(count属性:" + count + ")";
- }
- public boolean equals(Object obj){
- if(obj instanceof R){
- R r = (R)obj;
- if(r.count == this.count){
- return true;
- }
- }
- return false;
- }
- public int hashCode(){
- return this.count;
- }
- }
- public class TestHashSet2 {
- public static void main(String[] args) {
- HashSet hs = new HashSet();
- hs.add(new R(5));
- hs.add(new R(-3));
- hs.add(new R(9));
- hs.add(new R(-2));
- System.out.println(hs);
- //打印出的结果是:[R(count属性:5), R(count属性:9), R(count属性:-3), R(count属性:-2)]
- //集合元素没有重复
- //取出第一个元素
- Iterator it = hs.iterator();
- R first = (R)it.next();
- //为第一个元素的count属性赋值
- first.count = -3;
- System.out.println(hs);
- //打印出的结果是:[R(count属性:-3), R(count属性:9), R(count属性:-3), R(count属性:-2)]
- //集合元素有重复元素
- //删除一个count为-3的R对象
- hs.remove(new R(-3));
- System.out.println(hs);
- //打印出的结果是:[R(count属性:-3), R(count属性:9), R(count属性:-2)]
- //可以看到集合元素少了一个
- System.out.println("hs集合中是否包含count为-3的R对象?" + hs.contains(new R(-3)));
- //输出false
- System.out.println("hs集合中是否包含count为5的R对象?" + hs.contains(new R(5)));
- //输出false
- }
- }
如上面的程序提供了R类,R类中重写了equals(Obejct obj)方法和hashCode()方法,这两个方法都是通过R对象的属性
来判断的 ,修改了Set集合中第一个R对象的count属性,这将导致该R对象与集合中其他对象相同。打印出来的数据可以看出
集合中第一个元素和第三个元素完全相同,这表明两个元素已经重复,但因为HashSet在添加他们的时候已经把它们添加到了
不同地方,所以HashSet完全可以容纳两个相同的元素。
但此时HashSet比较混乱:当试图删除count为-3的R对象时,HashSet会计算稿对象的hashCode值,从而找出该对象在
集合中的位置 ,然后把此处的对象与count为-3的R对象通过equals方法进行比较,如果想等则删除该对象---HashSet只有
第三个元素才满足该条件(第一个元素实际上保存在count为5的R对象的位置),所以第三个元素被删除。至于第一个count为
-3的R对象,它保存在count为5的R对象的位置,但使用equals方法拿它和count为5的R对象比较又返回false,这将导致
HashSet不可能准确访问该元素。
所以说,当向HashSet中添加可变对象时,必须十分小心。如果修改HashSet集合中的对象,有可能导致该对象与集合中
其他对象相等,从而导致HashSet无法准确访问该对象。
HashSet还有一个子类LinkedHashSet,LinkedHashSet集合也是根据元素hashCode值来决定元素存储位置,但它同时
使用链表维护元素的次序,这样使得元素看起来是以插入的顺序保存的。也就是说,当遍历LinkedHashSet集合里元素时,
HashSet将会元素的添加的顺序来访问集合里的元素。
LinkedHashSet需要维护元素的插入顺序,因此性能略低于HashSet的性能,但在迭代访问Set里的全部元素时将有很好
的性能,因为他以链表来维护内部顺序。
- public class TestLinkedHashSet {
- public static void main(String[] args) {
- LinkedHashSet books = new LinkedHashSet();
- books.add("我爱Java");
- books.add("我爱Android");
- books.add("我爱学习");
- System.out.println(books);
- //[我爱Java, 我爱Android, 我爱学习]
- }
- }