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

从以下版本开始：

1.8

另请参见：

Spliterator

Nested Class Summary

Nested Classes
Modifier and Type	Class	描述
`static class`	`Spliterators.AbstractDoubleSpliterator`	一个抽象的 `Spliterator.OfDouble`实现 `trySplit`以允许有限的并行性。
`static class`	`Spliterators.AbstractIntSpliterator`	摘要 `Spliterator.OfInt`实现了 `trySplit`以允许有限的并行性。
`static class`	`Spliterators.AbstractLongSpliterator`	摘要 `Spliterator.OfLong`实现了 `trySplit`以允许有限的并行性。
`static class`	`Spliterators.AbstractSpliterator<T>`	一个抽象的 `Spliterator`实现 `trySplit`以允许有限的并行性。

方法摘要

所有方法静态方法具体的方法
Modifier and Type	方法	描述
`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` ，使用一组自定义的拼接器特性来覆盖给定阵列的元素。
`static Spliterator.OfDouble`	`spliterator(double[] array, int fromIndex, int toIndex, int additionalCharacteristics)`	创建一个 `Spliterator.OfDouble`涵盖给定数组的一系列元素，使用一组自定义的拼接器特性。
`static Spliterator.OfInt`	`spliterator(int[] array, int additionalCharacteristics)`	创建一个 `Spliterator.OfInt`覆盖给定阵列的元素，使用一组自定义的拼接器特征。
`static Spliterator.OfInt`	`spliterator(int[] array, int fromIndex, int toIndex, int additionalCharacteristics)`	创建一个 `Spliterator.OfInt`涵盖给定阵列的一系列元素，使用一组自定义的拼接器特性。
`static Spliterator.OfLong`	`spliterator(long[] array, int additionalCharacteristics)`	创建一个 `Spliterator.OfLong` ，使用自定义的一组拼接器特征来覆盖给定数组的元素。
`static Spliterator.OfLong`	`spliterator(long[] array, int fromIndex, int toIndex, int additionalCharacteristics)`	创建一个 `Spliterator.OfLong`涵盖了一组给定阵列的元素，使用了一组自定义的拼接器特性。
`static <T> Spliterator<T>`	`spliterator(Object[] array, int additionalCharacteristics)`	创建一个 `Spliterator`覆盖给定数组的元素，使用一组自定义的拼接器特征。
`static <T> Spliterator<T>`	`spliterator(Object[] array, int fromIndex, int toIndex, int additionalCharacteristics)`	创建一个 `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)`	创建一个 `Spliterator.OfDouble`使用给定的 `DoubleStream.DoubleIterator`作为元素的来源，并给出最初报告的大小。
`static Spliterator.OfInt`	`spliterator(PrimitiveIterator.OfInt iterator, long size, int characteristics)`	创建一个 `Spliterator.OfInt`使用给定的 `IntStream.IntIterator`作为元素的来源，并给出最初报告的大小。
`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)`	创建一个 `Spliterator.OfDouble`使用给定的 `DoubleStream.DoubleIterator`作为元素的来源，没有初始大小估计。
`static Spliterator.OfInt`	`spliteratorUnknownSize(PrimitiveIterator.OfInt iterator, int characteristics)`	创建一个 `Spliterator.OfInt`使用给定的 `IntStream.IntIterator`作为元素的来源，没有初始大小估计。
`static Spliterator.OfLong`	`spliteratorUnknownSize(PrimitiveIterator.OfLong iterator, int characteristics)`	使用给定的 `LongStream.LongIterator`作为元素的来源创建一个 `Spliterator.OfLong` ，没有初始大小估计。

Methods inherited from class 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特性的精细控制。大多数其他情况下，需要使用数组的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特性的精细控制。大多数其他情况下，需要使用数组的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特性的精细控制。大多数其他情况下，需要使用数组的Spliterator才能使用Arrays.spliterator(int[]) 。
    
    返回的分配器总是报告特征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特性的精细控制。大多数其他情况下，需要使用数组的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特性的精细控制。大多数其他情况下，需要使用数组的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特性的精细控制。大多数其他情况下，需要使用数组的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特性的精细控制。大多数其他情况下，需要使用数组的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特性的精细控制。大多数其他情况下，需要使用数组的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()作为其初始大小。
    拼接器是late-binding ，继承了集合的迭代器的故障快速属性，并实现了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 ，并使用给定的最初报告的大小。
    拼接器不是late-binding ，它继承了迭代器的故障快速属性，并实现了trySplit以允许有限的并行性。
    
    元素穿越应通过拼接器完成。如果迭代器在分割器返回后操作，或初始报告的大小不等于源中实际的元素数量，则分割和遍历的行为是未定义的。
    
    参数类型
    
    T - 元素的类型
    
    参数
    
    iterator - 源的迭代器
    
    size - 源中元素的数量，以初始值 estimateSize报告
    
    characteristics - 此拼接器的源或元素的特征。特性SIZED和SUBSIZED额外报告除非CONCURRENT供给。
    
    结果
    
    来自迭代器的拼接器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliteratorUnknownSize
```
public static <T> Spliterator<T> spliteratorUnknownSize(Iterator<? extends T> iterator,
                                                        int characteristics)
```
    创建Spliterator使用给定的Iterator作为元素的来源，没有初始大小估计。
    拼接器不是late-binding ，它继承了迭代器的故障快速属性，并实现了trySplit以允许有限的并行性。
    
    元素穿越应通过拼接器完成。如果在返回Spliter之后迭代器被操作，则分割和遍历的行为是未定义的。
    
    参数类型
    
    T - 元素的类型
    
    参数
    
    iterator - 源的迭代器
    
    characteristics - 此拼接器的源或元素的特征（ SIZED和 SUBSIZED （如果提供）将被忽略且不会报告。）
    
    结果
    
    来自迭代器的拼接器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliterator
```
public static Spliterator.OfInt spliterator(PrimitiveIterator.OfInt iterator,
                                            long size,
                                            int characteristics)
```
    使用给定的IntStream.IntIterator作为元素的来源，并以给定的最初报告的大小创建一个Spliterator.OfInt 。
    拼接器不是late-binding ，它继承了迭代器的故障快速属性，并实现了trySplit以允许有限的并行性。
    
    元素穿越应通过拼接器完成。如果迭代器在分割器返回后操作，或初始报告的大小不等于源中实际的元素数量，则分割和遍历的行为是未定义的。
    
    参数
    
    iterator - 源的迭代器
    
    size - 源中元素的数量，报告为初始值 estimateSize 。
    
    characteristics - 此Spliterator的源或元素的特征。特性SIZED和SUBSIZED额外报告除非CONCURRENT供给。
    
    结果
    
    来自迭代器的拼接器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliteratorUnknownSize
```
public static Spliterator.OfInt spliteratorUnknownSize(PrimitiveIterator.OfInt iterator,
                                                       int characteristics)
```
    创建Spliterator.OfInt使用给定的IntStream.IntIterator作为元素的来源，没有初始大小估计。
    拼接器不是late-binding ，它继承了迭代器的故障快速属性，并实现了trySplit以允许有限的并行性。
    
    元素穿越应通过拼接器完成。如果在返回Spliter之后迭代器被操作，则分割和遍历的行为是未定义的。
    
    参数
    
    iterator - 源的迭代器
    
    characteristics - 此拼接器的源或元素的特征（ SIZED和 SUBSIZED ，如果提供，将被忽略，不会报告。）
    
    结果
    
    来自迭代器的拼接器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliterator
```
public static Spliterator.OfLong spliterator(PrimitiveIterator.OfLong iterator,
                                             long size,
                                             int characteristics)
```
    使用给定的LongStream.LongIterator作为元素的来源创建一个Spliterator.OfLong ，并使用给定的最初报告的大小。
    拼接器不是late-binding ，它继承了迭代器的故障快速属性，并实现了trySplit以允许有限的并行性。
    
    元素穿越应通过拼接器完成。如果迭代器在分割器返回后操作，或初始报告的大小不等于源中实际的元素数量，则分割和遍历的行为是未定义的。
    
    参数
    
    iterator - 源的迭代器
    
    size - 源中的元素数，要作为初始值 estimateSize报告。
    
    characteristics - 此拼接器的来源或元素的特征。特性SIZED和SUBSIZED额外报告除非CONCURRENT供给。
    
    结果
    
    来自迭代器的拼接器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliteratorUnknownSize
```
public static Spliterator.OfLong spliteratorUnknownSize(PrimitiveIterator.OfLong iterator,
                                                        int characteristics)
```
    创建一个Spliterator.OfLong使用给定的LongStream.LongIterator作为元素的来源，没有初始大小估计。
    拼接器不是late-binding ，它继承了迭代器的故障快速属性，并实现了trySplit以允许有限的并行性。
    
    元素穿越应通过拼接器完成。如果在返回Spliter之后迭代器被操作，则分割和遍历的行为是未定义的。
    
    参数
    
    iterator - 源的迭代器
    
    characteristics - 此拼接器的来源或元素的特征（ SIZED和 SUBSIZED （如果提供）将被忽略且不会报告。）
    
    结果
    
    来自迭代器的拼接器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliterator
```
public static Spliterator.OfDouble spliterator(PrimitiveIterator.OfDouble iterator,
                                               long size,
                                               int characteristics)
```
    创建Spliterator.OfDouble使用给定DoubleStream.DoubleIterator作为元素的来源，并与给定的初始报告的大小。
    拼接器不是late-binding ，它继承了迭代器的故障快速属性，并实现了trySplit以允许有限的并行性。
    
    元素穿越应通过拼接器完成。如果迭代器在分割器返回后操作，或初始报告的大小不等于源中实际的元素数量，则分割和遍历的行为是未定义的。
    
    参数
    
    iterator - 源的迭代器
    
    size - 源中的元素数，将作为初始值 estimateSize报告
    
    characteristics - 此拼接器的源或元素的特征。特性SIZED和SUBSIZED额外报告除非CONCURRENT供给。
    
    结果
    
    来自迭代器的拼接器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - spliteratorUnknownSize
```
public static Spliterator.OfDouble spliteratorUnknownSize(PrimitiveIterator.OfDouble iterator,
                                                          int characteristics)
```
    创建一个Spliterator.OfDouble使用给定的DoubleStream.DoubleIterator作为元素的来源，没有初始大小估计。
    拼接器不是late-binding ，它继承了迭代器的故障快速属性，并实现了trySplit以允许有限的并行性。
    
    元素穿越应通过拼接器完成。如果在返回Spliter之后迭代器被操作，则分割和遍历的行为是未定义的。
    
    参数
    
    iterator - 源的迭代器
    
    characteristics - 此拼接器的源或元素的特征（ SIZED和 SUBSIZED （如果提供）将被忽略且不会报告。）
    
    结果
    
    来自迭代器的拼接器
    
    异常
    
    NullPointerException - 如果给定的迭代器是 null
  - iterator
```
public static <T> Iterator<T> iterator(Spliterator<? extends T> spliterator)
```
    创建一个Iterator从Spliterator 。
    元素的遍历应该通过迭代器完成。如果在返回迭代器之后操作拼接器，则遍历的行为是未定义的。
    
    参数类型
    
    T - 元素类型
    
    参数
    
    spliterator - 拼接器
    
    结果
    
    迭代器
    
    异常
    
    NullPointerException - 如果给定的拼接器是 null
  - iterator
```
public static PrimitiveIterator.OfInt iterator(Spliterator.OfInt spliterator)
```
    创建一个PrimitiveIterator.OfInt从Spliterator.OfInt 。
    元素的遍历应该通过迭代器完成。如果在返回迭代器之后操作拼接器，则遍历的行为是未定义的。
    
    参数
    
    spliterator - 拼接器
    
    结果
    
    迭代器
    
    异常
    
    NullPointerException - 如果给定的拼接器是 null
  - iterator
```
public static PrimitiveIterator.OfLong iterator(Spliterator.OfLong spliterator)
```
    创建一个PrimitiveIterator.OfLong从Spliterator.OfLong 。
    元素的遍历应该通过迭代器完成。如果在返回迭代器之后操作拼接器，则遍历的行为是未定义的。
    
    参数
    
    spliterator - 拼接器
    
    结果
    
    迭代器
    
    异常
    
    NullPointerException - 如果给定的拼接器是 null
  - iterator
```
public static PrimitiveIterator.OfDouble iterator(Spliterator.OfDouble spliterator)
```
    创建一个PrimitiveIterator.OfDouble从Spliterator.OfDouble 。
    元素的遍历应该通过迭代器完成。如果在返回迭代器之后操作拼接器，则遍历的行为是未定义的。
    
    参数
    
    spliterator - 拼接器
    
    结果
    
    迭代器
    
    异常
    
    NullPointerException - 如果给定的拼接器是 null

Class Spliterators

Nested Class Summary

方法摘要

Methods inherited from class 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