模块 java.base
包 java.util.concurrent

类 ConcurrentSkipListSet<E>

java.lang.Object
java.util.AbstractCollection <E>
java.util.AbstractSet <E>
java.util.concurrent.ConcurrentSkipListSet<E>
类型参数：
E - 此集合维护的元素类型
所有已实现的接口：
Serializable , Cloneable , Iterable<E> , Collection<E> , NavigableSet<E> , Set<E> , SortedSet<E>
public class ConcurrentSkipListSet<E> extends AbstractSet <E> implements NavigableSet <E>, Cloneable , Serializable
基于 ConcurrentSkipListMap 的可扩展并发 NavigableSet 实现。集合的元素根据它们的 自然排序 或集合创建时提供的 Comparator 进行排序，具体取决于使用的构造函数。

此实现提供了预期的平均值log(n)contains、add 和 remove 操作及其变体的时间成本。插入、删除和访问操作由多个线程安全地并发执行。

迭代器和拆分器是 弱一致 。

升序视图及其迭代器比降序视图更快。

请注意，与大多数集合不同，size 方法是 not 恒定时间操作。由于这些集合的异步特性，确定当前元素数量需要遍历元素，因此如果在遍历期间修改此集合，则可能会报告不准确的结果。

添加、删除或检查多个元素的批量操作，例如 AbstractCollection.addAll(java.util.Collection<? extends E>) 、Collection.removeIf(java.util.function.Predicate<? super E>) 或 Iterable.forEach(java.util.function.Consumer<? super T>) ，not 保证以原子方式执行。例如，与 addAll 操作并发的 forEach 遍历可能只会观察到一些添加的元素。

此类及其迭代器实现了 Set 和 Iterator 接口的所有 optional 方法。与大多数其他并发集合实现一样，此类不允许使用 null 元素，因为无法可靠地区分 null 参数和返回值与元素的缺失。

此类是 Java 集合框架 的成员。

自从：
1.6
参见：

  • 构造方法总结

    构造方法
    构造方法
    描述
    ConcurrentSkipListSet()
    构造一个新的空集，根据元素的 自然排序 对其元素进行排序。
    ConcurrentSkipListSet(Collection<? extends E> c)
    构造一个新集合，其中包含指定集合中的元素，并根据元素的 自然排序 对其元素进行排序。
    ConcurrentSkipListSet(Comparator<? super E> comparator)
    构造一个新的空集，该集根据指定的比较器对其元素进行排序。
    ConcurrentSkipListSet(SortedSet<E> s)
    构造一个包含相同元素并使用与指定排序集相同顺序的新集。

  • 方法总结

    修饰符和类型
    方法
    描述
    boolean
    add(E e)
    如果指定的元素不存在，则将其添加到此集合中。
    E
    ceiling(E e)
    返回此集合中大于或等于给定元素的最小元素，如果没有这样的元素，则返回 null。
    void
    clear()
    从此集合中删除所有元素。
    ConcurrentSkipListSet<E>
    clone()
    返回此 ConcurrentSkipListSet 实例的浅表副本。
    Comparator<? super E>
    comparator()
    返回用于对该集合中的元素进行排序的比较器，如果该集合使用其元素的 自然排序，则返回 null。
    boolean
    contains(Object o)
    如果此集合包含指定元素，则返回 true。
    Iterator<E>
    descendingIterator()
    按降序返回此集合中元素的迭代器。
    NavigableSet<E>
    descendingSet()
    返回此集合中包含的元素的倒序视图。
    boolean
    equals(Object o)
    比较指定对象与此集合是否相等。
    E
    first()
    返回此集合中当前的第一个（最低）元素。
    E
    floor(E e)
    返回此集合中小于或等于给定元素的最大元素，如果没有这样的元素，则返回 null。
    NavigableSet<E>
    headSet(E toElement)
    返回此集合中元素严格小于 toElement 的部分的视图。
    NavigableSet<E>
    headSet(E toElement, boolean inclusive)
    返回此集合的部分视图，其元素小于（或等于，如果 inclusive 为真） toElement 。
    E
    higher(E e)
    返回此集合中严格大于给定元素的最小元素，如果没有这样的元素，则返回 null。
    boolean
    isEmpty()
    如果此集合不包含任何元素，则返回 true。
    Iterator<E>
    iterator()
    按升序返回此集合中元素的迭代器。
    E
    last()
    返回此集合中当前的最后一个（最高）元素。
    E
    lower(E e)
    返回此集合中严格小于给定元素的最大元素，如果没有这样的元素，则返回 null。
    E
    pollFirst()
    检索并删除第一个（最低）元素，如果此集合为空，则返回 null。
    E
    pollLast()
    检索并删除最后一个（最高）元素，如果此集合为空，则返回 null。
    boolean
    remove(Object o)
    如果存在，则从此集合中移除指定元素。
    boolean
    removeAll(Collection<?> c)
    从此集合中移除指定集合中包含的所有元素。
    int
    size()
    返回此集合中的元素数。
    Spliterator<E>
    spliterator()
    返回此集合中元素的 Spliterator 。
    NavigableSet<E>
    subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
    返回此集合的部分视图，其元素范围从 fromElement 到 toElement 。
    NavigableSet<E>
    subSet(E fromElement, E toElement)
    返回此集合的部分视图，其元素范围从 fromElement（含）到 toElement（不含）。
    NavigableSet<E>
    tailSet(E fromElement)
    返回此集合中元素大于或等于 fromElement 的部分的视图。
    NavigableSet<E>
    tailSet(E fromElement, boolean inclusive)
    返回此集合的部分视图，其元素大于（或等于，如果 inclusive 为真） fromElement 。

    在类 java.util.AbstractSet 中声明的方法

    hashCode

    在类 java.util.AbstractCollection 中声明的方法

    addAll, containsAll, retainAll, toArray, toArray, toString

    在类 java.lang.Object 中声明的方法

    finalize, getClass, notify, notifyAll, wait, wait, wait

    在接口 java.util.Collection 中声明的方法

    parallelStream, removeIf, stream, toArray

    在接口 java.lang.Iterable 中声明的方法

    forEach

    在接口 java.util.Set 中声明的方法

    addAll, containsAll, hashCode, retainAll, toArray, toArray

  • 构造方法详细信息

    • ConcurrentSkipListSet

      public ConcurrentSkipListSet()
      构造一个新的空集，根据元素的 自然排序 对其元素进行排序。

    • ConcurrentSkipListSet

      public ConcurrentSkipListSet(Comparator <? super E > comparator)
      构造一个新的空集，该集根据指定的比较器对其元素进行排序。
      参数：
      comparator - 将用于订购此集合的比较器。如果 null ，将使用元素的 自然排序。

    • ConcurrentSkipListSet

      public ConcurrentSkipListSet(Collection <? extends E > c)
      构造一个新集合，其中包含指定集合中的元素，并根据元素的 自然排序 对其元素进行排序。
      参数：
      c - 将构成新集合的元素
      抛出：
      ClassCastException - 如果 c 中的元素不是 Comparable ，或者不可相互比较
      NullPointerException - 如果指定的集合或其任何元素为空

    • ConcurrentSkipListSet

      public ConcurrentSkipListSet(SortedSet <E > s)
      构造一个包含相同元素并使用与指定排序集相同顺序的新集。
      参数：
      s - 其元素将组成新集合的有序集合
      抛出：
      NullPointerException - 如果指定的排序集或其任何元素为空

  • 方法详情

    • clone

      public ConcurrentSkipListSet <E > clone()
      返回此 ConcurrentSkipListSet 实例的浅表副本。 （元素本身不会被克隆。）
      重写：
      clone 在类 Object 中
      返回：
      这个集合的浅拷贝
      参见：

    • size

      public int size()
      返回此集合中的元素数。如果此集合包含超过 Integer.MAX_VALUE 个元素，则返回 Integer.MAX_VALUE 。

      请注意，与大多数集合不同，此方法是 NOT 恒定时间操作。由于这些集合的异步性质，确定当前元素的数量需要遍历它们来计算它们。另外，在该方法执行过程中，size可能会发生变化，返回的结果会不准确。因此，这种方法在并发应用程序中通常不是很有用。

      指定者：
      size 在接口 Collection<E> 中
      指定者：
      size 在接口 Set<E> 中
      返回：
      该集合中的元素数

    • isEmpty

      public boolean isEmpty()
      如果此集合不包含任何元素，则返回 true。
      指定者：
      isEmpty 在接口 Collection<E> 中
      指定者：
      isEmpty 在接口 Set<E> 中
      重写：
      isEmpty 在类 AbstractCollection<E> 中
      返回：
      true 如果这个集合不包含任何元素

    • contains

      public boolean contains(Object  o)
      如果此集合包含指定元素，则返回 true。更正式地说，当且仅当此集合包含满足 o.equals(e) 的元素 e 时，返回 true。
      指定者：
      contains 在接口 Collection<E> 中
      指定者：
      contains 在接口 Set<E> 中
      重写：
      contains 在类 AbstractCollection<E> 中
      参数：
      o - 要检查此集合中包含的对象
      返回：
      true 如果此集合包含指定元素
      抛出：
      ClassCastException - 如果无法将指定元素与当前集合中的元素进行比较
      NullPointerException - 如果指定元素为空

    • add

      public boolean add(E  e)
      如果指定的元素不存在，则将其添加到此集合中。更正式地说，如果集合不包含满足 e.equals(e2) 的元素 e2，则将指定元素 e 添加到该集合。如果此集合已包含该元素，则调用保持集合不变并返回 false 。
      指定者：
      add 在接口 Collection<E> 中
      指定者：
      add 在接口 Set<E> 中
      重写：
      add 在类 AbstractCollection<E> 中
      参数：
      e - 要添加到此集合的元素
      返回：
      true 如果此集合尚未包含指定元素
      抛出：
      ClassCastException - 如果无法将 e 与该集合中当前的元素进行比较
      NullPointerException - 如果指定元素为空

    • remove

      public boolean remove(Object  o)
      如果存在，则从此集合中移除指定元素。更正式地说，删除一个元素 e 这样 o.equals(e) ，如果这个集合包含这样一个元素。如果此集合包含该元素，则返回 true（或者等效地，如果此集合因调用而更改）。 （一旦调用返回，此集合将不包含该元素。）
      指定者：
      remove 在接口 Collection<E> 中
      指定者：
      remove 在接口 Set<E> 中
      重写：
      remove 在类 AbstractCollection<E> 中
      参数：
      o - 要从此集合中删除的对象（如果存在）
      返回：
      true 如果这个集合包含指定的元素
      抛出：
      ClassCastException - 如果无法将 o 与该集合中的当前元素进行比较
      NullPointerException - 如果指定元素为空

    • clear

      public void clear()
      从此集合中删除所有元素。
      指定者：
      clear 在接口 Collection<E> 中
      指定者：
      clear 在接口 Set<E> 中
      重写：
      clear 在类 AbstractCollection<E> 中

    • iterator

      public Iterator <E > iterator()
      按升序返回此集合中元素的迭代器。
      指定者：
      iterator 在接口 Collection<E> 中
      指定者：
      iterator 在接口 Iterable<E> 中
      指定者：
      iterator 在接口 NavigableSet<E> 中
      指定者：
      iterator 在接口 Set<E> 中
      指定者：
      iterator 在类 AbstractCollection<E> 中
      返回：
      按升序迭代此 set 中的元素的迭代器

    • descendingIterator

      public Iterator <E > descendingIterator()
      按降序返回此集合中元素的迭代器。
      指定者：
      descendingIterator 在接口 NavigableSet<E> 中
      返回：
      按降序对该集合中的元素进行迭代

    • equals

      public boolean equals(Object  o)
      比较指定对象与此集合是否相等。如果指定对象也是一个集合，则返回 true，这两个集合具有相同的大小，并且指定集合的每个成员都包含在这个集合中（或者等效地，这个集合的每个成员都包含在指定集合中）。此定义确保 equals 方法在 set 接口的不同实现中正常工作。
      指定者：
      equals 在接口 Collection<E> 中
      指定者：
      equals 在接口 Set<E> 中
      重写：
      equals 在类 AbstractSet<E> 中
      参数：
      o - 要与此集合进行比较的对象
      返回：
      true如果指定的对象等于这个集合
      参见：

    • removeAll

      public boolean removeAll(Collection <?> c)
      从此集合中移除指定集合中包含的所有元素。如果指定的集合也是一个集合，则此操作有效地修改了这个集合，使其值为不对称集差两组中的。
      指定者：
      removeAll 在接口 Collection<E> 中
      指定者：
      removeAll 在接口 Set<E> 中
      重写：
      removeAll 在类 AbstractSet<E> 中
      参数：
      c - 包含要从此集合中删除的元素的集合
      返回：
      true 如果此集合因调用而更改
      抛出：
      ClassCastException - 如果此集合的元素类与指定集合不兼容 (optional)
      NullPointerException - 如果指定的集合或其任何元素为空
      参见：

    • lower

      public E  lower(E  e)
      从接口 NavigableSet 复制的描述
      返回此集合中严格小于给定元素的最大元素，如果没有这样的元素，则返回 null。
      指定者：
      lower 在接口 NavigableSet<E> 中
      参数：
      e - 要匹配的值
      返回：
      小于 e 的最大元素，或者 null 如果没有这样的元素
      抛出：
      ClassCastException - 如果无法将指定元素与当前集合中的元素进行比较
      NullPointerException - 如果指定元素为空

    • floor

      public E  floor(E  e)
      从接口 NavigableSet 复制的描述
      返回此集合中小于或等于给定元素的最大元素，如果没有这样的元素，则返回 null。
      指定者：
      floor 在接口 NavigableSet<E> 中
      参数：
      e - 要匹配的值
      返回：
      小于或等于 e 的最大元素，如果没有这样的元素，则为 null
      抛出：
      ClassCastException - 如果无法将指定元素与当前集合中的元素进行比较
      NullPointerException - 如果指定元素为空

    • ceiling

      public E  ceiling(E  e)
      从接口 NavigableSet 复制的描述
      返回此集合中大于或等于给定元素的最小元素，如果没有这样的元素，则返回 null。
      指定者：
      ceiling 在接口 NavigableSet<E> 中
      参数：
      e - 要匹配的值
      返回：
      大于或等于 e 的最小元素，如果没有这样的元素，则为 null
      抛出：
      ClassCastException - 如果无法将指定元素与当前集合中的元素进行比较
      NullPointerException - 如果指定元素为空

    • higher

      public E  higher(E  e)
      从接口 NavigableSet 复制的描述
      返回此集合中严格大于给定元素的最小元素，如果没有这样的元素，则返回 null。
      指定者：
      higher 在接口 NavigableSet<E> 中
      参数：
      e - 要匹配的值
      返回：
      大于 e 的最小元素，如果没有这样的元素，则为 null
      抛出：
      ClassCastException - 如果无法将指定元素与当前集合中的元素进行比较
      NullPointerException - 如果指定元素为空

    • pollFirst

      public E  pollFirst()
      从接口 NavigableSet 复制的描述
      检索并删除第一个（最低）元素，如果此集合为空，则返回 null。
      指定者：
      pollFirst 在接口 NavigableSet<E> 中
      返回：
      第一个元素，或 null 如果此集合为空

    • pollLast

      public E  pollLast()
      从接口 NavigableSet 复制的描述
      检索并删除最后一个（最高）元素，如果此集合为空，则返回 null。
      指定者：
      pollLast 在接口 NavigableSet<E> 中
      返回：
      最后一个元素，或 null 如果此集合为空

    • comparator

      public Comparator <? super E > comparator()
      从接口 SortedSet 复制的描述
      返回用于对该集合中的元素进行排序的比较器，如果该集合使用其元素的 自然排序，则返回 null。
      指定者：
      comparator 在接口 SortedSet<E> 中
      返回：
      用于对该集合中的元素进行排序的比较器，或者 null 如果该集合使用其元素的自然排序

    • first

      public E  first()
      从接口 SortedSet 复制的描述
      返回此集合中当前的第一个（最低）元素。
      指定者：
      first 在接口 SortedSet<E> 中
      返回：
      此集合中当前的第一个（最低）元素
      抛出：
      NoSuchElementException - 如果这个集合是空的

    • last

      public E  last()
      从接口 SortedSet 复制的描述
      返回此集合中当前的最后一个（最高）元素。
      指定者：
      last 在接口 SortedSet<E> 中
      返回：
      该集合中当前的最后一个（最高）元素
      抛出：
      NoSuchElementException - 如果这个集合是空的

    • subSet

      public NavigableSet <E > subSet(E  fromElement, boolean fromInclusive, E  toElement, boolean toInclusive)
      从接口 NavigableSet 复制的描述
      返回此集合的部分视图，其元素范围从 fromElement 到 toElement 。如果 fromElement 和 toElement 相等，则返回的集合为空，除非 fromInclusive 和 toInclusive 都为真。返回的集合受此集合的支持，因此返回集合中的更改会反映在此集合中，反之亦然。返回的集合支持该集合支持的所有可选集合操作。

      返回的集合将在尝试插入其范围之外的元素时抛出 IllegalArgumentException。

      指定者：
      subSet 在接口 NavigableSet<E> 中
      参数：
      fromElement - 返回集的低端点
      fromInclusive - true 如果低端点要包含在返回的视图中
      toElement - 返回集的高端点
      toInclusive - true 如果高端点要包含在返回的视图中
      返回：
      该集合的部分视图，其元素范围从 fromElement（含）到 toElement（不含）
      抛出：
      ClassCastException - 如果 fromElement 和 toElement 无法使用该集合的比较器相互比较（或者，如果该集合没有比较器，则使用自然排序）。如果无法将 fromElement 或 toElement 与当前集合中的元素进行比较，实现可能会（但不是必须）抛出此异常。
      NullPointerException - 如果 fromElement 或 toElement 为空
      IllegalArgumentException - 如果 fromElement 大于 toElement ；或者如果这个集合本身有一个限制范围，并且 fromElement 或 toElement 位于范围的边界之外。

    • headSet

      public NavigableSet <E > headSet(E  toElement, boolean inclusive)
      从接口 NavigableSet 复制的描述
      返回此集合的部分视图，其元素小于（或等于，如果 inclusive 为真） toElement 。返回的集合受此集合的支持，因此返回集合中的更改会反映在此集合中，反之亦然。返回的集合支持该集合支持的所有可选集合操作。

      返回的集合将在尝试插入其范围之外的元素时抛出 IllegalArgumentException。

      指定者：
      headSet 在接口 NavigableSet<E> 中
      参数：
      toElement - 返回集的高端点
      inclusive - true 如果高端点要包含在返回的视图中
      返回：
      该集合的部分视图，其元素小于（或等于，如果inclusive为真）toElement
      抛出：
      ClassCastException - 如果 toElement 与该集合的比较器不兼容（或者，如果该集合没有比较器，如果 toElement 没有实现 Comparable ）。如果无法将 toElement 与集合中的当前元素进行比较，则实现可能会（但不是必须）抛出此异常。
      NullPointerException - 如果 toElement 为空
      IllegalArgumentException - 如果这个集合本身有一个限制范围，并且 toElement 位于范围的边界之外

    • tailSet

      public NavigableSet <E > tailSet(E  fromElement, boolean inclusive)
      从接口 NavigableSet 复制的描述
      返回此集合的部分视图，其元素大于（或等于，如果 inclusive 为真） fromElement 。返回的集合受此集合的支持，因此返回集合中的更改会反映在此集合中，反之亦然。返回的集合支持该集合支持的所有可选集合操作。

      返回的集合将在尝试插入其范围之外的元素时抛出 IllegalArgumentException。

      指定者：
      tailSet 在接口 NavigableSet<E> 中
      参数：
      fromElement - 返回集的低端点
      inclusive - true 如果低端点要包含在返回的视图中
      返回：
      该集合的元素大于或等于 fromElement 的部分的视图
      抛出：
      ClassCastException - 如果 fromElement 与该集合的比较器不兼容（或者，如果该集合没有比较器，如果 fromElement 未实现 Comparable ）。如果 fromElement 无法与集合中当前的元素进行比较，实现可能会（但不是必须）抛出此异常。
      NullPointerException - 如果 fromElement 为空
      IllegalArgumentException - 如果这个集合本身有一个限制范围，并且 fromElement 位于范围的边界之外

    • subSet

      public NavigableSet <E > subSet(E  fromElement, E  toElement)
      从接口 NavigableSet 复制的描述
      返回此集合的部分视图，其元素范围从 fromElement（含）到 toElement（不含）。 （如果 fromElement 和 toElement 相等，则返回的集合为空。）返回的集合受此集合的支持，因此返回集合中的更改会反映在此集合中，反之亦然。返回的集合支持该集合支持的所有可选集合操作。

      返回的集合将在尝试插入其范围之外的元素时抛出 IllegalArgumentException。

      相当于 subSet(fromElement, true, toElement, false) 。

      指定者：
      subSet 在接口 NavigableSet<E> 中
      指定者：
      subSet 在接口 SortedSet<E> 中
      参数：
      fromElement - 返回集的低端点（含）
      toElement - 返回集的高端点（不包括）
      返回：
      该集合的部分视图，其元素范围从 fromElement（含）到 toElement（不含）
      抛出：
      ClassCastException - 如果 fromElement 和 toElement 无法使用该集合的比较器相互比较（或者，如果该集合没有比较器，则使用自然排序）。如果无法将 fromElement 或 toElement 与当前集合中的元素进行比较，实现可能会（但不是必须）抛出此异常。
      NullPointerException - 如果 fromElement 或 toElement 为空
      IllegalArgumentException - 如果 fromElement 大于 toElement ；或者如果这个集合本身有一个限制范围，并且 fromElement 或 toElement 位于范围的边界之外

    • headSet

      public NavigableSet <E > headSet(E  toElement)
      从接口 NavigableSet 复制的描述
      返回此集合中元素严格小于 toElement 的部分的视图。返回的集合受此集合的支持，因此返回集合中的更改会反映在此集合中，反之亦然。返回的集合支持该集合支持的所有可选集合操作。

      返回的集合将在尝试插入其范围之外的元素时抛出 IllegalArgumentException。

      相当于 headSet(toElement, false) 。

      指定者：
      headSet 在接口 NavigableSet<E> 中
      指定者：
      headSet 在接口 SortedSet<E> 中
      参数：
      toElement - 返回集的高端点（不包括）
      返回：
      该集合中元素严格小于 toElement 的部分的视图
      抛出：
      ClassCastException - 如果 toElement 与该集合的比较器不兼容（或者，如果该集合没有比较器，如果 toElement 没有实现 Comparable ）。如果无法将 toElement 与集合中的当前元素进行比较，则实现可能会（但不是必须）抛出此异常。
      NullPointerException - 如果 toElement 为空
      IllegalArgumentException - 如果这个集合本身有一个限制范围，并且 toElement 位于范围的边界之外

    • tailSet

      public NavigableSet <E > tailSet(E  fromElement)
      从接口 NavigableSet 复制的描述
      返回此集合中元素大于或等于 fromElement 的部分的视图。返回的集合受此集合的支持，因此返回集合中的更改会反映在此集合中，反之亦然。返回的集合支持该集合支持的所有可选集合操作。

      返回的集合将在尝试插入其范围之外的元素时抛出 IllegalArgumentException。

      相当于 tailSet(fromElement, true) 。

      指定者：
      tailSet 在接口 NavigableSet<E> 中
      指定者：
      tailSet 在接口 SortedSet<E> 中
      参数：
      fromElement - 返回集的低端点（含）
      返回：
      该集合的元素大于或等于 fromElement 的部分的视图
      抛出：
      ClassCastException - 如果 fromElement 与该集合的比较器不兼容（或者，如果该集合没有比较器，如果 fromElement 未实现 Comparable ）。如果 fromElement 无法与集合中当前的元素进行比较，实现可能会（但不是必须）抛出此异常。
      NullPointerException - 如果 fromElement 为空
      IllegalArgumentException - 如果这个集合本身有一个限制范围，并且 fromElement 位于范围的边界之外

    • descendingSet

      public NavigableSet <E > descendingSet()
      返回此集合中包含的元素的倒序视图。降序集由该集支持，因此对该集的更改会反映在降序集中，反之亦然。

      返回的集合的排序等同于 Collections.reverseOrder (comparator()) 。表达式 s.descendingSet().descendingSet() 返回 s 的视图，本质上等同于 s 。

      指定者：
      descendingSet 在接口 NavigableSet<E> 中
      返回：
      该集合的逆序视图

    • spliterator

      public Spliterator <E > spliterator()
      返回此集合中元素的 Spliterator 。

      Spliterator 报告 Spliterator.CONCURRENT 、Spliterator.NONNULL 、Spliterator.DISTINCT 、Spliterator.SORTED 和 Spliterator.ORDERED ，遇到顺序为升序。覆盖实施应记录附加特征值的报告。

      如果 集合的比较器 是 null，则 分离器的比较器 是 null。否则，拆分器的比较器与集合的比较器相同或强加相同的总排序。

      指定者：
      spliterator 在接口 Collection<E> 中
      指定者：
      spliterator 在接口 Iterable<E> 中
      指定者：
      spliterator 在接口 Set<E> 中
      指定者：
      spliterator 在接口 SortedSet<E> 中
      返回：
      a Spliterator 覆盖此集合中的元素
      自从：
      1.8