[學習筆記-Java集合-12] Set - CopyOnWriteArraySet源碼分析

時間 2019-11-07

標籤學習筆記 java 集合 set copyonwritearrayset 源碼分析欄目 Java 简体版

原文原文鏈接

介紹

CopyOnWriteArraySet底層是使用CopyOnWriteArrayList存儲元素的，因此它並非使用Map來存儲元素的。java

可是，咱們知道CopyOnWriteArrayList底層實際上是一個數組，它是容許元素重複的，那麼用它來實現CopyOnWriteArraySet怎麼保證元素不重複呢？數組

源碼分析

Set類的源碼通常都比較短，因此咱們直接貼源碼上來一行一行分析吧。安全

public class CopyOnWriteArraySet<E> extends AbstractSet<E>
        implements java.io.Serializable {
    private static final long serialVersionUID = 5457747651344034263L;

    // 內部使用CopyOnWriteArrayList存儲元素
    private final CopyOnWriteArrayList<E> al;

    // 構造方法
    public CopyOnWriteArraySet() {
        al = new CopyOnWriteArrayList<E>();
    }

    // 將集合c中的元素初始化到CopyOnWriteArraySet中
    public CopyOnWriteArraySet(Collection<? extends E> c) {
        if (c.getClass() == CopyOnWriteArraySet.class) {
            // 若是c是CopyOnWriteArraySet類型，說明沒有重複元素，
            // 直接調用CopyOnWriteArrayList的構造方法初始化
            @SuppressWarnings("unchecked") CopyOnWriteArraySet<E> cc =
                (CopyOnWriteArraySet<E>)c;
            al = new CopyOnWriteArrayList<E>(cc.al);
        }
        else {
            // 若是c不是CopyOnWriteArraySet類型，說明有重複元素
            // 調用CopyOnWriteArrayList的addAllAbsent()方法初始化
            // 它會把重複元素排除掉
            al = new CopyOnWriteArrayList<E>();
            al.addAllAbsent(c);
        }
    }

    // 獲取元素個數
    public int size() {
        return al.size();
    }

    // 檢查集合是否爲空
    public boolean isEmpty() {
        return al.isEmpty();
    }

    // 檢查是否包含某個元素
    public boolean contains(Object o) {
        return al.contains(o);
    }

    // 集合轉數組
    public Object[] toArray() {
        return al.toArray();
    }

    // 集合轉數組，這裏是可能有bug的，詳情見ArrayList中分析
    public <T> T[] toArray(T[] a) {
        return al.toArray(a);
    }

    // 清空全部元素
    public void clear() {
        al.clear();
    }

    // 刪除元素
    public boolean remove(Object o) {
        return al.remove(o);
    }

    // 添加元素
    // 這裏是調用CopyOnWriteArrayList的addIfAbsent()方法
    // 它會檢測元素不存在的時候才添加
    // 還記得這個方法嗎？當時有分析過的，建議把CopyOnWriteArrayList拿出來再看看
    public boolean add(E e) {
        return al.addIfAbsent(e);
    }

    // 是否包含c中的全部元素
    public boolean containsAll(Collection<?> c) {
        return al.containsAll(c);
    }

    // 並集
    public boolean addAll(Collection<? extends E> c) {
        return al.addAllAbsent(c) > 0;
    }

    // 單方向差集
    public boolean removeAll(Collection<?> c) {
        return al.removeAll(c);
    }

    // 交集
    public boolean retainAll(Collection<?> c) {
        return al.retainAll(c);
    }

    // 迭代器
    public Iterator<E> iterator() {
        return al.iterator();
    }

    // equals()方法
    public boolean equals(Object o) {
        // 若是二者是同一個對象，返回true
        if (o == this)
            return true;
        // 若是o不是Set對象，返回false
        if (!(o instanceof Set))
            return false;
        Set<?> set = (Set<?>)(o);
        Iterator<?> it = set.iterator();

        // 集合元素數組的快照
        Object[] elements = al.getArray();
        int len = elements.length;

        // 我以爲這裏的設計不太好
        // 首先，Set中的元素原本就是不重複的，因此不須要再用個matched[]數組記錄有沒有出現過
        // 其次，兩個集合的元素個數若是不相等，那確定不相等了，這個是否是應該做爲第一要素先檢查
        boolean[] matched = new boolean[len];
        int k = 0;
        // 從o這個集合開始遍歷
        outer: while (it.hasNext()) {
            // 若是k>len了，說明o中元素多了
            if (++k > len)
                return false;
            // 取值
            Object x = it.next();
            // 遍歷檢查是否在當前集合中
            for (int i = 0; i < len; ++i) {
                if (!matched[i] && eq(x, elements[i])) {
                    matched[i] = true;
                    continue outer;
                }
            }
            // 若是不在當前集合中，返回false
            return false;
        }
        return k == len;
    }

    // 移除知足過濾條件的元素
    public boolean removeIf(Predicate<? super E> filter) {
        return al.removeIf(filter);
    }

    // 遍歷元素
    public void forEach(Consumer<? super E> action) {
        al.forEach(action);
    }

    // 分割的迭代器
    public Spliterator<E> spliterator() {
        return Spliterators.spliterator
            (al.getArray(), Spliterator.IMMUTABLE | Spliterator.DISTINCT);
    }

    // 比較兩個元素是否相等
    private static boolean eq(Object o1, Object o2) {
        return (o1 == null) ? o2 == null : o1.equals(o2);
    }
}

能夠看到，在添加元素時調用了CopyOnWriteArrayList的addIfAbsent()方法來保證元素不重複。併發

總結

（1）CopyOnWriteArraySet是用CopyOnWriteArrayList實現的；源碼分析

（2）CopyOnWriteArraySet是有序的，由於底層實際上是數組，數組是有序的this

（3）CopyOnWriteArraySet是併發安全的，並且實現了讀寫分離；設計

（4）CopyOnWriteArraySet經過調用CopyOnWriteArrayList的addIfAbsent()方法來保證元素不重複；code

如何比較兩個Set中的元素是否徹底相等

假設有兩個Set，一個是A，一個是B。對象

最簡單的方式就是判斷是否A中的元素都在B中，B中的元素是否都在A中，也就是兩次兩層循環。element

其實，並不須要。

由於Set中的元素並不重複，因此只要先比較兩個Set的元素個數是否相等，再做一次兩層循環就能夠了，須要仔細體味。代碼以下：

public class CopyOnWriteArraySetTest {

    public static void main(String[] args) {
        Set<Integer> set1 = new CopyOnWriteArraySet<>();
        set1.add(1);
        set1.add(5);
        set1.add(2);
        set1.add(7);
//        set1.add(3);
        set1.add(4);

        Set<Integer> set2 = new HashSet<>();
        set2.add(1);
        set2.add(5);
        set2.add(2);
        set2.add(7);
        set2.add(3);

        System.out.println(eq(set1, set2));

        System.out.println(eq(set2, set1));
    }

    private static <T> boolean eq(Set<T> set1, Set<T> set2) {
        if (set1.size() != set2.size()) {
            return false;
        }

        for (T t : set1) {
            // contains至關於一層for循環
            if (!set2.contains(t)) {
                return false;
            }
        }

        return true;
    }
}

（2）那麼，如何比較兩個List中的元素是否徹底相等呢？

咱們知道，List中元素是能夠重複的，一次也能夠搞定，設定一個標記數組，標記某個位置的元素是否找到過，請仔細體味。

public class ListEqTest {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(3);
        list1.add(6);
        list1.add(3);
        list1.add(8);
        list1.add(5);

        List<Integer> list2 = new ArrayList<>();
        list2.add(3);
        list2.add(1);
        list2.add(3);
        list2.add(8);
        list2.add(5);
        list2.add(6);

        System.out.println(eq(list1, list2));
        System.out.println(eq(list2, list1));
    }

    private static <T> boolean eq(List<T> list1, List<T> list2) {
        if (list1.size() != list2.size()) {
            return false;
        }

        // 標記某個元素是否找到過，防止重複
        boolean matched[] = new boolean[list2.size()];

        outer: for (T t : list1) {
            for (int i = 0; i < list2.size(); i++) {
                // i這個位置沒找到過才比較大小
                if (!matched[i] && list2.get(i).equals(t)) {
                    matched[i] = true;
                    continue outer;
                }
            }
            return false;
        }

        return true;
    }
}