Module java.base
Package java.util.concurrent

Class 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>, SequencedCollection<E>, SequencedSet<E>, Set<E>, SortedSet<E>
public class ConcurrentSkipListSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, Serializable
基于ConcurrentSkipListMap的可伸缩并发NavigableSet实现。集合的元素根据它们的自然顺序或在创建集合时提供的Comparator（取决于使用哪个构造函数）进行排序。

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

迭代器和分割器是弱一致性的。

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

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

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

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

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

自版本:
1.6
另请参阅:

  • Constructor Summary

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

  • Method Summary

    Modifier and Type
    Method
    Description
    boolean
    add(E e)
    如果此集合中尚未存在指定元素，则将其添加到此集合。
    void
    addFirst(E e)
    抛出UnsupportedOperationException。
    void
    addLast(E e)
    抛出UnsupportedOperationException。
    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为true，则为小于或等于）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为true，则为大于或等于）fromElement的部分视图。

    Methods declared in class java.util.AbstractSet

    hashCode

    Methods declared in class java.util.AbstractCollection

    addAll, containsAll, retainAll, toArray, toArray, toString

    Methods declared in class java.lang.Object

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

    Methods declared in interface java.util.Collection

    parallelStream, removeIf, stream, toArray

    Methods declared in interface java.lang.Iterable

    forEach

    Methods declared in interface java.util.NavigableSet

    removeFirst, removeLast, reversed

    Methods declared in interface java.util.Set

    addAll, containsAll, hashCode, retainAll, toArray, toArray

    Methods declared in interface java.util.SortedSet

    getFirst, getLast

  • Constructor Details

    • ConcurrentSkipListSet

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

    • ConcurrentSkipListSet

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

    • ConcurrentSkipListSet

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

    • ConcurrentSkipListSet

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

  • Method Details

    • clone

      public ConcurrentSkipListSet<E> clone()
      返回此ConcurrentSkipListSet实例的浅拷贝。（元素本身不会被克隆。）
      覆盖:
      clone 在类 Object
      返回:
      此集合的浅拷贝
      另请参阅:

    • size

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

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

      指定者:
      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 - 如果指定元素为null

    • 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 - 如果指定元素为null

    • remove

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

    • 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>中
      返回:
      返回一个按升序排列的此集合中元素的迭代器

    • descendingIterator

      public Iterator<E> descendingIterator()
      返回一个按降序排列的此集合中元素的迭代器。
      指定者:
      descendingIterator 在接口 NavigableSet<E>中
      返回:
      返回一个按降序排列的此集合中元素的迭代器

    • equals

      public boolean equals(Object o)
      将指定对象与此集合进行比较以检查是否相等。如果指定对象也是一个集合，两个集合具有相同的大小，并且指定集合的每个成员都包含在此集合中（或者等效地，此集合的每个成员都包含在指定集合中），则返回true。此定义确保equals方法在集合接口的不同实现之间正常工作。
      指定由：
      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 - 如果此集合的元素的类与指定集合不兼容（可选）
      NullPointerException - 如果指定集合或其任何元素为null
      参见：

    • lower

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

    • floor

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

    • ceiling

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

    • higher

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

    • 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 - 如果此集合为空

    • addFirst

      public void addFirst(E e)
      抛出UnsupportedOperationException。由此集合的比较方法引起的遭遇顺序决定了元素的位置，因此不支持显式定位。
      指定由：
      addFirst 在接口 SequencedCollection<E>
      指定由：
      addFirst 在接口 SortedSet<E>
      参数：
      e - 要添加的元素
      抛出：
      UnsupportedOperationException - 总是
      自：
      21

    • addLast

      public void addLast(E e)
      抛出UnsupportedOperationException。由此集合的比较方法引起的遭遇顺序决定了元素的位置，因此不支持显式定位。
      指定由：
      addLast 在接口 SequencedCollection<E>
      指定由：
      addLast 在接口 SortedSet<E>
      参数：
      e - 要添加的元素。
      抛出：
      UnsupportedOperationException - 总是
      自：
      21

    • subSet

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

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

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

    • headSet

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

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

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

    • tailSet

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

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

      指定由：
      tailSet 在接口 NavigableSet<E>
      参数：
      fromElement - 返回集合的低端点
      inclusive - 如果要在返回视图中包含低端点，则为true
      返回：
      返回此集合中元素大于或等于fromElement的视图
      抛出：
      ClassCastException - 如果fromElement与此集合的比较器不兼容（或者如果集合没有比较器，则如果fromElement未实现Comparable）。如果fromElement无法与当前集合中的元素进行比较，实现可能会但不是必须抛出此异常。
      NullPointerException - 如果fromElement为null
      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为null
      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为null
      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为null
      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，遇到顺序为升序。重写实现应记录其他特征值的报告。

      spliterator的比较器如果集合的比较器为null，则为null。否则，spliterator的比较器与集合的比较器相同或施加相同的总排序。

      指定者：
      spliterator 在接口 Collection<E>
      指定者：
      spliterator 在接口 Iterable<E>
      指定者：
      spliterator 在接口 Set<E>
      指定者：
      spliterator 在接口 SortedSet<E>
      返回：
      包含此集合中元素的Spliterator
      自1.8起