类关系图

Set - 图1

功能介绍

包路径：java.util

功能描述：Set 继承自Collection接口，只是行为上不同，Set 不保存重复的元素**。Set集合的实现类可说是基于Map集合去写的。通过内部封装Map集合来实现的比如HashSet内部封装了HashMap

Set 接口存储一组唯一，无序的对象。

特点：插入无序，不可指定位置访问。

源码解析

Set

  1. package java.util;
  3. /**
  4.  *
  5.  * @param <E> the type of elements maintained by this set
  6.  *
  7.  * @author  Josh Bloch
  8.  * @author  Neal Gafter
  9.  * @see Collection
  10.  * @see List
  11.  * @see SortedSet
  12.  * @see HashSet
  13.  * @see TreeSet
  14.  * @see AbstractSet
  15.  * @see Collections#singleton(java.lang.Object)
  16.  * @see Collections#EMPTY_SET
  17.  * @since 1.2
  18.  */
  19. public interface Set<E> extends Collection<E> {
  20.     // Query Operations
  22.     /**
  23.      * 获取集合元素数量
  24.      * @return the number of elements in this set (its cardinality)
  25.      */
  26.     int size();
  28.     /**
  29.      * 判断集合是否为空
  30.      * @return <tt>true</tt> if this set contains no elements
  31.      */
  32.     boolean isEmpty();
  34.     /**
  35.      * 判断集合内是否存在目标元素
  36.      * @param o element whose presence in this set is to be tested
  37.      * @return <tt>true</tt> if this set contains the specified element
  38.      */
  39.     boolean contains(Object o);
  41.     /**
  42.      * 返回迭代器
  43.      * @return an iterator over the elements in this set
  44.      */
  45.     Iterator<E> iterator();
  47.     /**
  48.      * 将集合转为数组返回
  49.      * @return an array containing all the elements in this set
  50.      */
  51.     Object[] toArray();
  53.     /**
  54.      * 将集合转为目标类型的数组返回
  55.      * @param a the array into which the elements of this set are to be
  56.      *        stored, if it is big enough; otherwise, a new array of the same
  57.      *        runtime type is allocated for this purpose.
  58.      * @return an array containing all the elements in this set
  59.      */
  60.     <T> T[] toArray(T[] a);
  63.     // Modification Operations
  65.     /**
  66.      * 添加元素
  67.      * @param e element to be added to this set
  68.      * @return <tt>true</tt> if this set did not already contain the specified
  69.      *         element
  70.      */
  71.     boolean add(E e);
  74.     /**
  75.      * 从集合中移除元素
  76.      * @param o object to be removed from this set, if present
  77.      * @return <tt>true</tt> if this set contained the specified element
  78.      */
  79.     boolean remove(Object o);
  82.     // Bulk Operations
  84.     /**
  85.      * 判断是否存在传入集合的所有元素（交集）
  86.      * @param  c collection to be checked for containment in this set
  87.      * @return <tt>true</tt> if this set contains all of the elements of the
  88.      *         specified collection
  89.      */
  90.     boolean containsAll(Collection<?> c);
  92.     /**
  93.      * 添加传入集合的所有元素
  94.      * @param  c collection containing elements to be added to this set
  95.      * @return <tt>true</tt> if this set changed as a result of the call
  96.      * @see #add(Object)
  97.      */
  98.     boolean addAll(Collection<? extends E> c);
  100.     /**
  101.      * 仅保留传入集合里存在的元素（求交集）
  102.      * @param  c collection containing elements to be retained in this set
  103.      * @return <tt>true</tt> if this set changed as a result of the call
  104.      * @see #remove(Object)
  105.      */
  106.     boolean retainAll(Collection<?> c);
  108.     /**
  109.      * 仅移除传入集合的所有元素
  110.      * @param  c collection containing elements to be removed from this set
  111.      * @return <tt>true</tt> if this set changed as a result of the call
  112.      * @see #remove(Object)
  113.      * @see #contains(Object)
  114.      */
  115.     boolean removeAll(Collection<?> c);
  117.     /**
  118.      * 清空集合
  119.      */
  120.     void clear();
  123.     // Comparison and hashing
  125.     /**
  126.      * 判断集合是否相等（集合内所有元素相等则为相等）
  127.      * @param o object to be compared for equality with this set
  128.      * @return <tt>true</tt> if the specified object is equal to this set
  129.      */
  130.     boolean equals(Object o);
  132.     /**
  133.      * 
  134.      * @return the hash code value for this set
  135.      * @see Object#equals(Object)
  136.      * @see Set#equals(Object)
  137.      */
  138.     int hashCode();
  140.     /**
  141.      * 返回切割器
  142.      * @return a {@code Spliterator} over the elements in this set
  143.      * @since 1.8
  144.      */
  145.     @Override
  146.     default Spliterator<E> spliterator() {
  147.         return Spliterators.spliterator(this, Spliterator.DISTINCT);
  148.     }
  149. }

AbstractSet

AbstractSet是一个抽象类，实现了Set接口，同时继承了AbstractCollection抽象类

  1. package java.util;
  3. /**
  4.  *
  5.  * @author  Josh Bloch
  6.  * @author  Neal Gafter
  7.  * @see Collection
  8.  * @see AbstractCollection
  9.  * @see Set
  10.  * @since 1.2
  11.  */
  13. public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {
  14.     /**
  15.      * Sole constructor.  (For invocation by subclass constructors, typically
  16.      * implicit.)
  17.      */
  18.     protected AbstractSet() {
  19.     }
  21.     // Comparison and hashing
  23.     /**
  24.      * 比较两个集合是否相等
  25.      * @param o object to be compared for equality with this set
  26.      * @return <tt>true</tt> if the specified object is equal to this set
  27.      */
  28.     public boolean equals(Object o) {
  29.         if (o == this)
  30.             return true;
  32.         if (!(o instanceof Set))
  33.             return false;
  34.         Collection<?> c = (Collection<?>) o;
  35.         if (c.size() != size())
  36.             return false;
  37.         try {
  38.             // 是否全部存在
  39.             return containsAll(c);
  40.         } catch (ClassCastException unused)   {
  41.             return false;
  42.         } catch (NullPointerException unused) {
  43.             return false;
  44.         }
  45.     }
  47.     /**
  48.      * 
  49.      * @return the hash code value for this set
  50.      * @see Object#equals(Object)
  51.      * @see Set#equals(Object)
  52.      */
  53.     public int hashCode() {
  54.         int h = 0;
  55.         Iterator<E> i = iterator();
  56.         while (i.hasNext()) {
  57.             E obj = i.next();
  58.             if (obj != null)
  59.                 h += obj.hashCode();
  60.         }
  61.         return h;
  62.     }
  64.     /**
  65.      * 从当前集合中移除传入集合包含的所有元素
  66.      * @param  c collection containing elements to be removed from this set
  67.      * @return <tt>true</tt> if this set changed as a result of the call
  68.      * @see #remove(Object)
  69.      * @see #contains(Object)
  70.      */
  71.     public boolean removeAll(Collection<?> c) {
  72.         Objects.requireNonNull(c);
  73.         boolean modified = false;
  75.         // 如果当前集合元素比传入集合元素多
  76.         if (size() > c.size()) {
  78.             // 迭代传入集合并从当前集合移除
  79.             for (Iterator<?> i = c.iterator(); i.hasNext(); )
  80.                 modified |= remove(i.next());
  81.         } else {
  83.             // 迭代当前集合
  84.             for (Iterator<?> i = iterator(); i.hasNext(); ) {
  85.                 if (c.contains(i.next())) {
  86.                     i.remove();
  87.                     modified = true;
  88.                 }
  89.             }
  90.         }
  91.         return modified;
  92.     }
  94. }

简单使用

  1. public class SetCode {
  3.     public static void main(String[] args) {
  4.         commonExample();
  5.     }
  7.     public static void commonExample(){
  8.         Set<Integer> mySet  = new HashSet<>();
  9.         for(int i=0;i<20;i++){
  10.             mySet.add(i);
  11.         }
  12.         System.out.println("mySet = "+mySet);
  13.         System.out.println("mySet.size() = "+mySet.size());
  15.         Set<Integer> subSet  = new HashSet<>();
  16.         for(int i=0;i<10;i++){
  17.             subSet.add(i);
  18.         }
  19.         System.out.println("subSet = "+subSet);
  20.         System.out.println("mySet.containsAll(subSet) = "+mySet.containsAll(subSet));
  22.         mySet.removeAll(subSet);
  23.         System.out.println("mySet = "+mySet);
  24.     }
  25. }

输出:

mySet = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

mySet.size() = 20

subSet = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

mySet.containsAll(subSet) = true

mySet = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

总结

1、Set 继承自Collection接口，只是行为上不同，Set 不保存重复的元素。Set集合的实现类可说是基于Map集合去写的。通过内部封装Map集合来实现的比如HashSet内部封装了HashMap

2、Set 接口存储一组唯一，无序的对象。

3、Set插入无序，不可指定位置访问。

思考

Set和List的区别

    1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
    1. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
    1. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。