Set

集合论是数学的一个分支，钻研汇合、它们的运算和它们的性质。 汇合由不反复的项组成。根本符号运算符 并运算符，∪，示意“或”；交运算符，∩，示意“且”；差运算符，\，示意“不包含”；补运算符，'，示意补集;叉积运算符，×，示意笛卡尔积。限定词 冒号限定词，:，示意“使得”；隶属限定词，∈，示意“属于”；子集限定词，⊆，示意“是……的子集”;真子集限定词，⊂，示意“是……的真子集”。重要的汇合 ∅，空集，即不蕴含任何元素的汇合；ℕ，自然数集；ℤ，整数集；ℚ，有理数集；ℝ，实数集。对于以上汇合，有如下几点须要留神： 1. 空集是其自身的子集（并且也是任何其余汇合的子集），即使空集不蕴含任何项； 2. 数学家们对于零是否为自然数的认识通常并不对立，教科书个别会明确阐明作者是否认为零是自然数。 基数汇合的基数，或者说大小，由该汇合中的我的项目数量决定。基数运算符为 |...|。 例如，若 S = { 1, 2, 4 }，则 |S| = 3。 空集能够在汇合符号中应用不成立的条件来结构空集，例如，∅ = { x : x ≠ x }，或 ∅ = { x : x ∈ N, x < 0 }；空集总是惟一的（即，有且只有一个空集）；空集是所有汇合的子集；空集的基数为 0，即 |∅| = 0。汇合的示意汇合的逐项结构汇合能够通过蕴含其全副项的列表逐项生成。例如，S = { a, b, c, d }。 只有形成汇合的项分明，长列表能够用省略号缩短。例如，E = { 2, 4, 6, 8, ... } 显然为所有偶数形成的汇合，它蕴含无穷多项，尽管咱们只显式写出了其中四项。 汇合结构器汇合结构器符号是结构汇合的一种更具描述性的形式。它依赖于一个主语和一个谓词，使得 S = { 主语 : 谓词 }。 例如， A = { x : x 是元音字母 } = { a, e, i, o, u, y}B = { x : x ∈ N, x < 10 } = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }C = { x : x = 2k, k ∈ N } = { 0, 2, 4, 6, 8, ... }有时，谓词可能会 “漏 "到主语中，例如， ...

Set1：基本概念类数组对象, 内部元素唯一 let set = new Set([1, 2, 3, 2, 1]); console.log(set); // Set(3){ 1, 2, 3 } [...set]; // [1, 2, 3] 接收数组或迭代器对象 let set = new Set(document.getElementsByName('div')); set.size; // 0 let set = new Set([1, 2, 3, 2, 1]);不存在隐式转换 let set = new Set([5, '5']); set; // Set(2){ 5, '5' } let set = new Set([NaN, NaN]); set; // Set(1){ NaN } let set = new Set([{}, {}]); set; // Set(2){ {...}, {...} } let set = new Set('abcdabcd'); set; // Set(4){ 'a', 'b', 'c', 'd' }2：属性和方法size ， 返回当前Set元素总数 ...

介绍ConcurrentSkipListSet底层是通过ConcurrentNavigableMap来实现的，它是一个有序的线程安全的集合。 源码分析它的源码比较简单，跟通过Map实现的Set基本是一致，只是多了一些取最近的元素的方法。 // 实现了NavigableSet接口，并没有所谓的ConcurrentNavigableSet接口public class ConcurrentSkipListSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable { private static final long serialVersionUID = -2479143111061671589L; // 存储使用的map private final ConcurrentNavigableMap<E,Object> m; // 初始化 public ConcurrentSkipListSet() { m = new ConcurrentSkipListMap<E,Object>(); } // 传入比较器 public ConcurrentSkipListSet(Comparator<? super E> comparator) { m = new ConcurrentSkipListMap<E,Object>(comparator); } // 使用ConcurrentSkipListMap初始化map // 并将集合c中所有元素放入到map中 public ConcurrentSkipListSet(Collection<? extends E> c) { m = new ConcurrentSkipListMap<E,Object>(); addAll(c); } // 使用ConcurrentSkipListMap初始化map // 并将有序Set中所有元素放入到map中 public ConcurrentSkipListSet(SortedSet<E> s) { m = new ConcurrentSkipListMap<E,Object>(s.comparator()); addAll(s); } // ConcurrentSkipListSet类内部返回子set时使用的 ConcurrentSkipListSet(ConcurrentNavigableMap<E,Object> m) { this.m = m; } // 克隆方法 public ConcurrentSkipListSet<E> clone() { try { @SuppressWarnings("unchecked") ConcurrentSkipListSet<E> clone = (ConcurrentSkipListSet<E>) super.clone(); clone.setMap(new ConcurrentSkipListMap<E,Object>(m)); return clone; } catch (CloneNotSupportedException e) { throw new InternalError(); } } /* ---------------- Set operations -------------- */ // 返回元素个数 public int size() { return m.size(); } // 检查是否为空 public boolean isEmpty() { return m.isEmpty(); } // 检查是否包含某个元素 public boolean contains(Object o) { return m.containsKey(o); } // 添加一个元素 // 调用map的putIfAbsent()方法 public boolean add(E e) { return m.putIfAbsent(e, Boolean.TRUE) == null; } // 移除一个元素 public boolean remove(Object o) { return m.remove(o, Boolean.TRUE); } // 清空所有元素 public void clear() { m.clear(); } // 迭代器 public Iterator<E> iterator() { return m.navigableKeySet().iterator(); } // 降序迭代器 public Iterator<E> descendingIterator() { return m.descendingKeySet().iterator(); } /* ---------------- AbstractSet Overrides -------------- */ // 比较相等方法 public boolean equals(Object o) { // Override AbstractSet version to avoid calling size() if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; try { // 这里是通过两次两层for循环来比较 // 这里是有很大优化空间的，参考上篇文章CopyOnWriteArraySet中的彩蛋 return containsAll(c) && c.containsAll(this); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } // 移除集合c中所有元素 public boolean removeAll(Collection<?> c) { // Override AbstractSet version to avoid unnecessary call to size() boolean modified = false; for (Object e : c) if (remove(e)) modified = true; return modified; } /* ---------------- Relational operations -------------- */ // 小于e的最大元素 public E lower(E e) { return m.lowerKey(e); } // 小于等于e的最大元素 public E floor(E e) { return m.floorKey(e); } // 大于等于e的最小元素 public E ceiling(E e) { return m.ceilingKey(e); } // 大于e的最小元素 public E higher(E e) { return m.higherKey(e); } // 弹出最小的元素 public E pollFirst() { Map.Entry<E,Object> e = m.pollFirstEntry(); return (e == null) ? null : e.getKey(); } // 弹出最大的元素 public E pollLast() { Map.Entry<E,Object> e = m.pollLastEntry(); return (e == null) ? null : e.getKey(); } /* ---------------- SortedSet operations -------------- */ // 取比较器 public Comparator<? super E> comparator() { return m.comparator(); } // 最小的元素 public E first() { return m.firstKey(); } // 最大的元素 public E last() { return m.lastKey(); } // 取两个元素之间的子set public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) { return new ConcurrentSkipListSet<E> (m.subMap(fromElement, fromInclusive, toElement, toInclusive)); } // 取头子set public NavigableSet<E> headSet(E toElement, boolean inclusive) { return new ConcurrentSkipListSet<E>(m.headMap(toElement, inclusive)); } // 取尾子set public NavigableSet<E> tailSet(E fromElement, boolean inclusive) { return new ConcurrentSkipListSet<E>(m.tailMap(fromElement, inclusive)); } // 取子set，包含from，不包含to public NavigableSet<E> subSet(E fromElement, E toElement) { return subSet(fromElement, true, toElement, false); } // 取头子set，不包含to public NavigableSet<E> headSet(E toElement) { return headSet(toElement, false); } // 取尾子set，包含from public NavigableSet<E> tailSet(E fromElement) { return tailSet(fromElement, true); } // 降序set public NavigableSet<E> descendingSet() { return new ConcurrentSkipListSet<E>(m.descendingMap()); } // 可分割的迭代器 @SuppressWarnings("unchecked") public Spliterator<E> spliterator() { if (m instanceof ConcurrentSkipListMap) return ((ConcurrentSkipListMap<E,?>)m).keySpliterator(); else return (Spliterator<E>)((ConcurrentSkipListMap.SubMap<E,?>)m).keyIterator(); } // 原子更新map，给clone方法使用 private void setMap(ConcurrentNavigableMap<E,Object> map) { UNSAFE.putObjectVolatile(this, mapOffset, map); } // 原子操作相关内容 private static final sun.misc.Unsafe UNSAFE; private static final long mapOffset; static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); Class<?> k = ConcurrentSkipListSet.class; mapOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("m")); } catch (Exception e) { throw new Error(e); } }}可以看到，ConcurrentSkipListSet基本上都是使用ConcurrentSkipListMap实现的，虽然取子set部分是使用ConcurrentSkipListMap中的内部类，但是这些内部类其实也是和ConcurrentSkipListMap相关的，它们返回ConcurrentSkipListMap的一部分数据。 ...

介绍CopyOnWriteArraySet底层是使用CopyOnWriteArrayList存储元素的，所以它并不是使用Map来存储元素的。 但是，我们知道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()方法来保证元素不重复。 ...