疯狂Java学习笔记（36）-----------Set集合

举报
brucexiaogui 发表于 2021/12/30 01:18:36 2021/12/30
【摘要】 疯狂Java学习笔记（36）-----------Set集合 Set集合 类似于一个罐子，丢进"Set",集合里的过个对象之间没有明显的顺序。 Set集合与Collection集合基本上完全一样，他没有提供任何额外的方法。 实际上Set就是Collection，只是行为略有不同，Set不允许包含重复元素。允许包含值为null的元素，但最...

疯狂Java学习笔记（36）-----------Set集合

Set集合 类似于一个罐子，丢进"Set",集合里的过个对象之间没有明显的顺序。

Set集合与Collection集合基本上完全一样，他没有提供任何额外的方法。

实际上Set就是Collection，只是行为略有不同，Set不允许包含重复元素。允许包含值为null的元素，但最多只能有一个null元素。

 

常用方法

        按照定义，Set 接口继承 Collection 接口，所有原始方法都是现成的，没有引入新方法。具体的 Set 实现类依赖添加的对象的 equals() 方法来检查等同性。

        各个方法的作用描述：

        public int size() ：返回set中元素的数目，如果set包含的元素数大于Integer.MAX_VALUE，返回Integer.MAX_VALUE；

        public boolean isEmpty() ：如果set中不含元素，返回true  ；
        public boolean contains(Object o) ：如果set包含指定元素，返回true  ；
        public Iterator iterator() ： 返回set中元素的迭代器，元素返回没有特定的顺序，除非set提高该保证的某些类的实例  ；
        public boolean add(Object o) ：如果set中不存在指定元素，则向set加入 ；
        public boolean remove(Object o) ：如果set中存在指定元素，则从set中删除  ；
        public boolean removeAll(Collection c) ：如果set包含指定集合，则从set中删除指定集合的所有元素  ；
        public void clear() ：从set中删除所有元素；

 

原理分析

        HashSet的元素存放顺序和添加进去时候的顺序没有任何关系；而LinkedHashSet 则保持元素的添加顺序；TreeSet则是对我们的Set中的元素进行排序存放。


        一般来说，当要从集合中以有序的方式抽取元素时，TreeSet 实现就会有用处。为了能顺利进行，添加TreeSet  的元素必须是可排序的。 而同样需要对添加到TreeSet中的类对象实现 Comparable  接口的支持。

对于Comparable接口的实现。假定一棵树知道如何保持 java.lang  包装程序器类元素的有序状态。一般说来，先把元素添加到 HashSet，再把集合转换为 TreeSet  来进行有序遍历会更快。这点和HashMap的使用非常的类似。


        其实Set的实现原理是基于Map上面的。Set中很多实现类和Map中的一些实现类的使用上非常的相似。Map中的“键值对”，其中的 “键”是不能重复的。这个和Set中的元素不能重复一致，其实Set利用的就是Map中“键”不能重复的特性来实现的。

 HashSet的巧妙实现：就是建立一个“键值对”，“键”就是我们要存入的对象，“值”则是一个常量。这样可以确保， 我们所需要的存储的信息之是“键”。而“键”在Map中是不能重复的，这就保证了我们存入Set中的所有的元素都不重复。而判断是否添加元素成功，则是通 过判断我们向Map中存入的“键值对”是否已经存在，如果存在的话，那么返回值肯定是常量：PRESENT  ，表示添加失败。如果不存在，返回值就为null 表示添加成功。

 

 

下面是一个测试类

SetTest.java

[java]  view plain  copy
  1. package com.haixu.set;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Set;  
  5. /* 
  6.  * Set 集合测试！ 
  7.  * */  
  8. public class SetTest {  
  9.  public static void main(String[] args) {  
  10.   //HashSet是Set的典型实现  
  11.  Set<String> str1 = new HashSet<String>();  
  12.    
  13.  //添加一个字符串  
  14.  str1.add(new String("you will succcess!"));  
  15.    
  16.  //再次添加一个字符串对象  
  17.  //因为两个字符串对象通过equals方法比较相等  
  18.  //添加失败将返回false  
  19.  boolean result = str1.add(new String("Hold on Haixu!"));  
  20.  System.out.println(result +"------->" + str1);  
  21.   
  22.  }  
  23.   
  24. }  


 

HashSet类：

      1、HashSet不能重复存储equals相同的数据 。原因就是equals相同，数据的散列码也就相同（hashCode必须和equals兼容）。大量相同的数据将存放在同一个散列单元所指向的链表中，造成严重的散列冲突，对查找效率是灾难性的。

      2、HashSet的存储是无序的 ，没有前后关系，他并不是线性结构的集合。

      3、hashCode必须和equals必须兼容

 

当向HashSet集合中存入一个元素师，HsahSet会调用对象的hashCode方法来得到对象的hashCode值，然后根据该HashCode值决定该对象的HashSet的位置。

如果两个元素通过equals（）方法比较返回true，但他们的哈市COde方法返回值不相等，HashSet将会把他们存放在不同的位置！

 

 

 

 

这张图片价值不菲呀！好好阅读呀！

在网上找了好多的资料都没有仔细详细的讲解HashSet 类，只能总计总结了！

HashSetTest.java

 

[java]  view plain  copy
  1. package com.haixu.set;  
  2. /* 
  3.  * HashSet类的练习，测试对象的存储位置 
  4.  * */  
  5. import java.util.HashSet;  
  6.   
  7. class A{  
  8.       
  9.     public boolean equals(Object obj){  
  10.         return true;  
  11.     }  
  12.       
  13. }  
  14. class B{  
  15.       
  16.     public int hashCode(){  
  17.         return 1;  
  18.     }  
  19.       
  20. }  
  21.   
  22. class C{  
  23.       
  24.     public int hashCode(){  
  25.         return 2;  
  26.         }  
  27.     public boolean equals(Object obj){  
  28.         return true;  
  29.     }  
  30. }  
  31.   
  32. public class HashSetTest {  
  33.       
  34.     public static void main(String[] args) {  
  35.         HashSet<Object> str1 = new HashSet<Object>();  
  36.         str1.add(new A());  
  37.         str1.add(new A());  
  38.         str1.add(new B());  
  39.         str1.add(new B());  
  40.         str1.add(new C());  
  41.         str1.add(new C());  
  42.         System.out.println(str1);  
  43.     }  
  44.   
  45. }  


运行结果“[com.haixu.set.B@1, com.haixu.set.B@1,com.haixu.set.C@2,com.haixu.set.A@1fb8ee3,com.haixu.set.A@c17164]

 

HashSetTest2.java

 

[java]  view plain  copy
  1. package com.haixu.set;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Iterator;  
  5.   
  6. class R{  
  7.     int count;  
  8.     public R(int count){  
  9.         this.count = count;  
  10.     }  
  11.     public String toString(){  
  12.         return "R[count:" + count + "]";  
  13.     }  
  14.     public boolean equals(Object obj){  
  15.         if(this == obj){  
  16.             return true;  
  17.         }  
  18.         if(obj != null && obj.getClass() == R.class ){  
  19.             R r = (R)obj;  
  20.             if(r.count == this.count){  
  21.                 return true;  
  22.             }  
  23.         }  
  24.         return false;  
  25.     }  
  26.     public int hashCode(){  
  27.         return this.count;  
  28.     }  
  29. }  
  30. public class HashSetTest2 {  
  31.       
  32.     public static void main(String[] args) {  
  33.         HashSet<Object> hs =new HashSet<Object>();  
  34.         hs.add(new R(5));  
  35.         hs.add(new R(-3));  
  36.         hs.add(new R(9));  
  37.         hs.add(new R(-2));  
  38.         //打印HashSet集合，集合元素没有重复  
  39.         System.out.println(hs);  
  40.         //取出一个元素  
  41.         Iterator it = (Iterator) hs.iterator();  
  42.         R first = (R)it.next();  
  43.     //为第一个元素count实例变量赋值  
  44.         first.count = -3;  
  45.         //再次输出HashSet集合，集合没有重复元素  
  46.         System.out.println(hs);  
  47.         //删除count为-3的R对象  
  48.         hs.remove(new R(-3));  
  49.         //可以看出被删除类一个对象  
  50.         System.out.println(hs);  
  51.           
  52.         System.out.println("hs是否包含count为-3的R对象？" + hs.contains(new R(-3)));  
  53.         System.out.println("hs是否包含count为5的R对象？" + hs.contains(new R(5)));  
  54.           
  55.     }  
  56.   
  57. }  



 TreeSet原理:
   /*
 * TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法
 * 
 * Integer能排序(有默认顺序), String能排序(有默认顺序), 自定义的类存储的时候出现异常(没有顺序)
 * 
 * 如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口
 *   在类上implement Comparable
 *   重写compareTo()方法
 *   在方法内定义比较算法, 根据大小关系, 返回正数负数或零
 *   在使用TreeSet存储对象的时候, add()方法内部就会自动调用compareTo()方法进行比较, 根据比较结果使用二叉树形式进行存储
 */

TreeSet是依靠TreeMap来实现的。
TreeSet是一个有序集合，TreeSet中的元素将按照升序排列，缺省是按照自然排序进行排列，意味着TreeSet中的元素要实现Comparable接口。或者有一个自定义的比较器。
我们可以在构造TreeSet对象时，传递实现Comparator接口的比较器对象。

 

 

import java.util.Iterator;
import java.util.*;

public class TreeSetTest {
    public static void main(String[] args) {
        Set ts = new TreeSet();
        ts.add("Haixu");
        ts.add("success");
        ts.add("you can!");
        Iterator it = ts.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

输出结果“Haixu， success，you can！

打印结果不是和先前加入的顺序一样，它是按照一个字母的排序法进行排序的。这是因为String 类实现了Comparable接口。

如果我们自己定义的一个类的对象要加入到TreeSet当中，那么这个类必须要实现Comparable接口。

 

 

   比较器

在使用Arrays对数组中的元素进行排序的时候，可以传递一个比较器。

在使用Collections对集合中的元素进行排序的时候，可以传递一个比较器。

那么在使用TreeSet对加入到其中的元素进行排序的时候可以传入一个比较器吗？

  public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<E,Object>(comparator));
    }

通过查看它的构造方法就知道可以传入一个比较器。

 

EnumSet 是一个与枚举类型一起使用的专用 Set 实现。枚举set中所有元素都必须来自单个枚举类型（即必须是同类型，且该类型是Enum的子类）。
 枚举类型在创建 set 时显式或隐式地指定。枚举 set 在内部表示为位向量。 此表示形式非常紧凑且高效。此类的空间和时间性能应该很好，
 足以用作传统上基于 int 的“位标志”的替换形式，具有高品质、类型安全的优势。
 如果指定的 collection 也是一个枚举 set，则批量操作（如 containsAll 和 retainAll）也应运行得非常快。
 由 iterator 方法返回的迭代器按其自然顺序 遍历这些元素（该顺序是声明枚举常量的顺序）。
 返回的迭代器是弱一致的：它从不抛出 ConcurrentModificationException，也不一定显示在迭代进行时发生的任何 set 修改的效果。
 不允许使用 null 元素。试图插入 null 元素将抛出 NullPointerException。但是，
 试图测试是否出现 null 元素或移除 null 元素将不会抛出异常。
 像大多数 collection 一样，EnumSet 是不同步的。如果多个线程同时访问一个枚举 set，
 并且至少有一个线程修改该 set，则此枚举 set 在外部应该是同步的。这通常是通过对自然封装该枚举 set 的对象执行同步操作来完成的。
 如果不存在这样的对象，则应该使用 Collections.synchronizedSet(java.util.Set) 方法来“包装”该 set。
 最好在创建时完成这一操作，以防止意外的非同步访问：
  Set<MyEnum> s = Collections.synchronizedSet(EnumSet.noneOf(Foo.class));
 实现注意事项：所有基本操作都在固定时间内执行。虽然并不保证，但它们很可能比其 HashSet 副本更快。
 如果参数是另一个 EnumSet 实例，则诸如 addAll() 和 AbstractSet.removeAll(java.util.Collection) 之类的批量操作
 也会在固定时间内执行。
注意1：不允许使用 null 元素。试图插入 null 元素将抛出 NullPointerException。但是，
 试图测试是否出现 null 元素或移除 null 元素将不会抛出异常。
注意2：EnumSet是不同步的。不是线程安全的。
注意3：EnumSet的本质就为枚举类型定制的一个Set，且枚举set中所有元素都必须来自单个枚举类型。
注意4：关于EnumSet的存储，文档中提到是这样的。 “枚举 set 在内部表示为位向量。”
 我想它应该是用一个bit为来表示的于之对应的枚举变量是否在集合中。
 比如：0x1001
 假如约定从低位开始，就表示第0个，和第三个枚举类型变量在EnumSet中。
 这样的话空间和时间性能也就应该很好。
注意5:至于Enum的枚举常量的位置（序数）可以用Enum的ordinal()方法得到。
注意6:在jdk内部可以一个数组的形式一个枚举的枚举常量。
下面是来自来JDK中RegularEnumSet.java的一个示例
    private static <E extends Enum<E>> E[] getUniverse(Class<E> elementType) {
        return SharedSecrets.getJavaLangAccess()
     .getEnumConstantsShared(elementType);
    }
注意7:元素属于哪种枚举类型必须在创建 set 时显式或隐式地指定.
注意8：关于枚举类型的更多知识可参考《枚举类型》

Enumset 是个虚类，我们只能通过它提供的静态方法来返回 Enumset 的实现类的实例。
返回EnumSet的两种不同的实现 ：如果EnumSet大小小于64，
就返回RegularEnumSet实例(当然它继承自EnumSet)，这个EnumSet实际上至用了一个long来存储这个EnumSet。
如果 EnumSet大小大于等于64，则返回JumboEnumSet实例，它使用一个long[]来存储。这样做的好处很明显： 大多数情况下返回的RegularEnumSet效率比JumboEnumSet高很多。

 

[java]  view plain  copy
  1. 实例1  
  2. import java.util.Comparator;  
  3. import java.util.EnumSet;  
  4. import java.util.Random;  
  5. import java.util.concurrent.SynchronousQueue;  
  6. import java.util.concurrent.TimeUnit;  
  7. public class Test {  
  8.  /** 
  9.    * @param args 
  10.    */  
  11.  public static void main(String[] args) {  
  12.   System.out.println("EnumSet.noneOf");  
  13.   EnumSet<Student> set=EnumSet.noneOf(Student.class);  
  14.    set.add(Student.HARRY);  
  15.    set.add(Student.ROBBIE);  
  16.    set.add(Student.ROBIN);  
  17.   for(Student p:set)  
  18.    System.out.println(p);  
  19.   set.clear();  
  20.   System.out.println("EnumSet.allOf");  
  21.   set=EnumSet.allOf(Student.class);  
  22.   for(Student p:set)  
  23.    System.out.println(p);  
  24.   set.clear();  
  25.   System.out.println("EnumSet.Of one");  
  26.   set=EnumSet.of(Student.ROBIN);  
  27.   for(Student p:set)  
  28.    System.out.println(p);  
  29.   System.out.println("EnumSet.Of two");  
  30.   set=EnumSet.of(Student.ROBIN,Student.HARRY);  
  31.   for(Student p:set)  
  32.    System.out.println(p);  
  33.  }  
  34. }  
  35. enum   Student  
  36. {  
  37.  ROBIN("robin"),  
  38.  HARRY("harry",40),  
  39.  ROBBIE("robbie");  
  40.  String name;  
  41.  int age;  
  42.  private Student(String name)  
  43.  {  
  44.   this(name,0);  
  45.  }  
  46.  private Student(String name,int age)  
  47.  {  
  48.   this.name=name;  
  49.   this.age=age;  
  50.  }  
  51.  public String toString()  
  52.  {  
  53.   return name;  
  54.  }  
  55. }   

转载自：https://blog.csdn.net/u011225629/article/details/45826883

文章来源: brucelong.blog.csdn.net，作者：Bruce小鬼，版权归原作者所有，如需转载，请联系作者。

原文链接：brucelong.blog.csdn.net/article/details/79992823

【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Java 数据结构
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入