java集合----Set

csdn
个人博客

一.前言

今天面试，上来第一个问题就是关于 Set 集合,因为之前做的准备都是什么 HashMap 啊, List 之类的，但是对于 Set 集合没有做过多的了解，所以一时语塞。看来基础是不能挑着学的，全部掌握才不怕。

二.Set 接口

1.简介

以下内容引用自 源码中的注释

Set 集合是一个不包含重复元素的集合。更确切地讲，set 不包含满足对于两个存在Set 中对象 e1 和 e2， e1.equals(e2) 的元素，并且最多包含一个 null 元素。

注：如果将可变对象用作 set 元素，那么必须极其小心。如果对象是 set 中某个元素，如果以一种影响 equals 比较的方式改变对象的值，那么 set 的行为就是不确定的。此项禁止的一个特殊情况是不允许某个 set 包含其自身作为元素。

总的来说：就是 Set 集合中存储的元素是不能存在重复的，且存储在 Set 集合中的元素如果一个可变的对象，则对对象的操作就千万不能使这个对象的 equals 方法发生变化，否则就会使 Set 集合处于未知的状态，因为 Set 集合保证对象唯一的条件的是通过 equals 方法来判断的。

2.Set 接口

public interface Set<E> extends Collection<E> {
    //返回 Set 集合元素的数量，最多为 Integer.MAX_VALUE
    int size();

    //判断是否包含元素
    boolean isEmpty();

    //判断 Set 集合是否包含一个指定的元素 o,
    //更确切地讲，是判断 Set 是否存在一个元素 o1
    //使得 o1.equals(o) 返回 true.
    boolean contains(Object o);

    //返回一个 Set 集合的迭代器，具体元素的顺序交给子类去实现。
    Iterator<E> iterator();

    //以数组的形式返回集合中的元素，顺序和上面的 iterator 一样。
    Object[] toArray();

    //返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。
    <T> T[] toArray(T[] a);


   //添加一个不重复的元素，更确切地讲是添加一个元素，并保证集合中的
   //任意一个元素 o 都不会使 o.equals(e) 返回 true.
    boolean add(E e);

    // 移除以一个元素
    boolean remove(Object o);

    //判断Set 是否包含了 集合 c 的所有元素
    boolean containsAll(Collection<?> c);

    //向Set  添加集合 c  中的元素
    boolean addAll(Collection<? extends E> c);

    //删除所有没有在集合 c 中的元素
    boolean retainAll(Collection<?> c);

    //删除所有在集合 c 的元素
    boolean removeAll(Collection<?> c);

    //清除所有元素
    void clear();


    //Set 集合自己的equals/hashCode 方法。
    boolean equals(Object o);

   
    int hashCode();

   
   //创建一个可以分割的迭代器
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.DISTINCT);
    }

     //返回一个不可变的 Set 集合
     //下面几个方法都是，参数为集合中固定的元素。
    static <E> Set<E> of() {
        return ImmutableCollections.Set0.instance();
    }

  
    static <E> Set<E> of(E e1) {
        return new ImmutableCollections.Set1<>(e1);
    }

  
    static <E> Set<E> of(E e1, E e2) {
        return new ImmutableCollections.Set2<>(e1, e2);
    }

    
    static <E> Set<E> of(E e1, E e2, E e3) {
        return new ImmutableCollections.SetN<>(e1, e2, e3);
    }

    
    static <E> Set<E> of(E e1, E e2, E e3, E e4) {
        return new ImmutableCollections.SetN<>(e1, e2, e3, e4);
    }

   
    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5) {
        return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5);
    }

  
    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
        return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5,
                                               e6);
    }

  
    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
        return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5,
                                               e6, e7);
    }

   
    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
        return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5,
                                               e6, e7, e8);
    }

    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
        return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5,
                                               e6, e7, e8, e9);
    }

 
    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
        return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5,
                                               e6, e7, e8, e9, e10);
    }

    @SafeVarargs
    @SuppressWarnings("varargs")
    static <E> Set<E> of(E... elements) {
        switch (elements.length) { // implicit null check of elements
            case 0:
                return ImmutableCollections.Set0.instance();
            case 1:
                return new ImmutableCollections.Set1<>(elements[0]);
            case 2:
                return new ImmutableCollections.Set2<>(elements[0], elements[1]);
            default:
                return new ImmutableCollections.SetN<>(elements);
        }
    }

    //复制一个 Set 集合，返回的是一个不可变得Set 集合
    @SuppressWarnings("unchecked")
    static <E> Set<E> copyOf(Collection<? extends E> coll) {
        if (coll instanceof ImmutableCollections.AbstractImmutableSet) {
            return (Set<E>)coll;
        } else {
            return (Set<E>)Set.of(new HashSet<>(coll).toArray());
        }
    }
}