```
public final class Spliterators
extends Object
```
用于操作或创建Spliterator及其原始特化 Spliterator.OfInt,Spliterator.OfLong和Spliterator.OfDouble的实例的静态类和方法。

从以下版本开始：

1.8

另请参见：

Spliterator

嵌套类汇总

嵌套类
变量和类型	类	描述
`static class`	`Spliterators.AbstractDoubleSpliterator`	实现 `trySplit`的抽象 `Spliterator.OfDouble`允许有限的并行性。
`static class`	`Spliterators.AbstractIntSpliterator`	实现 `trySplit`的摘要 `Spliterator.OfInt`允许有限的并行性。
`static class`	`Spliterators.AbstractLongSpliterator`	摘要 `Spliterator.OfLong` ，实现 `trySplit`以允许有限的并行性。
`static class`	`Spliterators.AbstractSpliterator<T>`	实现 `trySplit`的抽象 `Spliterator`允许有限的并行性。

方法摘要

所有方法静态方法具体的方法
变量和类型	方法	描述
`static Spliterator.OfDouble`	`emptyDoubleSpliterator()`	创建一个空 `Spliterator.OfDouble`
`static Spliterator.OfInt`	`emptyIntSpliterator()`	创建一个空 `Spliterator.OfInt`
`static Spliterator.OfLong`	`emptyLongSpliterator()`	创建一个空 `Spliterator.OfLong`
`static <T> Spliterator<T>`	`emptySpliterator()`	创建一个空 `Spliterator`
`static PrimitiveIterator.OfDouble`	`iterator(Spliterator.OfDouble spliterator)`	创建一个 `PrimitiveIterator.OfDouble`从 `Spliterator.OfDouble` 。
`static PrimitiveIterator.OfInt`	`iterator(Spliterator.OfInt spliterator)`	创建一个 `PrimitiveIterator.OfInt`从 `Spliterator.OfInt` 。
`static PrimitiveIterator.OfLong`	`iterator(Spliterator.OfLong spliterator)`	创建一个 `PrimitiveIterator.OfLong`从 `Spliterator.OfLong` 。
`static <T> Iterator<T>`	`iterator(Spliterator<? extends T> spliterator)`	创建一个 `Iterator`从 `Spliterator` 。
`static Spliterator.OfDouble`	`spliterator(double[] array, int additionalCharacteristics)`	创建 `Spliterator.OfDouble`覆盖给定的阵列的元件，使用一组定制的spliterator特性。
`static Spliterator.OfDouble`	`spliterator(double[] array, int fromIndex, int toIndex, int additionalCharacteristics)`	创建 `Spliterator.OfDouble`覆盖范围的给定阵列的元件的，使用一组定制的spliterator特性。
`static Spliterator.OfInt`	`spliterator(int[] array, int additionalCharacteristics)`	创建 `Spliterator.OfInt`覆盖给定的阵列的元件，使用一组定制的spliterator特性。
`static Spliterator.OfInt`	`spliterator(int[] array, int fromIndex, int toIndex, int additionalCharacteristics)`	创建 `Spliterator.OfInt`覆盖范围的给定阵列的元件的，使用一组定制的spliterator特性。
`static Spliterator.OfLong`	`spliterator(long[] array, int additionalCharacteristics)`	创建 `Spliterator.OfLong`覆盖给定的阵列的元件，使用一组定制的spliterator特性。
`static Spliterator.OfLong`	`spliterator(long[] array, int fromIndex, int toIndex, int additionalCharacteristics)`	创建 `Spliterator.OfLong`覆盖范围的给定阵列的元件的，使用一组定制的spliterator特性。
`static <T> Spliterator<T>`	`spliterator(Object[] array, int additionalCharacteristics)`	创建 `Spliterator`覆盖给定的阵列的元件，使用一组定制的spliterator特性。
`static <T> Spliterator<T>`	`spliterator(Object[] array, int fromIndex, int toIndex, int additionalCharacteristics)`	创建 `Spliterator`覆盖范围的给定阵列的元件的，使用一组定制的spliterator特性。
`static <T> Spliterator<T>`	`spliterator(Collection<? extends T> c, int characteristics)`	使用给定集合的 `Collection.iterator()`作为元素源创建 `Spliterator` ，并将其 `Collection.size()`报告为其初始大小。
`static <T> Spliterator<T>`	`spliterator(Iterator<? extends T> iterator, long size, int characteristics)`	使用给定的 `Iterator`作为元素源创建 `Spliterator` ，并使用给定的初始报告大小。
`static Spliterator.OfDouble`	`spliterator(PrimitiveIterator.OfDouble iterator, long size, int characteristics)`	使用给定的 `DoubleStream.DoubleIterator`作为元素源创建 `Spliterator.OfDouble` ，并使用给定的初始报告大小。
`static Spliterator.OfInt`	`spliterator(PrimitiveIterator.OfInt iterator, long size, int characteristics)`	使用给定的 `IntStream.IntIterator`作为元素源创建 `Spliterator.OfInt` ，并使用给定的初始报告大小。
`static Spliterator.OfLong`	`spliterator(PrimitiveIterator.OfLong iterator, long size, int characteristics)`	使用给定的 `LongStream.LongIterator`作为元素源创建 `Spliterator.OfLong` ，并使用给定的初始报告大小。
`static <T> Spliterator<T>`	`spliteratorUnknownSize(Iterator<? extends T> iterator, int characteristics)`	使用给定的 `Iterator`作为元素源创建 `Spliterator` ，没有初始大小估计。
`static Spliterator.OfDouble`	`spliteratorUnknownSize(PrimitiveIterator.OfDouble iterator, int characteristics)`	使用给定的 `DoubleStream.DoubleIterator`作为元素源创建 `Spliterator.OfDouble` ，没有初始大小估计。
`static Spliterator.OfInt`	`spliteratorUnknownSize(PrimitiveIterator.OfInt iterator, int characteristics)`	使用给定的 `IntStream.IntIterator`作为元素源创建 `Spliterator.OfInt` ，没有初始大小估计。
`static Spliterator.OfLong`	`spliteratorUnknownSize(PrimitiveIterator.OfLong iterator, int characteristics)`	使用给定的 `LongStream.LongIterator`作为元素源创建 `Spliterator.OfLong` ，没有初始大小估计。

声明方法的类 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 方法详细信息
  - emptySpliterator
```
public static <T> Spliterator<T> emptySpliterator()
```
    创建一个空Spliterator
    空的分裂器报告Spliterator.SIZED和Spliterator.SUBSIZED 。致电Spliterator.trySplit()始终返回null 。
    
    参数类型
    
    T - 元素类型
    
    结果
    
    一个空的分裂者
  - emptyIntSpliterator
```
public static Spliterator.OfInt emptyIntSpliterator()
```
    创建一个空Spliterator.OfInt
    空的分裂器报告Spliterator.SIZED和Spliterator.SUBSIZED 。致电Spliterator.trySplit()始终返回null 。
    
    结果
    
    一个空的分裂者
  - emptyLongSpliterator
```
public static Spliterator.OfLong emptyLongSpliterator()
```
    创建一个空Spliterator.OfLong
    空的分裂器报告Spliterator.SIZED和Spliterator.SUBSIZED 。致电Spliterator.trySplit()始终返回null 。
    
    结果
    
    一个空的分裂者
  - emptyDoubleSpliterator
```
public static Spliterator.OfDouble emptyDoubleSpliterator()
```
    创建一个空Spliterator.OfDouble
    空的分裂器报告Spliterator.SIZED和Spliterator.SUBSIZED 。致电Spliterator.trySplit()的电话总是返回null 。
    
    结果
    
    一个空的分裂者
  - spliterator
```
public static <T> Spliterator<T> spliterator(Object[] array,
                                             int additionalCharacteristics)
```
    创建Spliterator覆盖给定的阵列的元件，使用一组定制的spliterator特性。
    提供此方法作为Spliterators的实现方便，Spliterators将其元素的部分存储在数组中，并且需要对Spliterator特性进行精细控制。需要使用阵列的Spliterator的大多数其他情况应使用Arrays.spliterator(Object[]) 。
    
    返回的分裂器始终报告特征SIZED和SUBSIZED 。呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLE和ORDERED 。
    
    参数类型
    
    T - 元素类型
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    additionalCharacteristics - 此分裂器源或元件的其他分裂器特性超出 SIZED和 SUBSIZED ，这些特性始终报告
    
    结果
    
    数组的分裂器
    
    异常
    
    NullPointerException - 如果给定的数组是 null
    
    另请参见：
    
    Arrays.spliterator(Object[])
  - spliterator
```
public static <T> Spliterator<T> spliterator(Object[] array,
                                             int fromIndex,
                                             int toIndex,
                                             int additionalCharacteristics)
```
    创建Spliterator覆盖范围的给定阵列的元件的，使用一组定制的spliterator特性。
    提供此方法作为Spliterators的实现方便，Spliterators将其元素的部分存储在数组中，并且需要对Spliterator特性进行精细控制。需要使用阵列的Spliterator的大多数其他情况应使用Arrays.spliterator(Object[]) 。
    
    返回的分裂器始终报告特征SIZED和SUBSIZED 。呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLE和ORDERED 。
    
    参数类型
    
    T - 元素类型
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    fromIndex - 要覆盖的最小索引（包括）
    
    toIndex - 过去最大的指数之一
    
    additionalCharacteristics - 此分裂器源或元件的其他分裂器特性超出 SIZED和 SUBSIZED ，这些特性始终报告
    
    结果
    
    数组的分裂器
    
    异常
    
    NullPointerException - 如果给定的数组是 null
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex为负数，则 toIndex小于 fromIndex ，或者 toIndex大于数组大小
    
    另请参见：
    
    Arrays.spliterator(Object[], int, int)
  - spliterator
```
public static Spliterator.OfInt spliterator(int[] array,
                                            int additionalCharacteristics)
```
    创建Spliterator.OfInt覆盖给定的阵列的元件，使用一组定制的spliterator特性。
    提供此方法作为Spliterators的实现方便，Spliterators将其元素的部分存储在数组中，并且需要对Spliterator特性进行精细控制。需要使用阵列的Spliterator的大多数其他情况应使用Arrays.spliterator(int[]) 。
    
    返回的spliterator始终报告特征SIZED和SUBSIZED 。呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLE和ORDERED 。
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    additionalCharacteristics - 此分裂器源或元件的额外分裂器特性超出 SIZED和 SUBSIZED ，总是报告
    
    结果
    
    数组的分裂器
    
    异常
    
    NullPointerException - 如果给定的数组是 null
    
    另请参见：
    
    Arrays.spliterator(int[])
  - spliterator
```
public static Spliterator.OfInt spliterator(int[] array,
                                            int fromIndex,
                                            int toIndex,
                                            int additionalCharacteristics)
```
    创建Spliterator.OfInt覆盖范围的给定阵列的元件的，使用一组定制的spliterator特性。
    提供此方法作为Spliterators的实现方便，Spliterators将其元素的部分存储在数组中，并且需要对Spliterator特性进行精细控制。需要使用阵列的Spliterator的大多数其他情况应使用Arrays.spliterator(int[], int, int) 。
    
    返回的分裂器始终报告特征SIZED和SUBSIZED 。呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLE和ORDERED 。
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    fromIndex - 要覆盖的最小索引（包括）
    
    toIndex - 覆盖范围最大的指数之一
    
    additionalCharacteristics - 此分裂器的源或超出 SIZED和 SUBSIZED元素的附加分裂器特征始终报告
    
    结果
    
    数组的分裂器
    
    异常
    
    NullPointerException - 如果给定的数组是 null
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex为负数，则 toIndex小于 fromIndex ，或者 toIndex大于数组大小
    
    另请参见：
    
    Arrays.spliterator(int[], int, int)
  - spliterator
```
public static Spliterator.OfLong spliterator(long[] array,
                                             int additionalCharacteristics)
```
    创建Spliterator.OfLong覆盖给定的阵列的元件，使用一组定制的spliterator特性。
    提供此方法作为Spliterators的实现方便，Spliterators将其元素的部分存储在数组中，并且需要对Spliterator特性进行精细控制。需要使用阵列的Spliterator的大多数其他情况应使用Arrays.spliterator(long[]) 。
    
    返回的分裂器始终报告特征SIZED和SUBSIZED 。呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLE和ORDERED 。
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    additionalCharacteristics - 此分裂器源或超出 SIZED和 SUBSIZED元素的附加分裂器特性总是报告
    
    结果
    
    数组的分裂器
    
    异常
    
    NullPointerException - 如果给定的数组是 null
    
    另请参见：
    
    Arrays.spliterator(long[])
  - spliterator
```
public static Spliterator.OfLong spliterator(long[] array,
                                             int fromIndex,
                                             int toIndex,
                                             int additionalCharacteristics)
```
    创建Spliterator.OfLong覆盖范围的给定阵列的元件的，使用一组定制的spliterator特性。
    提供此方法作为Spliterators的实现方便，Spliterators将其元素的部分存储在数组中，并且需要对Spliterator特性进行精细控制。需要使用阵列的Spliterator的大多数其他情况应使用Arrays.spliterator(long[], int, int) 。
    
    返回的分裂器始终报告特征SIZED和SUBSIZED 。呼叫者可以为分裂者报告提供额外的特征。（例如，如果已知数组将不再进一步修改，请指定IMMUTABLE ;如果数组数据被视为具有遭遇顺序，请指定ORDERED ）。该方法Arrays.spliterator(long[], int, int)通常可以替代地使用，这将返回一个报告spliterator SIZED ， SUBSIZED ， IMMUTABLE ，和ORDERED 。
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    fromIndex - 要覆盖的最小索引（包括）
    
    toIndex - 覆盖范围最大的指数之一
    
    additionalCharacteristics - 此分裂器源或超出 SIZED和 SUBSIZED元素的附加分裂器特征总是报告
    
    结果
    
    数组的分裂器
    
    异常
    
    NullPointerException - 如果给定的数组是 null
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex为负数，则 toIndex小于 fromIndex ，或者 toIndex大于数组大小
    
    另请参见：
    
    Arrays.spliterator(long[], int, int)
  - spliterator
```
public static Spliterator.OfDouble spliterator(double[] array,
                                               int additionalCharacteristics)
```
    创建Spliterator.OfDouble覆盖给定的阵列的元件，使用一组定制的spliterator特性。
    提供此方法作为Spliterators的实现方便，Spliterators将其元素的部分存储在数组中，并且需要对Spliterator特性进行精细控制。需要使用阵列的Spliterator的大多数其他情况应使用Arrays.spliterator(double[]) 。
    
    返回的分裂器始终报告特征SIZED和SUBSIZED 。呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLE和ORDERED 。
    
    参数
    
    array - 数组，假设在使用期间未经修改
    
    additionalCharacteristics - 此分裂器源或超出 SIZED和 SUBSIZED元素的其他分裂器特性总是报告
    
    结果
    
    数组的分裂器
    
    异常
    
    NullPointerException - 如果给定的数组是 null
    
    另请参见：
    
    Arrays.spliterator(double[])
  - spliterator
```
public static Spliterator.OfDouble spliterator(double[] array,
                                               int fromIndex,
                                               int toIndex,
                                               int additionalCharacteristics)
```
    创建Spliterator.OfDouble覆盖范围的给定阵列的元件的，使用一组定制的spliterator特性。
    提供此方法作为Spliterators的实现方便，Spliterators将其元素的部分存储在数组中，并且需要对Spliterator特性进行精细控制。需要使用阵列的Spliterator的大多数其他情况应使用Arrays.spliterator(double[], int, int) 。
    
    返回的分裂器始终报告特征SIZED和SUBSIZED 。呼叫者可以为分裂者报告提供额外的特征。（例如，如果已知数组将不会被进一步修改，请指定IMMUTABLE ;如果数组数据被视为具有遭遇顺序，请指定ORDERED ）。该方法Arrays.spliterator(long[], int, int)通常可以替代地使用，这将返回一个报告spliterator SIZED ， SUBSIZED ， IMMUTABLE ，和ORDERED 。
    
    参数
    
    array - 假定在使用期间未修改的数组
    
    fromIndex - 要覆盖的最小索引（包括）
    
    toIndex - 覆盖范围最大的指数之一
    
    additionalCharacteristics - 此分裂器源或超出 SIZED和 SUBSIZED元素的附加分裂器特性总是报告
    
    结果
    
    数组的分裂器
    
    异常
    
    NullPointerException - 如果给定的数组是 null
    
    ArrayIndexOutOfBoundsException - 如果 fromIndex为负数，则 toIndex小于 fromIndex ，或者 toIndex大于数组大小
    
    另请参见：
    
    Arrays.spliterator(double[], int, int)
  - spliterator
```
public static <T> Spliterator<T> spliterator(Collection<? extends T> c,
                                             int characteristics)
```
    使用给定集合的Collection.iterator()作为元素源创建Spliterator ，并将其Collection.size()报告为其初始大小。
    spliterator是late-binding ，继承了集合迭代器的fail-fast属性，并实现了trySplit以允许有限的并行性。
    
    参数类型
    
    T - 元素类型
    
    参数
    
    c - 该系列
    
    characteristics - 此分裂器的源或元素的特征。特性SIZED和SUBSIZED被额外报告除非CONCURRENT被供给。
    
    结果
    
    来自迭代器的分裂器
    
    异常
    
    NullPointerException - 如果给定集合是 null
  - spliterator
```
public static <T> Spliterator<T> spliterator(Iterator<? extends T> iterator,
                                             long size,
                                             int characteristics)
```
    使用给定的Iterator作为元素源创建Spliterator ，并使用给定的初始报告大小。
    spliterator不是late-binding ，继承了迭代器的fail-fast属性，并实现了trySplit以允许有限的并行性。
    
    元素的遍历应该通过分裂器来完成。如果在返回spliterator之后操作迭代器，或者最初报告的大小不等于源中元素的实际数量，则拆分和遍历的行为是不确定的。
    
    参数类型
    
    T - 元素类型
    
    参数
    
    iterator - 源的迭代器
    
    size - 源中的元素数，将报告为初始值 estimateSize
    
    characteristics - 此分裂器的源或元素的特征。特性SIZED和SUBSIZED被额外报告除非CONCURRENT被供给。
    
    结果
    
    来自迭代器的分裂器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliteratorUnknownSize
```
public static <T> Spliterator<T> spliteratorUnknownSize(Iterator<? extends T> iterator,
                                                        int characteristics)
```
    使用给定的Iterator作为元素源创建Spliterator ，没有初始大小估计。
    spliterator不是late-binding ，它继承了迭代器的fail-fast属性，并实现了trySplit以允许有限的并行性。
    
    元素的遍历应该通过分裂器来完成。如果在返回spliterator后操作迭代器，则拆分和遍历的行为是不确定的。
    
    参数类型
    
    T - 元素类型
    
    参数
    
    iterator - 源的迭代器
    
    characteristics - 此spliterator的源或元素的特征（ SIZED和 SUBSIZED ，如果提供，将被忽略，不会报告。）
    
    结果
    
    来自迭代器的分裂器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliterator
```
public static Spliterator.OfInt spliterator(PrimitiveIterator.OfInt iterator,
                                            long size,
                                            int characteristics)
```
    使用给定的IntStream.IntIterator作为元素源创建Spliterator.OfInt ，并使用给定的初始报告大小。
    spliterator不是late-binding ，它继承了迭代器的fail-fast属性，并实现了trySplit以允许有限的并行性。
    
    元素的遍历应该通过分裂器来完成。如果在返回spliterator之后操作迭代器，或者最初报告的大小不等于源中元素的实际数量，则拆分和遍历的行为是不确定的。
    
    参数
    
    iterator - 源的迭代器
    
    size - 源中的元素数，将报告为初始值 estimateSize 。
    
    characteristics - 此分裂器的源或元素的特征。特性SIZED和SUBSIZED被额外报告除非CONCURRENT被供给。
    
    结果
    
    来自迭代器的分裂器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliteratorUnknownSize
```
public static Spliterator.OfInt spliteratorUnknownSize(PrimitiveIterator.OfInt iterator,
                                                       int characteristics)
```
    使用给定的IntStream.IntIterator作为元素源创建Spliterator.OfInt ，没有初始大小估计。
    spliterator不是late-binding ，它继承了迭代器的fail-fast属性，并实现了trySplit以允许有限的并行性。
    
    元素的遍历应该通过分裂器来完成。如果在返回spliterator后操作迭代器，则拆分和遍历的行为是不确定的。
    
    参数
    
    iterator - 源的迭代器
    
    characteristics - 此spliterator的源或元素的特征（ SIZED和 SUBSIZED ，如果提供，将被忽略，不会报告。）
    
    结果
    
    来自迭代器的分裂器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliterator
```
public static Spliterator.OfLong spliterator(PrimitiveIterator.OfLong iterator,
                                             long size,
                                             int characteristics)
```
    使用给定的LongStream.LongIterator作为元素源创建Spliterator.OfLong ，并使用给定的初始报告大小。
    spliterator不是late-binding ，继承了迭代器的fail-fast属性，并实现了trySplit以允许有限的并行性。
    
    元素的遍历应该通过分裂器来完成。如果在返回spliterator之后操作迭代器，或者最初报告的大小不等于源中元素的实际数量，则拆分和遍历的行为是不确定的。
    
    参数
    
    iterator - 源的迭代器
    
    size - 源中的元素数，将报告为初始值 estimateSize 。
    
    characteristics - 此分裂器的源或元素的特征。特性SIZED和SUBSIZED被额外报告除非CONCURRENT被供给。
    
    结果
    
    来自迭代器的分裂器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliteratorUnknownSize
```
public static Spliterator.OfLong spliteratorUnknownSize(PrimitiveIterator.OfLong iterator,
                                                        int characteristics)
```
    使用给定的LongStream.LongIterator作为元素源创建Spliterator.OfLong ，没有初始大小估计。
    spliterator不是late-binding ，继承了迭代器的fail-fast属性，并实现了trySplit以允许有限的并行性。
    
    元素的遍历应该通过分裂器来完成。如果在返回spliterator后操作迭代器，则拆分和遍历的行为是不确定的。
    
    参数
    
    iterator - 源的迭代器
    
    characteristics - 此spliterator的源或元素的特征（ SIZED和 SUBSIZED ，如果提供，将被忽略，不会报告。）
    
    结果
    
    来自迭代器的分裂器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliterator
```
public static Spliterator.OfDouble spliterator(PrimitiveIterator.OfDouble iterator,
                                               long size,
                                               int characteristics)
```
    使用给定的DoubleStream.DoubleIterator作为元素源创建Spliterator.OfDouble ，并使用给定的初始报告大小。
    spliterator不是late-binding ，它继承了迭代器的fail-fast属性，并实现了trySplit以允许有限的并行性。
    
    元素的遍历应该通过分裂器来完成。如果在返回spliterator之后操作迭代器，或者最初报告的大小不等于源中元素的实际数量，则拆分和遍历的行为是不确定的。
    
    参数
    
    iterator - 源的迭代器
    
    size - 源中的元素数，将报告为初始值 estimateSize
    
    characteristics - 此分裂器的源或元素的特征。特性SIZED和SUBSIZED被额外报告除非CONCURRENT被供给。
    
    结果
    
    来自迭代器的分裂器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliteratorUnknownSize
```
public static Spliterator.OfDouble spliteratorUnknownSize(PrimitiveIterator.OfDouble iterator,
                                                          int characteristics)
```
    使用给定的DoubleStream.DoubleIterator作为元素源创建Spliterator.OfDouble ，没有初始大小估计。
    spliterator不是late-binding ，继承迭代器的fail-fast属性，并实现trySplit以允许有限的并行性。
    
    元素的遍历应该通过分裂器来完成。如果在返回spliterator后操作迭代器，则拆分和遍历的行为是不确定的。
    
    参数
    
    iterator - 源的迭代器
    
    characteristics - 此spliterator的源或元素的特征（ SIZED和 SUBSIZED ，如果提供，将被忽略，不会报告。）
    
    结果
    
    来自迭代器的分裂器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - iterator
```
public static <T> Iterator<T> iterator(Spliterator<? extends T> spliterator)
```
    创建一个Iterator从Spliterator 。
    元素的遍历应该通过迭代器完成。如果在返回迭代器后操作spliterator，则遍历的行为是不确定的。
    
    参数类型
    
    T - 元素类型
    
    参数
    
    spliterator - 分裂者
    
    结果
    
    迭代器
    
    异常
    
    NullPointerException - 如果给定的分裂器是 null
  - iterator
```
public static PrimitiveIterator.OfInt iterator(Spliterator.OfInt spliterator)
```
    创建一个PrimitiveIterator.OfInt从Spliterator.OfInt 。
    元素的遍历应该通过迭代器完成。如果在返回迭代器后操作spliterator，则遍历的行为是不确定的。
    
    参数
    
    spliterator - 分裂者
    
    结果
    
    迭代器
    
    异常
    
    NullPointerException - 如果给定的分裂器是 null
  - iterator
```
public static PrimitiveIterator.OfLong iterator(Spliterator.OfLong spliterator)
```
    创建一个PrimitiveIterator.OfLong从Spliterator.OfLong 。
    元素的遍历应该通过迭代器完成。如果在返回迭代器后操作spliterator，则遍历的行为是不确定的。
    
    参数
    
    spliterator - 分裂者
    
    结果
    
    迭代器
    
    异常
    
    NullPointerException - 如果给定的分裂器是 null
  - iterator
```
public static PrimitiveIterator.OfDouble iterator(Spliterator.OfDouble spliterator)
```
    创建一个PrimitiveIterator.OfDouble从Spliterator.OfDouble 。
    元素的遍历应该通过迭代器完成。如果在返回迭代器后操作spliterator，则遍历的行为是不确定的。
    
    参数
    
    spliterator - 分裂者
    
    结果
    
    迭代器
    
    异常
    
    NullPointerException - 如果给定的分裂器是 null

Class Spliterators

嵌套类汇总

方法摘要

声明方法的类 java.lang.Object

方法详细信息

emptySpliterator

emptyIntSpliterator

emptyLongSpliterator

emptyDoubleSpliterator

spliterator

spliterator

spliterator

spliterator

spliterator

spliterator

spliterator

spliterator

spliterator

spliterator

spliteratorUnknownSize

spliterator

spliteratorUnknownSize

spliterator

spliteratorUnknownSize

spliterator

spliteratorUnknownSize

iterator

iterator

iterator

iterator