模块  java.base
软件包  java.util

Class Spliterators

    • 方法详细信息

      • spliterator

        public static <T> Spliterator<T> spliterator​(Object[] array,
                                                     int additionalCharacteristics)
        创建Spliterator覆盖给定的阵列的元件,使用一组定制的spliterator特性。

        提供此方法作为Spliterators的实现方便,Spliterators将其元素的部分存储在数组中,并且需要对Spliterator特性进行精细控制。 需要使用阵列的Spliterator的大多数其他情况应使用Arrays.spliterator(Object[])

        返回的分裂器始终报告特征SIZEDSUBSIZED 呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLEORDERED

        参数类型
        T - 元素类型
        参数
        array - 假定在使用期间未修改的数组
        additionalCharacteristics - 此分裂器源或元件的其他分裂器特性超出 SIZEDSUBSIZED ,这些特性始终报告
        结果
        数组的分裂器
        异常
        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[])

        返回的分裂器始终报告特征SIZEDSUBSIZED 呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLEORDERED

        参数类型
        T - 元素类型
        参数
        array - 假定在使用期间未修改的数组
        fromIndex - 要覆盖的最小索引(包括)
        toIndex - 过去最大的指数之一
        additionalCharacteristics - 此分裂器源或元件的其他分裂器特性超出 SIZEDSUBSIZED ,这些特性始终报告
        结果
        数组的分裂器
        异常
        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始终报告特征SIZEDSUBSIZED 呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLEORDERED

        参数
        array - 假定在使用期间未修改的数组
        additionalCharacteristics - 此分裂器源或元件的额外分裂器特性超出 SIZEDSUBSIZED ,总是报告
        结果
        数组的分裂器
        异常
        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)

        返回的分裂器始终报告特征SIZEDSUBSIZED 呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLEORDERED

        参数
        array - 假定在使用期间未修改的数组
        fromIndex - 要覆盖的最小索引(包括)
        toIndex - 覆盖范围最大的指数之一
        additionalCharacteristics - 此分裂器的源或超出 SIZEDSUBSIZED元素的附加分裂器特征始终报告
        结果
        数组的分裂器
        异常
        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[])

        返回的分裂器始终报告特征SIZEDSUBSIZED 呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLEORDERED

        参数
        array - 假定在使用期间未修改的数组
        additionalCharacteristics - 此分裂器源或超出 SIZEDSUBSIZED元素的附加分裂器特性总是报告
        结果
        数组的分裂器
        异常
        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)

        返回的分裂器始终报告特征SIZEDSUBSIZED 呼叫者可以为分裂者报告提供额外的特征。 (例如,如果已知数组将不再进一步修改,请指定IMMUTABLE ;如果数组数据被视为具有遭遇顺序,请指定ORDERED )。 该方法Arrays.spliterator(long[], int, int)通常可以替代地使用,这将返回一个报告spliterator SIZEDSUBSIZEDIMMUTABLE ,和ORDERED

        参数
        array - 假定在使用期间未修改的数组
        fromIndex - 要覆盖的最小索引(包括)
        toIndex - 覆盖范围最大的指数之一
        additionalCharacteristics - 此分裂器源或超出 SIZEDSUBSIZED元素的附加分裂器特征总是报告
        结果
        数组的分裂器
        异常
        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[])

        返回的分裂器始终报告特征SIZEDSUBSIZED 呼叫者可以为分裂者报告提供额外的特征; 通常另外指定IMMUTABLEORDERED

        参数
        array - 数组,假设在使用期间未经修改
        additionalCharacteristics - 此分裂器源或超出 SIZEDSUBSIZED元素的其他分裂器特性总是报告
        结果
        数组的分裂器
        异常
        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)

        返回的分裂器始终报告特征SIZEDSUBSIZED 呼叫者可以为分裂者报告提供额外的特征。 (例如,如果已知数组将不会被进一步修改,请指定IMMUTABLE ;如果数组数据被视为具有遭遇顺序,请指定ORDERED )。 该方法Arrays.spliterator(long[], int, int)通常可以替代地使用,这将返回一个报告spliterator SIZEDSUBSIZEDIMMUTABLE ,和ORDERED

        参数
        array - 假定在使用期间未修改的数组
        fromIndex - 要覆盖的最小索引(包括)
        toIndex - 覆盖范围最大的指数之一
        additionalCharacteristics - 此分裂器源或超出 SIZEDSUBSIZED元素的附加分裂器特性总是报告
        结果
        数组的分裂器
        异常
        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 - 此分裂器的源或元素的特征。 特性SIZEDSUBSIZED被额外报告除非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 - 此分裂器的源或元素的特征。 特性SIZEDSUBSIZED被额外报告除非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的源或元素的特征( SIZEDSUBSIZED ,如果提供,将被忽略,不会报告。)
        结果
        来自迭代器的分裂器
        异常
        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 - 此分裂器的源或元素的特征。 特性SIZEDSUBSIZED被额外报告除非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的源或元素的特征( SIZEDSUBSIZED ,如果提供,将被忽略,不会报告。)
        结果
        来自迭代器的分裂器
        异常
        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 - 此分裂器的源或元素的特征。 特性SIZEDSUBSIZED被额外报告除非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的源或元素的特征( SIZEDSUBSIZED ,如果提供,将被忽略,不会报告。)
        结果
        来自迭代器的分裂器
        异常
        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 - 此分裂器的源或元素的特征。 特性SIZEDSUBSIZED被额外报告除非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的源或元素的特征( SIZEDSUBSIZED ,如果提供,将被忽略,不会报告。)
        结果
        来自迭代器的分裂器
        异常
        NullPointerException - 如果给定的迭代器是 null
      • iterator

        public static <T> Iterator<T> iterator​(Spliterator<? extends T> spliterator)
        创建一个IteratorSpliterator

        元素的遍历应该通过迭代器完成。 如果在返回迭代器后操作spliterator,则遍历的行为是不确定的。

        参数类型
        T - 元素类型
        参数
        spliterator - 分裂者
        结果
        迭代器
        异常
        NullPointerException - 如果给定的分裂器是 null
      • iterator

        public static PrimitiveIterator.OfInt iterator​(Spliterator.OfInt spliterator)
        创建一个PrimitiveIterator.OfIntSpliterator.OfInt

        元素的遍历应该通过迭代器完成。 如果在返回迭代器后操作spliterator,则遍历的行为是不确定的。

        参数
        spliterator - 分裂者
        结果
        迭代器
        异常
        NullPointerException - 如果给定的分裂器是 null
      • iterator

        public static PrimitiveIterator.OfLong iterator​(Spliterator.OfLong spliterator)
        创建一个PrimitiveIterator.OfLongSpliterator.OfLong

        元素的遍历应该通过迭代器完成。 如果在返回迭代器后操作spliterator,则遍历的行为是不确定的。

        参数
        spliterator - 分裂者
        结果
        迭代器
        异常
        NullPointerException - 如果给定的分裂器是 null
      • iterator

        public static PrimitiveIterator.OfDouble iterator​(Spliterator.OfDouble spliterator)
        创建一个PrimitiveIterator.OfDoubleSpliterator.OfDouble

        元素的遍历应该通过迭代器完成。 如果在返回迭代器后操作spliterator,则遍历的行为是不确定的。

        参数
        spliterator - 分裂者
        结果
        迭代器
        异常
        NullPointerException - 如果给定的分裂器是 null