Spliterators (Java Platform SE 8 )

java.lang.Object
- java.util.Spliterators

```
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 and Description
`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	Method and Description
`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 <T> Spliterator<T>`	`spliterator(Collection<? extends T> c, int characteristics)` 创建一个 `Spliterator`使用给定集合的 `Collection.iterator()`作为元素的来源，并报告其 `Collection.size()`作为其初始大小。
`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`覆盖一组给定数组的元素，使用一组自定义的分割器特征。
`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`覆盖给定数组的一系列元素，使用一组自定义的拼接器特征。
`static <T> Spliterator<T>`	`spliterator(Iterator<? extends T> iterator, long size, int characteristics)` 创建一个 `Spliterator`使用给定的 `Iterator`作为元素的来源，并给定最初报告的大小。
`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`覆盖给定数组的一系列元素，使用一组自定义的拼接器特性。
`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`覆盖一组给定数组的元素，使用一组自定义的拼接器特征。
`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)` 使用给定的 `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)` 创建一个 `Spliterator`使用给定的 `Iterator`作为元素的来源，没有初始大小估计。
`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特性的精细控制。大多数其他情况下，需要使用数组的Spliterator才能使用Arrays.spliterator(Object[]) 。
    
    返回的Spliterer总是报告特性SIZED和SUBSIZED 。呼叫者可以为分组报告提供附加特征; 通常还要指定IMMUTABLE和ORDERED 。
    
    参数类型
    
    T - 元素类型
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    additionalCharacteristics - 这个拼接器的来源或超出 SIZED和 SUBSIZED元素的 SIZED SUBSIZED特征，总是被报告
    
    结果
    
    阵列的拼接器
    
    异常
    
    NullPointerException - 如果给定的数组是 null
    
    另请参见：
    
    Arrays.spliterator(Object[])
  - spliterator
```
public static <T> Spliterator<T> spliterator(Object[] array,
                                             int fromIndex,
                                             int toIndex,
                                             int additionalCharacteristics)
```
    创建一个Spliterator涵盖给定数组的一系列元素，使用一组自定义的拼接器特征。
    该方法被提供为用于将其元素的部分存储在数组中的分割器的实现方便性，并且需要对Spliterator特性的精细控制。需要使用数组的Spliter的大多数其他情况应该使用Arrays.spliterator(Object[]) 。
    
    返回的Spliterer总是报告特性SIZED和SUBSIZED 。呼叫者可以为分组报告提供附加特征; 通常还要指定IMMUTABLE和ORDERED 。
    
    参数类型
    
    T - 元素类型
    
    参数
    
    array - 假定在使用期间 array的数组
    
    fromIndex - 涵盖的最小索引（包括）
    
    toIndex - 过去最大的索引之一
    
    additionalCharacteristics - 这个拼接器的源或 SIZED SUBSIZED特征（ 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特性的精细控制。大多数其他情况下，需要使用数组的Spliterator才能使用Arrays.spliterator(int[]) 。
    
    返回的Spliterer总是报告特性SIZED和SUBSIZED 。呼叫者可以为分组报告提供附加特征; 通常还要指定IMMUTABLE和ORDERED 。
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    additionalCharacteristics - 这个拼接器的源或 SIZED SUBSIZED特征（ 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) 。
    
    返回的Spliterer总是报告特性SIZED和SUBSIZED 。呼叫者可以为分组报告提供附加特征; 通常还要指定IMMUTABLE和ORDERED 。
    
    参数
    
    array - 假定在使用期间 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特性的精细控制。大多数其他情况下，需要使用数组的Spliterator才能使用Arrays.spliterator(long[]) 。
    
    返回的Spliterer总是报告特性SIZED和SUBSIZED 。呼叫者可以为分组报告提供附加特征; 通常还要指定IMMUTABLE和ORDERED 。
    
    参数
    
    array - 假定在使用过程中 array的数组
    
    additionalCharacteristics - 这个拼接器的源或 SIZED SUBSIZED特征（ SIZED和 SUBSIZED总是被报告
    
    结果
    
    阵列的拼接器
    
    异常
    
    NullPointerException - 如果给定的数组是 null
    
    另请参见：
    
    Arrays.spliterator(long[])
  - spliterator
```
public static Spliterator.OfLong spliterator(long[] array,
                                             int fromIndex,
                                             int toIndex,
                                             int additionalCharacteristics)
```
    创建一个Spliterator.OfLong ，使用一组自定义的拼接器Spliterator.OfLong覆盖给定数组的一系列元素。
    该方法被提供为用于将其元素的部分存储在数组中的分割器的实现方便性，并且需要对Spliterator特性的精细控制。需要使用数组的Spliterator的其他大多数情况应该使用Arrays.spliterator(long[], int, int) 。
    
    返回的分配器总是报告特性SIZED和SUBSIZED 。呼叫者可以为分组器报告提供附加特性。（例如，如果知道数组不会被进一步修改，请指定IMMUTABLE ;如果数组数据被认为具有相遇顺序，请指定ORDERED ）。该方法Arrays.spliterator(long[], int, int)通常可以替代地使用，这将返回一个报告spliterator SIZED ， SUBSIZED ， IMMUTABLE和ORDERED 。
    
    参数
    
    array - 假定在使用过程中 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特性的精细控制。需要使用数组的Spliter的大多数其他情况应该使用Arrays.spliterator(double[]) 。
    
    返回的分配器总是报告特性SIZED和SUBSIZED 。呼叫者可以为分组报告提供附加特征; 通常还要指定IMMUTABLE和ORDERED 。
    
    参数
    
    array - 假定在使用过程中 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) 。
    
    返回的Spliterer总是报告特性SIZED和SUBSIZED 。呼叫者可以为分组器报告提供附加特性。（例如，如果知道该数组将不被进一步修改，请指定IMMUTABLE ;如果数组数据被认为具有相遇顺序，请指定ORDERED ）。该方法Arrays.spliterator(long[], int, int)通常可以替代地使用，这将返回一个报告spliterator SIZED ， SUBSIZED ， IMMUTABLE和ORDERED 。
    
    参数
    
    array - 假定在使用期间 array的数组
    
    fromIndex - 涵盖的最小索引（包括）
    
    toIndex - 一个过去最大的索引
    
    additionalCharacteristics - 这个拼接器的源或 SIZED SUBSIZED特征，总是被报告在 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)
```
    创建一个Spliterator使用给定集合的Collection.iterator()作为元素的来源，并报告其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)
```
    创建一个Spliterator使用给定的Iterator作为元素的来源，并给定最初报告的大小。
    拼接器不是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)
```
    创建一个Spliterator.OfInt使用给定的IntStream.IntIterator作为元素的来源，并给定最初报告的大小。
    拼接器不是late-binding ，它继承了迭代器的故障快速属性，并实现了trySplit以允许有限的并行性。
    
    元素穿越应通过拼接器完成。如果迭代器在分割器返回后操作，或初始报告的大小不等于源中实际的元素数量，则分割和遍历的行为是未定义的。
    
    参数
    
    iterator - 源的迭代器
    
    size - 源中元素的数量，以初始值 estimateSize报告。
    
    characteristics - 此拼接器的源或元素的特征。额外报告特性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

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

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