All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.landawn.abacus.util.stream.IntStream Maven / Gradle / Ivy

There is a newer version: 1.10.1
Show newest version
/*
 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package com.landawn.abacus.util.stream;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.PrimitiveIterator;
import java.util.Queue;

import com.landawn.abacus.exception.AbacusException;
import com.landawn.abacus.util.ContinuableFuture;
import com.landawn.abacus.util.Fn;
import com.landawn.abacus.util.Holder;
import com.landawn.abacus.util.IndexedInt;
import com.landawn.abacus.util.IntIterator;
import com.landawn.abacus.util.IntList;
import com.landawn.abacus.util.IntMatrix;
import com.landawn.abacus.util.IntSummaryStatistics;
import com.landawn.abacus.util.MutableInt;
import com.landawn.abacus.util.N;
import com.landawn.abacus.util.Nth;
import com.landawn.abacus.util.Optional;
import com.landawn.abacus.util.OptionalDouble;
import com.landawn.abacus.util.OptionalInt;
import com.landawn.abacus.util.Pair;
import com.landawn.abacus.util.Percentage;
import com.landawn.abacus.util.Try;
import com.landawn.abacus.util.function.BiConsumer;
import com.landawn.abacus.util.function.BinaryOperator;
import com.landawn.abacus.util.function.BooleanSupplier;
import com.landawn.abacus.util.function.Function;
import com.landawn.abacus.util.function.IntBiFunction;
import com.landawn.abacus.util.function.IntBiPredicate;
import com.landawn.abacus.util.function.IntBinaryOperator;
import com.landawn.abacus.util.function.IntConsumer;
import com.landawn.abacus.util.function.IntFunction;
import com.landawn.abacus.util.function.IntNFunction;
import com.landawn.abacus.util.function.IntPredicate;
import com.landawn.abacus.util.function.IntSupplier;
import com.landawn.abacus.util.function.IntToByteFunction;
import com.landawn.abacus.util.function.IntToCharFunction;
import com.landawn.abacus.util.function.IntToDoubleFunction;
import com.landawn.abacus.util.function.IntToFloatFunction;
import com.landawn.abacus.util.function.IntToLongFunction;
import com.landawn.abacus.util.function.IntToShortFunction;
import com.landawn.abacus.util.function.IntTriFunction;
import com.landawn.abacus.util.function.IntUnaryOperator;
import com.landawn.abacus.util.function.ObjIntConsumer;
import com.landawn.abacus.util.function.Supplier;
import com.landawn.abacus.util.function.ToIntFunction;

/**
 * Note: It's copied from OpenJDK at: http://hg.openjdk.java.net/jdk8u/hs-dev/jdk
 * 
* * @see Stream */ public abstract class IntStream extends StreamBase { private static final IntStream EMPTY = new ArrayIntStream(N.EMPTY_INT_ARRAY, true, null); IntStream(final boolean sorted, final Collection closeHandlers) { super(sorted, null, closeHandlers); } /** * Returns a stream consisting of the results of applying the given * function to the elements of this stream. * *

This is an intermediate * operation. * * @param mapper a non-interfering, * stateless * function to apply to each element * @return the new stream */ public abstract IntStream map(IntUnaryOperator mapper); public abstract CharStream mapToChar(IntToCharFunction mapper); public abstract ByteStream mapToByte(IntToByteFunction mapper); public abstract ShortStream mapToShort(IntToShortFunction mapper); /** * Returns a {@code LongStream} consisting of the results of applying the * given function to the elements of this stream. * *

This is an intermediate * operation. * * @param mapper a non-interfering, * stateless * function to apply to each element * @return the new stream */ public abstract LongStream mapToLong(IntToLongFunction mapper); /** * Returns a {@code FloatStream} consisting of the results of applying the * given function to the elements of this stream. * *

This is an intermediate * operation. * * @param mapper a non-interfering, * stateless * function to apply to each element * @return the new stream */ public abstract FloatStream mapToFloat(IntToFloatFunction mapper); /** * Returns a {@code DoubleStream} consisting of the results of applying the * given function to the elements of this stream. * *

This is an intermediate * operation. * * @param mapper a non-interfering, * stateless * function to apply to each element * @return the new stream */ public abstract DoubleStream mapToDouble(IntToDoubleFunction mapper); /** * Returns an object-valued {@code Stream} consisting of the results of * applying the given function to the elements of this stream. * *

This is an * intermediate operation. * * @param the element type of the new stream * @param mapper a non-interfering, * stateless * function to apply to each element * @return the new stream */ public abstract Stream mapToObj(IntFunction mapper); /** * Returns a stream consisting of the results of replacing each element of * this stream with the contents of a mapped stream produced by applying * the provided mapping function to each element. * *

This is an intermediate * operation. * * @param mapper a non-interfering, * stateless * function to apply to each element which produces an * {@code IntStream} of new values * @return the new stream * @see Stream#flatMap(Function) */ public abstract IntStream flatMap(IntFunction mapper); public abstract IntStream flattMap(IntFunction mapper); public abstract CharStream flatMapToChar(IntFunction mapper); public abstract ByteStream flatMapToByte(IntFunction mapper); public abstract ShortStream flatMapToShort(IntFunction mapper); public abstract LongStream flatMapToLong(IntFunction mapper); public abstract FloatStream flatMapToFloat(IntFunction mapper); public abstract DoubleStream flatMapToDouble(IntFunction mapper); public abstract Stream flatMapToObj(IntFunction> mapper); public abstract Stream flattMapToObj(IntFunction> mapper); /** * Merge series of adjacent elements which satisfy the given predicate using * the merger function and return a new stream. * *
* This method only run sequentially, even in parallel stream. * * @param collapsible * @param mergeFunction * @return */ @SequentialOnly public abstract IntStream collapse(final IntBiPredicate collapsible, final IntBiFunction mergeFunction); /** * Returns a {@code Stream} produced by iterative application of a accumulation function * to an initial element {@code seed} and next element of the current stream. * Produces a {@code Stream} consisting of {@code seed}, {@code acc(seed, value1)}, * {@code acc(acc(seed, value1), value2)}, etc. * *

This is an intermediate operation. * *

Example: *

     * accumulator: (a, b) -> a + b
     * stream: [1, 2, 3, 4, 5]
     * result: [1, 3, 6, 10, 15]
     * 
* *
* This method only run sequentially, even in parallel stream. * * @param accumulator the accumulation function * @return the new stream which has the extract same size as this stream. */ @SequentialOnly public abstract IntStream scan(final IntBiFunction accumulator); /** * Returns a {@code Stream} produced by iterative application of a accumulation function * to an initial element {@code seed} and next element of the current stream. * Produces a {@code Stream} consisting of {@code seed}, {@code acc(seed, value1)}, * {@code acc(acc(seed, value1), value2)}, etc. * *

This is an intermediate operation. * *

Example: *

     * seed:10
     * accumulator: (a, b) -> a + b
     * stream: [1, 2, 3, 4, 5]
     * result: [11, 13, 16, 20, 25]
     * 
* *
* This method only run sequentially, even in parallel stream. * * @param seed the initial value. it's only used once by accumulator to calculate the fist element in the returned stream. * It will be ignored if this stream is empty and won't be the first element of the returned stream. * * @param accumulator the accumulation function * @return the new stream which has the extract same size as this stream. */ @SequentialOnly public abstract IntStream scan(final int seed, final IntBiFunction accumulator); /** * *
* This method only run sequentially, even in parallel stream. * * @param n * @return */ @SequentialOnly public abstract IntStream top(int n); /** * *
* This method only run sequentially, even in parallel stream. * * @param n * @param comparator * @return */ @SequentialOnly public abstract IntStream top(final int n, Comparator comparator); public abstract IntList toIntList(); /** * * @param keyExtractor * @param valueMapper * @return * @see Collectors#toMap(Function, Function) */ public abstract Map toMap(IntFunction keyExtractor, IntFunction valueMapper); /** * * @param keyExtractor * @param valueMapper * @param mapFactory * @return * @see Collectors#toMap(Function, Function, Supplier) */ public abstract > M toMap(IntFunction keyExtractor, IntFunction valueMapper, Supplier mapFactory); /** * * @param keyExtractor * @param valueMapper * @param mergeFunction * @return * @see Collectors#toMap(Function, Function, BinaryOperator) */ public abstract Map toMap(IntFunction keyExtractor, IntFunction valueMapper, BinaryOperator mergeFunction); /** * * @param keyExtractor * @param valueMapper * @param mergeFunction * @param mapFactory * @return * @see Collectors#toMap(Function, Function, BinaryOperator, Supplier) */ public abstract > M toMap(IntFunction keyExtractor, IntFunction valueMapper, BinaryOperator mergeFunction, Supplier mapFactory); /** * * @param classifier * @param downstream * @return * @see Collectors#groupingBy(Function, Collector) */ public abstract Map toMap(final IntFunction classifier, final Collector downstream); /** * * @param classifier * @param downstream * @param mapFactory * @return * @see Collectors#groupingBy(Function, Collector, Supplier) */ public abstract > M toMap(final IntFunction classifier, final Collector downstream, final Supplier mapFactory); public abstract IntMatrix toMatrix(); /** * Performs a reduction on the * elements of this stream, using the provided identity value and an * associative * accumulation function, and returns the reduced value. This is equivalent * to: *
{@code
     *     int result = identity;
     *     for (int element : this stream)
     *         result = accumulator.applyAsInt(result, element)
     *     return result;
     * }
* * but is not constrained to execute sequentially. * *

The {@code identity} value must be an identity for the accumulator * function. This means that for all {@code x}, * {@code accumulator.apply(identity, x)} is equal to {@code x}. * The {@code accumulator} function must be an * associative function. * *

This is a terminal * operation. * * @apiNote Sum, min, max, and average are all special cases of reduction. * Summing a stream of numbers can be expressed as: * *

{@code
     *     int sum = integers.reduce(0, (a, b) -> a+b);
     * }
* * or more compactly: * *
{@code
     *     int sum = integers.reduce(0, Integer::sum);
     * }
* *

While this may seem a more roundabout way to perform an aggregation * compared to simply mutating a running total in a loop, reduction * operations parallelize more gracefully, without needing additional * synchronization and with greatly reduced risk of data races. * * @param identity the identity value for the accumulating function * @param op an associative, * non-interfering, * stateless * function for combining two values * @return the result of the reduction * @see #sum() * @see #min() * @see #max() * @see #average() */ public abstract int reduce(int identity, IntBinaryOperator op); /** * Performs a reduction on the * elements of this stream, using an * associative accumulation * function, and returns an {@code OptionalInt} describing the reduced value, * if any. This is equivalent to: *

{@code
     *     boolean foundAny = false;
     *     int result = null;
     *     for (int element : this stream) {
     *         if (!foundAny) {
     *             foundAny = true;
     *             result = element;
     *         }
     *         else
     *             result = accumulator.applyAsInt(result, element);
     *     }
     *     return foundAny ? OptionalInt.of(result) : OptionalInt.empty();
     * }
* * but is not constrained to execute sequentially. * *

The {@code accumulator} function must be an * associative function. * *

This is a terminal * operation. * * @param op an associative, * non-interfering, * stateless * function for combining two values * @return the result of the reduction * @see #reduce(int, IntBinaryOperator) */ public abstract OptionalInt reduce(IntBinaryOperator op); /** * Performs a mutable * reduction operation on the elements of this stream. A mutable * reduction is one in which the reduced value is a mutable result container, * such as an {@code ArrayList}, and elements are incorporated by updating * the state of the result rather than by replacing the result. This * produces a result equivalent to: *

{@code
     *     R result = supplier.get();
     *     for (int element : this stream)
     *         accumulator.accept(result, element);
     *     return result;
     * }
* *

Like {@link #reduce(int, IntBinaryOperator)}, {@code collect} operations * can be parallelized without requiring additional synchronization. * *

This is a terminal * operation. * * @param type of the result * @param supplier a function that creates a new result container. For a * parallel execution, this function may be called * multiple times and must return a fresh value each time. * @param accumulator an associative, * non-interfering, * stateless * function for incorporating an additional element into a result * @param combiner an associative, * non-interfering, * stateless * function for combining two values, which must be * compatible with the accumulator function * @return the result of the reduction * @see Stream#collect(Supplier, BiConsumer, BiConsumer) */ public abstract R collect(Supplier supplier, ObjIntConsumer accumulator, BiConsumer combiner); /** * * @param supplier * @param accumulator * @return */ public abstract R collect(Supplier supplier, ObjIntConsumer accumulator); public abstract void forEach(final Try.IntConsumer action) throws E; public abstract boolean anyMatch(final Try.IntPredicate predicate) throws E; public abstract boolean allMatch(final Try.IntPredicate predicate) throws E; public abstract boolean noneMatch(final Try.IntPredicate predicate) throws E; public abstract OptionalInt findFirst(final Try.IntPredicate predicate) throws E; public abstract OptionalInt findLast(final Try.IntPredicate predicate) throws E; public abstract OptionalInt findFirstOrLast(Try.IntPredicate predicateForFirst, Try.IntPredicate predicateForLast) throws E, E2; public abstract OptionalInt findAny(final Try.IntPredicate predicate) throws E; /** * Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. * Don't call any other methods with this stream after head() and tail() are called. * * @return */ public abstract OptionalInt head(); /** * Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. * Don't call any other methods with this stream after head() and tail() are called. * * @return */ public abstract IntStream tail(); public abstract Pair headAndTail(); // /** // * Headd and taill should be used by pair. // * Don't call any other methods with this stream after headd() and taill() are called. // * // * @return // * @deprecated // */ // @Deprecated // public abstract IntStream headd(); // // /** // * Headd and taill should be used by pair. // * Don't call any other methods with this stream after headd() and taill() are called. // * // * @return // * @deprecated // */ // @Deprecated // public abstract OptionalInt taill(); // // /** // * // * @return // * @deprecated // */ // @Deprecated // public abstract Pair headAndTaill(); /** * Returns an {@code OptionalInt} describing the minimum element of this * stream, or an empty optional if this stream is empty. This is a special * case of a reduction * and is equivalent to: *

{@code
     *     return reduce(Integer::min);
     * }
* *

This is a terminal operation. * * @return an {@code OptionalInt} containing the minimum element of this * stream, or an empty {@code OptionalInt} if the stream is empty */ public abstract OptionalInt min(); /** * Returns an {@code OptionalInt} describing the maximum element of this * stream, or an empty optional if this stream is empty. This is a special * case of a reduction * and is equivalent to: *

{@code
     *     return reduce(Integer::max);
     * }
* *

This is a terminal * operation. * * @return an {@code OptionalInt} containing the maximum element of this * stream, or an empty {@code OptionalInt} if the stream is empty */ public abstract OptionalInt max(); /** * * @param k * @return OptionalByte.empty() if there is no element or count less than k, otherwise the kth largest element. */ public abstract OptionalInt kthLargest(int k); /** * Returns the sum of elements in this stream. This is a special case * of a reduction * and is equivalent to: *

{@code
     *     return reduce(0, Integer::sum);
     * }
* *

This is a terminal * operation. * * @return the sum of elements in this stream */ public abstract int sum(); /** * Returns an {@code OptionalDouble} describing the arithmetic mean of elements of * this stream, or an empty optional if this stream is empty. This is a * special case of a * reduction. * *

This is a terminal * operation. * * @return an {@code OptionalDouble} containing the average element of this * stream, or an empty optional if the stream is empty */ public abstract OptionalDouble average(); public abstract IntSummaryStatistics summarize(); public abstract Pair>> summarizze(); /** * * @param b * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected. * @return */ public abstract IntStream merge(final IntStream b, final IntBiFunction nextSelector); public abstract IntStream zipWith(IntStream b, IntBiFunction zipFunction); public abstract IntStream zipWith(IntStream b, IntStream c, IntTriFunction zipFunction); public abstract IntStream zipWith(IntStream b, int valueForNoneA, int valueForNoneB, IntBiFunction zipFunction); public abstract IntStream zipWith(IntStream b, IntStream c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction zipFunction); /** * Returns a {@code LongStream} consisting of the elements of this stream, * converted to {@code long}. * *

This is an intermediate * operation. * * @return a {@code LongStream} consisting of the elements of this stream, * converted to {@code long} */ public abstract LongStream asLongStream(); /** * Returns a {@code FloatStream} consisting of the elements of this stream, * converted to {@code double}. * *

This is an intermediate * operation. * * @return a {@code FloatStream} consisting of the elements of this stream, * converted to {@code double} */ public abstract FloatStream asFloatStream(); /** * Returns a {@code DoubleStream} consisting of the elements of this stream, * converted to {@code double}. * *

This is an intermediate * operation. * * @return a {@code DoubleStream} consisting of the elements of this stream, * converted to {@code double} */ public abstract DoubleStream asDoubleStream(); public abstract java.util.stream.IntStream toJdkStream(); /** * Returns a {@code Stream} consisting of the elements of this stream, * each boxed to an {@code Integer}. * *

This is an intermediate * operation. * * @return a {@code Stream} consistent of the elements of this stream, * each boxed to an {@code Integer} */ public abstract Stream boxed(); @Override public IntIterator iterator() { return iteratorEx(); } abstract IntIteratorEx iteratorEx(); @Override public R __(Function transfer) { return transfer.apply(this); } public static IntStream empty() { return EMPTY; } @SafeVarargs public static IntStream of(final int... a) { return N.isNullOrEmpty(a) ? empty() : new ArrayIntStream(a); } public static IntStream of(final int[] a, final int startIndex, final int endIndex) { return N.isNullOrEmpty(a) && (startIndex == 0 && endIndex == 0) ? empty() : new ArrayIntStream(a, startIndex, endIndex); } public static IntStream of(final int[][] a) { return N.isNullOrEmpty(a) ? empty() : Stream.of(a).flatMapToInt(new Function() { @Override public IntStream apply(int[] t) { return IntStream.of(t); } }); } public static IntStream of(final int[][][] a) { return N.isNullOrEmpty(a) ? empty() : Stream.of(a).flatMapToInt(new Function() { @Override public IntStream apply(int[][] t) { return IntStream.of(t); } }); } public static IntStream of(final Integer[] a) { return Stream.of(a).mapToInt(Fn.unboxI()); } public static IntStream of(final Integer[] a, final int startIndex, final int endIndex) { return Stream.of(a, startIndex, endIndex).mapToInt(Fn.unboxI()); } public static IntStream of(final Collection c) { return Stream.of(c).mapToInt(Fn.unboxI()); } public static IntStream of(final IntIterator iterator) { return iterator == null ? empty() : new IteratorIntStream(iterator); } /** * Lazy evaluation. * @param supplier * @return */ public static IntStream of(final Supplier supplier) { final IntIterator iter = new IntIteratorEx() { private IntIterator iterator = null; @Override public boolean hasNext() { if (iterator == null) { init(); } return iterator.hasNext(); } @Override public int nextInt() { if (iterator == null) { init(); } return iterator.nextInt(); } private void init() { final IntList c = supplier.get(); if (N.isNullOrEmpty(c)) { iterator = IntIterator.empty(); } else { iterator = c.iterator(); } } }; return of(iter); } public static IntStream of(final java.util.stream.IntStream stream) { return of(new IntIteratorEx() { private PrimitiveIterator.OfInt iter = null; @Override public boolean hasNext() { if (iter == null) { iter = stream.iterator(); } return iter.hasNext(); } @Override public int nextInt() { if (iter == null) { iter = stream.iterator(); } return iter.nextInt(); } @Override public long count() { return iter == null ? stream.count() : super.count(); } @Override public void skip(long n) { if (iter == null) { iter = stream.skip(n).iterator(); } else { super.skip(n); } } @Override public int[] toArray() { return iter == null ? stream.toArray() : super.toArray(); } }).onClose(new Runnable() { @Override public void run() { stream.close(); } }); } public static IntStream ofCodePoints(final CharSequence str) { if (N.isNullOrEmpty(str)) { return empty(); } final IntIterator iter = new IntIterator() { private final int len = str.length(); private int cursor = 0; @Override public boolean hasNext() { return cursor < len; } @Override public int nextInt() { if (cursor >= len) { throw new NoSuchElementException(); } char c1 = str.charAt(cursor++); if (Character.isHighSurrogate(c1) && cursor < len) { char c2 = str.charAt(cursor); if (Character.isLowSurrogate(c2)) { cursor++; return Character.toCodePoint(c1, c2); } } return c1; } }; return of(iter); } @SafeVarargs public static IntStream from(final char... a) { return N.isNullOrEmpty(a) ? empty() : from(a, 0, a.length); } public static IntStream from(final char[] a, final int fromIndex, final int toIndex) { N.checkFromToIndex(fromIndex, toIndex, N.len(a)); if (fromIndex == toIndex) { return empty(); } return new IteratorIntStream(new IntIteratorEx() { private int cursor = fromIndex; @Override public boolean hasNext() { return cursor < toIndex; } @Override public int nextInt() { if (cursor >= toIndex) { throw new NoSuchElementException(); } return a[cursor++]; } @Override public long count() { return toIndex - cursor; } @Override public void skip(long n) { cursor = n < toIndex - cursor ? cursor + (int) n : toIndex; } @Override public int[] toArray() { final int[] result = new int[toIndex - cursor]; for (int i = cursor; i < toIndex; i++) { result[i - cursor] = a[i]; } return result; } }); } @SafeVarargs public static IntStream from(final byte... a) { return N.isNullOrEmpty(a) ? empty() : from(a, 0, a.length); } public static IntStream from(final byte[] a, final int fromIndex, final int toIndex) { N.checkFromToIndex(fromIndex, toIndex, N.len(a)); if (fromIndex == toIndex) { return empty(); } return new IteratorIntStream(new IntIteratorEx() { private int cursor = fromIndex; @Override public boolean hasNext() { return cursor < toIndex; } @Override public int nextInt() { if (cursor >= toIndex) { throw new NoSuchElementException(); } return a[cursor++]; } @Override public long count() { return toIndex - cursor; } @Override public void skip(long n) { cursor = n < toIndex - cursor ? cursor + (int) n : toIndex; } @Override public int[] toArray() { final int[] result = new int[toIndex - cursor]; for (int i = cursor; i < toIndex; i++) { result[i - cursor] = a[i]; } return result; } }); } @SafeVarargs public static IntStream from(final short... a) { return N.isNullOrEmpty(a) ? empty() : from(a, 0, a.length); } public static IntStream from(final short[] a, final int fromIndex, final int toIndex) { N.checkFromToIndex(fromIndex, toIndex, N.len(a)); if (fromIndex == toIndex) { return empty(); } return new IteratorIntStream(new IntIteratorEx() { private int cursor = fromIndex; @Override public boolean hasNext() { return cursor < toIndex; } @Override public int nextInt() { if (cursor >= toIndex) { throw new NoSuchElementException(); } return a[cursor++]; } @Override public long count() { return toIndex - cursor; } @Override public void skip(long n) { cursor = n < toIndex - cursor ? cursor + (int) n : toIndex; } @Override public int[] toArray() { final int[] result = new int[toIndex - cursor]; for (int i = cursor; i < toIndex; i++) { result[i - cursor] = a[i]; } return result; } }); } public static IntStream range(final int startInclusive, final int endExclusive) { if (startInclusive >= endExclusive) { return empty(); } return new IteratorIntStream(new IntIteratorEx() { private int next = startInclusive; private long cnt = endExclusive * 1L - startInclusive; @Override public boolean hasNext() { return cnt > 0; } @Override public int nextInt() { if (cnt-- <= 0) { throw new NoSuchElementException(); } return next++; } @Override public void skip(long n) { cnt = n >= cnt ? 0 : cnt - (int) n; next += n; } @Override public long count() { return cnt; } @Override public int[] toArray() { final int[] result = new int[(int) cnt]; for (int i = 0; i < cnt; i++) { result[i] = next++; } cnt = 0; return result; } }); } public static IntStream range(final int startInclusive, final int endExclusive, final int by) { if (by == 0) { throw new IllegalArgumentException("'by' can't be zero"); } if (endExclusive == startInclusive || endExclusive > startInclusive != by > 0) { return empty(); } return new IteratorIntStream(new IntIteratorEx() { private int next = startInclusive; private long cnt = (endExclusive * 1L - startInclusive) / by + ((endExclusive * 1L - startInclusive) % by == 0 ? 0 : 1); @Override public boolean hasNext() { return cnt > 0; } @Override public int nextInt() { if (cnt-- <= 0) { throw new NoSuchElementException(); } int result = next; next += by; return result; } @Override public void skip(long n) { cnt = n >= cnt ? 0 : cnt - (int) n; next += n * by; } @Override public long count() { return cnt; } @Override public int[] toArray() { final int[] result = new int[(int) cnt]; for (int i = 0; i < cnt; i++, next += by) { result[i] = next; } cnt = 0; return result; } }); } public static IntStream rangeClosed(final int startInclusive, final int endInclusive) { if (startInclusive > endInclusive) { return empty(); } else if (startInclusive == endInclusive) { return of(startInclusive); } return new IteratorIntStream(new IntIteratorEx() { private int next = startInclusive; private long cnt = endInclusive * 1L - startInclusive + 1; @Override public boolean hasNext() { return cnt > 0; } @Override public int nextInt() { if (cnt-- <= 0) { throw new NoSuchElementException(); } return next++; } @Override public void skip(long n) { cnt = n >= cnt ? 0 : cnt - (int) n; next += n; } @Override public long count() { return cnt; } @Override public int[] toArray() { final int[] result = new int[(int) cnt]; for (int i = 0; i < cnt; i++) { result[i] = next++; } cnt = 0; return result; } }); } public static IntStream rangeClosed(final int startInclusive, final int endInclusive, final int by) { if (by == 0) { throw new IllegalArgumentException("'by' can't be zero"); } if (endInclusive == startInclusive) { return of(startInclusive); } else if (endInclusive > startInclusive != by > 0) { return empty(); } return new IteratorIntStream(new IntIteratorEx() { private int next = startInclusive; private long cnt = (endInclusive * 1L - startInclusive) / by + 1; @Override public boolean hasNext() { return cnt > 0; } @Override public int nextInt() { if (cnt-- <= 0) { throw new NoSuchElementException(); } int result = next; next += by; return result; } @Override public void skip(long n) { cnt = n >= cnt ? 0 : cnt - (int) n; next += n * by; } @Override public long count() { return cnt; } @Override public int[] toArray() { final int[] result = new int[(int) cnt]; for (int i = 0; i < cnt; i++, next += by) { result[i] = next; } cnt = 0; return result; } }); } public static IntStream repeat(final int element, final long n) { N.checkArgNotNegative(n, "n"); if (n == 0) { return empty(); } return new IteratorIntStream(new IntIteratorEx() { private long cnt = n; @Override public boolean hasNext() { return cnt > 0; } @Override public int nextInt() { if (cnt-- <= 0) { throw new NoSuchElementException(); } return element; } @Override public void skip(long n) { cnt = n >= cnt ? 0 : cnt - (int) n; } @Override public long count() { return cnt; } @Override public int[] toArray() { final int[] result = new int[(int) cnt]; for (int i = 0; i < cnt; i++) { result[i] = element; } cnt = 0; return result; } }); } public static IntStream random() { return generate(new IntSupplier() { @Override public int getAsInt() { return RAND.nextInt(); } }); } public static IntStream random(final int startInclusive, final int endExclusive) { if (startInclusive >= endExclusive) { throw new IllegalArgumentException("'startInclusive' must be less than 'endExclusive'"); } final long mod = (long) endExclusive - (long) startInclusive; if (mod < Integer.MAX_VALUE) { final int n = (int) mod; return generate(new IntSupplier() { @Override public int getAsInt() { return RAND.nextInt(n) + startInclusive; } }); } else { return generate(new IntSupplier() { @Override public int getAsInt() { return (int) (Math.abs(RAND.nextLong() % mod) + startInclusive); } }); } } public static IntStream iterate(final BooleanSupplier hasNext, final IntSupplier next) { N.checkArgNotNull(hasNext); N.checkArgNotNull(next); return new IteratorIntStream(new IntIteratorEx() { private boolean hasNextVal = false; @Override public boolean hasNext() { if (hasNextVal == false) { hasNextVal = hasNext.getAsBoolean(); } return hasNextVal; } @Override public int nextInt() { if (hasNextVal == false && hasNext() == false) { throw new NoSuchElementException(); } hasNextVal = false; return next.getAsInt(); } }); } public static IntStream iterate(final int seed, final BooleanSupplier hasNext, final IntUnaryOperator f) { N.checkArgNotNull(hasNext); N.checkArgNotNull(f); return new IteratorIntStream(new IntIteratorEx() { private int t = 0; private boolean isFirst = true; private boolean hasNextVal = false; @Override public boolean hasNext() { if (hasNextVal == false) { hasNextVal = hasNext.getAsBoolean(); } return hasNextVal; } @Override public int nextInt() { if (hasNextVal == false && hasNext() == false) { throw new NoSuchElementException(); } hasNextVal = false; if (isFirst) { isFirst = false; t = seed; } else { t = f.applyAsInt(t); } return t; } }); } /** * * @param seed * @param hasNext test if has next by hasNext.test(seed) for first time and hasNext.test(f.apply(previous)) for remaining. * @param f * @return */ public static IntStream iterate(final int seed, final IntPredicate hasNext, final IntUnaryOperator f) { N.checkArgNotNull(hasNext); N.checkArgNotNull(f); return new IteratorIntStream(new IntIteratorEx() { private int t = 0; private int cur = 0; private boolean isFirst = true; private boolean hasMore = true; private boolean hasNextVal = false; @Override public boolean hasNext() { if (hasNextVal == false && hasMore) { if (isFirst) { isFirst = false; hasNextVal = hasNext.test(cur = seed); } else { hasNextVal = hasNext.test(cur = f.applyAsInt(t)); } if (hasNextVal == false) { hasMore = false; } } return hasNextVal; } @Override public int nextInt() { if (hasNextVal == false && hasNext() == false) { throw new NoSuchElementException(); } t = cur; hasNextVal = false; return t; } }); } public static IntStream iterate(final int seed, final IntUnaryOperator f) { N.checkArgNotNull(f); return new IteratorIntStream(new IntIteratorEx() { private int t = 0; private boolean isFirst = true; @Override public boolean hasNext() { return true; } @Override public int nextInt() { if (isFirst) { isFirst = false; t = seed; } else { t = f.applyAsInt(t); } return t; } }); } public static IntStream generate(final IntSupplier s) { N.checkArgNotNull(s); return new IteratorIntStream(new IntIteratorEx() { @Override public boolean hasNext() { return true; } @Override public int nextInt() { return s.getAsInt(); } }); } @SafeVarargs public static IntStream concat(final int[]... a) { return N.isNullOrEmpty(a) ? empty() : new IteratorIntStream(new IntIteratorEx() { private final Iterator iter = N.asList(a).iterator(); private IntIterator cur; @Override public boolean hasNext() { while ((cur == null || cur.hasNext() == false) && iter.hasNext()) { cur = IntIteratorEx.of(iter.next()); } return cur != null && cur.hasNext(); } @Override public int nextInt() { if ((cur == null || cur.hasNext() == false) && hasNext() == false) { throw new NoSuchElementException(); } return cur.nextInt(); } }); } @SafeVarargs public static IntStream concat(final IntIterator... a) { return N.isNullOrEmpty(a) ? empty() : new IteratorIntStream(new IntIteratorEx() { private final Iterator iter = N.asList(a).iterator(); private IntIterator cur; @Override public boolean hasNext() { while ((cur == null || cur.hasNext() == false) && iter.hasNext()) { cur = iter.next(); } return cur != null && cur.hasNext(); } @Override public int nextInt() { if ((cur == null || cur.hasNext() == false) && hasNext() == false) { throw new NoSuchElementException(); } return cur.nextInt(); } }); } @SafeVarargs public static IntStream concat(final IntStream... a) { return N.isNullOrEmpty(a) ? empty() : concat(N.asList(a)); } public static IntStream concat(final Collection c) { return N.isNullOrEmpty(c) ? empty() : new IteratorIntStream(new IntIteratorEx() { private final Iterator iter = c.iterator(); private IntIterator cur; @Override public boolean hasNext() { while ((cur == null || cur.hasNext() == false) && iter.hasNext()) { cur = iter.next().iteratorEx(); } return cur != null && cur.hasNext(); } @Override public int nextInt() { if ((cur == null || cur.hasNext() == false) && hasNext() == false) { throw new NoSuchElementException(); } return cur.nextInt(); } }).onClose(newCloseHandler(c)); } /** * Zip together the "a" and "b" arrays until one of them runs out of values. * Each pair of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @return */ public static IntStream zip(final int[] a, final int[] b, final IntBiFunction zipFunction) { return Stream.zip(a, b, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a", "b" and "c" arrays until one of them runs out of values. * Each triple of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @return */ public static IntStream zip(final int[] a, final int[] b, final int[] c, final IntTriFunction zipFunction) { return Stream.zip(a, b, c, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a" and "b" iterators until one of them runs out of values. * Each pair of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @return */ public static IntStream zip(final IntIterator a, final IntIterator b, final IntBiFunction zipFunction) { return Stream.zip(a, b, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a", "b" and "c" iterators until one of them runs out of values. * Each triple of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @return */ public static IntStream zip(final IntIterator a, final IntIterator b, final IntIterator c, final IntTriFunction zipFunction) { return Stream.zip(a, b, c, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a" and "b" streams until one of them runs out of values. * Each pair of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @return */ public static IntStream zip(final IntStream a, final IntStream b, final IntBiFunction zipFunction) { return Stream.zip(a, b, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a", "b" and "c" streams until one of them runs out of values. * Each triple of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @return */ public static IntStream zip(final IntStream a, final IntStream b, final IntStream c, final IntTriFunction zipFunction) { return Stream.zip(a, b, c, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the iterators until one of them runs out of values. * Each array of values is combined into a single value using the supplied zipFunction function. * * @param c * @param zipFunction * @return */ public static IntStream zip(final Collection c, final IntNFunction zipFunction) { return Stream.zip(c, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a" and "b" iterators until all of them runs out of values. * Each pair of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @param valueForNoneA value to fill if "a" runs out of values first. * @param valueForNoneB value to fill if "b" runs out of values first. * @param zipFunction * @return */ public static IntStream zip(final int[] a, final int[] b, final int valueForNoneA, final int valueForNoneB, final IntBiFunction zipFunction) { return Stream.zip(a, b, valueForNoneA, valueForNoneB, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a", "b" and "c" iterators until all of them runs out of values. * Each triple of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @param c * @param valueForNoneA value to fill if "a" runs out of values. * @param valueForNoneB value to fill if "b" runs out of values. * @param valueForNoneC value to fill if "c" runs out of values. * @param zipFunction * @return */ public static IntStream zip(final int[] a, final int[] b, final int[] c, final int valueForNoneA, final int valueForNoneB, final int valueForNoneC, final IntTriFunction zipFunction) { return Stream.zip(a, b, c, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a" and "b" iterators until all of them runs out of values. * Each pair of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @param valueForNoneA value to fill if "a" runs out of values first. * @param valueForNoneB value to fill if "b" runs out of values first. * @param zipFunction * @return */ public static IntStream zip(final IntIterator a, final IntIterator b, final int valueForNoneA, final int valueForNoneB, final IntBiFunction zipFunction) { return Stream.zip(a, b, valueForNoneA, valueForNoneB, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a", "b" and "c" iterators until all of them runs out of values. * Each triple of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @param c * @param valueForNoneA value to fill if "a" runs out of values. * @param valueForNoneB value to fill if "b" runs out of values. * @param valueForNoneC value to fill if "c" runs out of values. * @param zipFunction * @return */ public static IntStream zip(final IntIterator a, final IntIterator b, final IntIterator c, final int valueForNoneA, final int valueForNoneB, final int valueForNoneC, final IntTriFunction zipFunction) { return Stream.zip(a, b, c, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a" and "b" iterators until all of them runs out of values. * Each pair of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @param valueForNoneA value to fill if "a" runs out of values first. * @param valueForNoneB value to fill if "b" runs out of values first. * @param zipFunction * @return */ public static IntStream zip(final IntStream a, final IntStream b, final int valueForNoneA, final int valueForNoneB, final IntBiFunction zipFunction) { return Stream.zip(a, b, valueForNoneA, valueForNoneB, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the "a", "b" and "c" iterators until all of them runs out of values. * Each triple of values is combined into a single value using the supplied zipFunction function. * * @param a * @param b * @param c * @param valueForNoneA value to fill if "a" runs out of values. * @param valueForNoneB value to fill if "b" runs out of values. * @param valueForNoneC value to fill if "c" runs out of values. * @param zipFunction * @return */ public static IntStream zip(final IntStream a, final IntStream b, final IntStream c, final int valueForNoneA, final int valueForNoneB, final int valueForNoneC, final IntTriFunction zipFunction) { return Stream.zip(a, b, c, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * Zip together the iterators until all of them runs out of values. * Each array of values is combined into a single value using the supplied zipFunction function. * * @param c * @param valuesForNone value to fill for any iterator runs out of values. * @param zipFunction * @return */ public static IntStream zip(final Collection c, final int[] valuesForNone, final IntNFunction zipFunction) { return Stream.zip(c, valuesForNone, zipFunction).mapToInt(ToIntFunction.UNBOX); } /** * * @param a * @param b * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected. * @return */ public static IntStream merge(final int[] a, final int[] b, final IntBiFunction nextSelector) { if (N.isNullOrEmpty(a)) { return of(b); } else if (N.isNullOrEmpty(b)) { return of(a); } return new IteratorIntStream(new IntIteratorEx() { private final int lenA = a.length; private final int lenB = b.length; private int cursorA = 0; private int cursorB = 0; @Override public boolean hasNext() { return cursorA < lenA || cursorB < lenB; } @Override public int nextInt() { if (cursorA < lenA) { if (cursorB < lenB) { if (nextSelector.apply(a[cursorA], b[cursorB]) == Nth.FIRST) { return a[cursorA++]; } else { return b[cursorB++]; } } else { return a[cursorA++]; } } else if (cursorB < lenB) { return b[cursorB++]; } else { throw new NoSuchElementException(); } } }); } /** * * @param a * @param b * @param c * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected. * @return */ public static IntStream merge(final int[] a, final int[] b, final int[] c, final IntBiFunction nextSelector) { return merge(merge(a, b, nextSelector).iteratorEx(), IntStream.of(c).iteratorEx(), nextSelector); } /** * * @param a * @param b * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected. * @return */ public static IntStream merge(final IntIterator a, final IntIterator b, final IntBiFunction nextSelector) { if (a.hasNext() == false) { return of(b); } else if (b.hasNext() == false) { return of(a); } return new IteratorIntStream(new IntIteratorEx() { private int nextA = 0; private int nextB = 0; private boolean hasNextA = false; private boolean hasNextB = false; @Override public boolean hasNext() { return a.hasNext() || b.hasNext() || hasNextA || hasNextB; } @Override public int nextInt() { if (hasNextA) { if (b.hasNext()) { if (nextSelector.apply(nextA, (nextB = b.nextInt())) == Nth.FIRST) { hasNextA = false; hasNextB = true; return nextA; } else { return nextB; } } else { hasNextA = false; return nextA; } } else if (hasNextB) { if (a.hasNext()) { if (nextSelector.apply((nextA = a.nextInt()), nextB) == Nth.FIRST) { return nextA; } else { hasNextA = true; hasNextB = false; return nextB; } } else { hasNextB = false; return nextB; } } else if (a.hasNext()) { if (b.hasNext()) { if (nextSelector.apply((nextA = a.nextInt()), (nextB = b.nextInt())) == Nth.FIRST) { hasNextB = true; return nextA; } else { hasNextA = true; return nextB; } } else { return a.nextInt(); } } else if (b.hasNext()) { return b.nextInt(); } else { throw new NoSuchElementException(); } } }); } /** * * @param a * @param b * @param c * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected. * @return */ public static IntStream merge(final IntIterator a, final IntIterator b, final IntIterator c, final IntBiFunction nextSelector) { return merge(merge(a, b, nextSelector).iteratorEx(), c, nextSelector); } /** * * @param a * @param b * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected. * @return */ public static IntStream merge(final IntStream a, final IntStream b, final IntBiFunction nextSelector) { return merge(a.iteratorEx(), b.iteratorEx(), nextSelector).onClose(newCloseHandler(N.asList(a, b))); } /** * * @param a * @param b * @param c * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected. * @return */ public static IntStream merge(final IntStream a, final IntStream b, final IntStream c, final IntBiFunction nextSelector) { return merge(N.asList(a, b, c), nextSelector); } /** * * @param c * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected. * @return */ public static IntStream merge(final Collection c, final IntBiFunction nextSelector) { if (N.isNullOrEmpty(c)) { return empty(); } else if (c.size() == 1) { return c.iterator().next(); } else if (c.size() == 2) { final Iterator iter = c.iterator(); return merge(iter.next(), iter.next(), nextSelector); } final Iterator iter = c.iterator(); IntStream result = merge(iter.next().iteratorEx(), iter.next().iteratorEx(), nextSelector); while (iter.hasNext()) { result = merge(result.iteratorEx(), iter.next().iteratorEx(), nextSelector); } return result.onClose(newCloseHandler(c)); } /** * * @param c * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected. * @return */ public static IntStream parallelMerge(final Collection c, final IntBiFunction nextSelector) { return parallelMerge(c, nextSelector, DEFAULT_MAX_THREAD_NUM); } /** * * @param c * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected. * @param maxThreadNum * @return */ public static IntStream parallelMerge(final Collection c, final IntBiFunction nextSelector, final int maxThreadNum) { checkMaxThreadNum(maxThreadNum); if (N.isNullOrEmpty(c)) { return empty(); } else if (c.size() == 1) { return c.iterator().next(); } else if (c.size() == 2) { final Iterator iter = c.iterator(); return merge(iter.next(), iter.next(), nextSelector); } else if (maxThreadNum <= 1) { return merge(c, nextSelector); } final Queue queue = N.newLinkedList(); for (IntStream e : c) { queue.add(e.iteratorEx()); } final Holder eHolder = new Holder<>(); final MutableInt cnt = MutableInt.of(c.size()); final List> futureList = new ArrayList<>(c.size() - 1); for (int i = 0, n = N.min(maxThreadNum, c.size() / 2 + 1); i < n; i++) { futureList.add(DEFAULT_ASYNC_EXECUTOR.execute(new Try.Runnable() { @Override public void run() { IntIterator a = null; IntIterator b = null; IntIterator c = null; try { while (eHolder.value() == null) { synchronized (queue) { if (cnt.intValue() > 2 && queue.size() > 1) { a = queue.poll(); b = queue.poll(); cnt.decrement(); } else { break; } } c = IntIteratorEx.of(merge(a, b, nextSelector).toArray()); synchronized (queue) { queue.offer(c); } } } catch (Exception e) { setError(eHolder, e); } } })); } complete(futureList, eHolder); // Should never happen. if (queue.size() != 2) { throw new AbacusException("Unknown error happened."); } return merge(queue.poll(), queue.poll(), nextSelector).onClose(newCloseHandler(c)); } public static abstract class IntStreamEx extends IntStream { private IntStreamEx(boolean sorted, Collection closeHandlers) { super(sorted, closeHandlers); // Factory class. } } }





© 2015 - 2025 Weber Informatics LLC | Privacy Policy