• Home
• com.landawn
• abacus-common
• 3.10.20
• source code
• Stream.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

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

/*
 * Copyright (C) 2016, 2017, 2018, 2019 HaiYang Li
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package com.landawn.abacus.util.stream;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.security.SecureRandom;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Deque;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.BinaryOperator;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;
import java.util.function.Function;
import java.util.function.IntConsumer;
import java.util.function.IntFunction;
import java.util.function.LongConsumer;
import java.util.function.LongFunction;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.UnaryOperator;
import java.util.stream.Collector;

import com.landawn.abacus.annotation.Beta;
import com.landawn.abacus.annotation.IntermediateOp;
import com.landawn.abacus.annotation.LazyEvaluation;
import com.landawn.abacus.annotation.ParallelSupported;
import com.landawn.abacus.annotation.SequentialOnly;
import com.landawn.abacus.annotation.TerminalOp;
import com.landawn.abacus.annotation.TerminalOpTriggered;
import com.landawn.abacus.exception.UncheckedIOException;
import com.landawn.abacus.util.Array;
import com.landawn.abacus.util.AsyncExecutor;
import com.landawn.abacus.util.ByteIterator;
import com.landawn.abacus.util.CharIterator;
import com.landawn.abacus.util.CheckedStream;
import com.landawn.abacus.util.ClassUtil;
import com.landawn.abacus.util.Comparators;
import com.landawn.abacus.util.ContinuableFuture;
import com.landawn.abacus.util.DataSet;
import com.landawn.abacus.util.DoubleIterator;
import com.landawn.abacus.util.Duration;
import com.landawn.abacus.util.FloatIterator;
import com.landawn.abacus.util.Fn;
import com.landawn.abacus.util.Fn.Suppliers;
import com.landawn.abacus.util.Holder;
import com.landawn.abacus.util.IOUtil;
import com.landawn.abacus.util.ImmutableMap;
import com.landawn.abacus.util.Indexed;
import com.landawn.abacus.util.IntIterator;
import com.landawn.abacus.util.Iterators;
import com.landawn.abacus.util.Joiner;
import com.landawn.abacus.util.Keyed;
import com.landawn.abacus.util.LineIterator;
import com.landawn.abacus.util.ListMultimap;
import com.landawn.abacus.util.LongIterator;
import com.landawn.abacus.util.MergeResult;
import com.landawn.abacus.util.Multimap;
import com.landawn.abacus.util.MutableBoolean;
import com.landawn.abacus.util.MutableInt;
import com.landawn.abacus.util.MutableLong;
import com.landawn.abacus.util.N;
import com.landawn.abacus.util.NoCachingNoUpdating;
import com.landawn.abacus.util.NoCachingNoUpdating.DisposableEntry;
import com.landawn.abacus.util.ObjIterator;
import com.landawn.abacus.util.Pair;
import com.landawn.abacus.util.Percentage;
import com.landawn.abacus.util.RateLimiter;
import com.landawn.abacus.util.ShortIterator;
import com.landawn.abacus.util.Splitter;
import com.landawn.abacus.util.Throwables;
import com.landawn.abacus.util.u.Optional;
import com.landawn.abacus.util.u.OptionalDouble;
import com.landawn.abacus.util.u.OptionalInt;
import com.landawn.abacus.util.u.OptionalLong;
import com.landawn.abacus.util.function.ByteBiFunction;
import com.landawn.abacus.util.function.ByteNFunction;
import com.landawn.abacus.util.function.ByteTriFunction;
import com.landawn.abacus.util.function.CharBiFunction;
import com.landawn.abacus.util.function.CharNFunction;
import com.landawn.abacus.util.function.CharTriFunction;
import com.landawn.abacus.util.function.DoubleBiFunction;
import com.landawn.abacus.util.function.DoubleNFunction;
import com.landawn.abacus.util.function.DoubleTriFunction;
import com.landawn.abacus.util.function.FloatBiFunction;
import com.landawn.abacus.util.function.FloatNFunction;
import com.landawn.abacus.util.function.FloatTriFunction;
import com.landawn.abacus.util.function.IntBiFunction;
import com.landawn.abacus.util.function.IntNFunction;
import com.landawn.abacus.util.function.IntTriFunction;
import com.landawn.abacus.util.function.LongBiFunction;
import com.landawn.abacus.util.function.LongNFunction;
import com.landawn.abacus.util.function.LongTriFunction;
import com.landawn.abacus.util.function.ShortBiFunction;
import com.landawn.abacus.util.function.ShortNFunction;
import com.landawn.abacus.util.function.ShortTriFunction;
import com.landawn.abacus.util.function.ToByteFunction;
import com.landawn.abacus.util.function.ToCharFunction;
import com.landawn.abacus.util.function.ToFloatFunction;
import com.landawn.abacus.util.function.ToShortFunction;
import com.landawn.abacus.util.function.TriFunction;
import com.landawn.abacus.util.function.TriPredicate;
import com.landawn.abacus.util.stream.ObjIteratorEx.BufferedIterator;

/**
 * Note: This class includes codes copied from StreamEx: https://github.com/amaembo/streamex under Apache License, version 2.0.
 * 

 *
 * The Stream will be automatically closed after execution(A terminal method is executed/triggered).
 *
 * @param  the type of the stream elements
 * @see BaseStream
 * @see IntStream
 * @see LongStream
 * @see DoubleStream
 * @see EntryStream
 * @see com.landawn.abacus.util.CheckedStream
 * @see Collectors
 * @see com.landawn.abacus.util.Fn
 * @see com.landawn.abacus.util.Comparators
 */
@com.landawn.abacus.annotation.Immutable
@LazyEvaluation
@SuppressWarnings({ "java:S1192", "java:S1845" })
public abstract class Stream
        extends StreamBase, Consumer, List, Optional, Indexed, ObjIterator, Stream> {

    static final Random RAND = new SecureRandom();

    Stream(final boolean sorted, final Comparator cmp, final Collection closeHandlers) {
        super(sorted, cmp, closeHandlers);
    }

    /**
     * Select the elements belong to the specified {@code targetType}(including its subtype).
     *
     * @param 
     * @param targetType
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public  Stream select(final Class targetType) {
        if (isParallel()) {
            return (Stream) sequential().filter(Fn.instanceOf(targetType))
                    .parallel(maxThreadNum(), executorNumForVirtualThread(), splitor(), asyncExecutor(), cancelUncompletedThreads());
        } else {
            return (Stream) filter(Fn.instanceOf(targetType));
        }
    }

    /**
     *
     * @param predicate
     * @return
     */
    @SequentialOnly
    @Beta
    @IntermediateOp
    @Override
    public Stream skipUntil(final Predicate predicate) {
        return dropWhile(Fn.not(predicate));
    }

    /**
     *
     *
     * @param 
     * @param extractor
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public  Stream> pairWith(final Function extractor) {
        return map(t -> Pair.of(t, extractor.apply(t)));
    }

    /**
     *
     *
     * @param 
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream map(final Function mapper);

    /**
     * Convert the element to a new value if it's not {@code null}, otherwise skip it.
     *
     * @param 
     * @param mapper
     * @return
     * @implSpec Same as {@code skipNulls().map(mapper)}.
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public  Stream mapIfNotNul(final Function mapper) {
        return skipNulls().map(mapper);
    }

    /**
     *
     *
     * @param 
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream slidingMap(BiFunction mapper);

    /**
     * Slide with windowSize = 2 and the specified increment, then map by the specified mapper.
     *
     * @param 
     * @param increment
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream slidingMap(int increment, BiFunction mapper);

    /**
     *
     *
     * @param 
     * @param increment
     * @param ignoreNotPaired
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream slidingMap(int increment, boolean ignoreNotPaired, BiFunction mapper);

    /**
     *
     *
     * @param 
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream slidingMap(TriFunction mapper);

    /**
     * Slide with windowSize = 3 and the specified increment, then map by the specified mapper.
     *
     * @param 
     * @param increment
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream slidingMap(int increment, TriFunction mapper);

    /**
     *
     *
     * @param 
     * @param increment
     * @param ignoreNotPaired
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream slidingMap(int increment, boolean ignoreNotPaired, TriFunction mapper);

    /**
     * Note: copied from StreamEx: https://github.com/amaembo/streamex
     *
     * 

     *
     * Returns a stream consisting of results of applying the given function to
     * the ranges created from the source elements.
     *
     * 
     * 
     * Stream.of("a", "ab", "ac", "b", "c", "cb").rangeMap((a, b) -> b.startsWith(a), (a, b) -> a + "->" + b).toList(); // a->ac, b->b, c->cb
     * 
     * 
     *
     * 

     * This is a quasi-intermediate
     * partial reduction operation.
     *
     * @param  the type of the resulting elements
     * @param sameRange a non-interfering, stateless predicate to apply to
     *        the leftmost and next elements which returns true for elements
     *        which belong to the same range.
     * @param mapper a non-interfering, stateless function to apply to the
     *        range borders and produce the resulting element. If value was
     *        not merged to the interval, then mapper will receive the same
     *        value twice, otherwise it will receive the leftmost and the
     *        rightmost values which were merged to the range.
     * @return
     * @see #collapse(BiPredicate, BiFunction)
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream rangeMap(final BiPredicate sameRange, final BiFunction mapper);

    /**
     *
     *
     * @param mapperForFirst
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream mapFirst(Function mapperForFirst);

    /**
     *
     *
     * @param 
     * @param mapperForFirst
     * @param mapperForElse
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream mapFirstOrElse(Function mapperForFirst, Function mapperForElse);

    /**
     *
     *
     * @param mapperForLast
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream mapLast(Function mapperForLast);

    /**
     *
     *
     * @param 
     * @param mapperForLast
     * @param mapperForElse
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream mapLastOrElse(Function mapperForLast, Function mapperForElse);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract CharStream mapToChar(ToCharFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract ByteStream mapToByte(ToByteFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract ShortStream mapToShort(ToShortFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract IntStream mapToInt(ToIntFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract LongStream mapToLong(ToLongFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract FloatStream mapToFloat(ToFloatFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract DoubleStream mapToDouble(ToDoubleFunction mapper);

    // public abstract  EntryStream mapToEntry();

    /**
     *
     *
     * @param 
     * @param 
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  EntryStream mapToEntry(Function> mapper);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  EntryStream mapToEntry(Function keyMapper, Function valueMapper);

    // public abstract  Stream mapp(Function> mapper);

    /**
     *
     *
     * @param 
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream flatMap(Function> mapper);

    /**
     *
     *
     * @param 
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream flatmap(Function> mapper);

    /**
     *
     *
     * @param 
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream flattMap(Function mapper);

    /**
     *
     *
     * @param 
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream flattmap(Function> mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract CharStream flatMapToChar(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract CharStream flatmapToChar(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract ByteStream flatMapToByte(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract ByteStream flatmapToByte(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract ShortStream flatMapToShort(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract ShortStream flatmapToShort(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract IntStream flatMapToInt(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract IntStream flatmapToInt(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract LongStream flatMapToLong(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract LongStream flatmapToLong(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract FloatStream flatMapToFloat(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract FloatStream flatmapToFloat(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract DoubleStream flatMapToDouble(Function mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract DoubleStream flatmapToDouble(Function mapper);

    /**
     *
     *
     * @param 
     * @param 
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  EntryStream flatMapToEntry(Function>> mapper);

    /**
     *
     *
     * @param 
     * @param 
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  EntryStream flatmapToEntry(Function> mapper);

    /**
     *
     *
     * @param 
     * @param 
     * @param mapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  EntryStream flattMapToEntry(Function> mapper); //NOSONAR

    /**
     *
     *
     * @param 
     * @param mapper
     * @return
     * @implNote same as ====>
     * 
     * skipNulls().flatmap(mapper)
     * 

     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public  Stream flatMapIfNotNull(Function> mapper) {
        return skipNulls().flatmap(mapper);
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param mapper
     * @param mapper2
     * @return
     * @implNote same as ====>
     * 
     * skipNulls().flatmap(mapper).skipNulls().flatmap(mapper2)
     * 
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public  Stream flatMapIfNotNull(Function> mapper,
            Function> mapper2) {
        return skipNulls().flatmap(mapper).skipNulls().flatmap(mapper2);
    }

    /**
     *
     *
     * @param 
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream mapMulti(BiConsumer> mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract IntStream mapMultiToInt(BiConsumer mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract LongStream mapMultiToLong(BiConsumer mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract DoubleStream mapMultiToDouble(BiConsumer mapper);

    /**
     * Note: copied from StreamEx: https://github.com/amaembo/streamex
     *
     * @param 
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream mapPartial(Function> mapper);

    /**
     * Note: copied from StreamEx: https://github.com/amaembo/streamex
     *
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract IntStream mapPartialToInt(Function mapper);

    /**
     * Note: copied from StreamEx: https://github.com/amaembo/streamex
     *
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract LongStream mapPartialToLong(Function mapper);

    /**
     * Note: copied from StreamEx: https://github.com/amaembo/streamex
     *
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract DoubleStream mapPartialToDouble(Function mapper);

    /**
     * Note: copied from StreamEx: https://github.com/amaembo/streamex
     *
     * @param 
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream mapPartialJdk(Function> mapper);

    /**
     * Note: copied from StreamEx: https://github.com/amaembo/streamex
     *
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract IntStream mapPartialToIntJdk(Function mapper);

    /**
     * Note: copied from StreamEx: https://github.com/amaembo/streamex
     *
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract LongStream mapPartialToLongJdk(Function mapper);

    /**
     * Note: copied from StreamEx: https://github.com/amaembo/streamex
     *
     * @param mapper
     * @return
     */
    @Beta
    @ParallelSupported
    @IntermediateOp
    public abstract DoubleStream mapPartialToDoubleJdk(Function mapper);

    /**
     *
     *
     * @param 
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream>> groupBy(final Function keyMapper);

    /**
     *
     *
     * @param 
     * @param keyMapper
     * @param mapFactory
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream>> groupBy(final Function keyMapper,
            final Supplier>> mapFactory);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @return
     * @see Collectors#toMultimap(Function, Function)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream>> groupBy(Function keyMapper, Function valueMapper);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mapFactory
     * @return
     * @see Collectors#toMultimap(Function, Function, Supplier)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream>> groupBy(Function keyMapper, Function valueMapper,
            Supplier>> mapFactory);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param downstream
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream> groupBy(final Function keyMapper, final Collector downstream);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param downstream
     * @param mapFactory
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream> groupBy(final Function keyMapper, final Collector downstream,
            final Supplier> mapFactory);

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param downstream
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream> groupBy(final Function keyMapper,
            final Function valueMapper, final Collector downstream);

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param downstream
     * @param mapFactory
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream> groupBy(final Function keyMapper,
            final Function valueMapper, final Collector downstream, final Supplier> mapFactory);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mergeFunction
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream> groupBy(final Function keyMapper, final Function valueMapper,
            BinaryOperator mergeFunction);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mergeFunction
     * @param mapFactory
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream> groupBy(final Function keyMapper, final Function valueMapper,
            final BinaryOperator mergeFunction, final Supplier> mapFactory);

    //    @ParallelSupported
    //    public abstract  Stream>> flatGroupBy(final Throwables.Function, E> flatKeyMapper);
    //
    //    @ParallelSupported
    //    public abstract  Stream>> flatGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Supplier>> mapFactory);
    //
    //    /**
    //     *
    //     * @param flatKeyMapper
    //     * @param valueMapper
    //     * @return
    //     * @see Collectors#toMultimap(Function, Function)
    //     */
    //    @ParallelSupported
    //    public abstract  Stream>> flatGroupBy(Throwables.Function, E> flatKeyMapper,
    //            Throwables.BiFunction valueMapper);
    //
    //    /**
    //     *
    //     * @param flatKeyMapper
    //     * @param valueMapper
    //     * @param mapFactory
    //     * @return
    //     * @see Collectors#toMultimap(Function, Function, Supplier)
    //     */
    //    @ParallelSupported
    //    public abstract  Stream>> flatGroupBy(Throwables.Function, E> flatKeyMapper,
    //            Throwables.BiFunction valueMapper, Supplier>> mapFactory);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flatGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Collector downstream);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flatGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Collector downstream, final Supplier> mapFactory);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flatGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Throwables.BiFunction valueMapper, final Collector downstream);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flatGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Throwables.BiFunction valueMapper, final Collector downstream,
    //            final Supplier> mapFactory);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flatGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Throwables.BiFunction valueMapper, BinaryOperator mergeFunction);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flatGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Throwables.BiFunction valueMapper, final BinaryOperator mergeFunction,
    //            final Supplier> mapFactory);
    //
    //    @ParallelSupported
    //    public abstract  Stream>> flattGroupBy(final Throwables.Function, E> flatKeyMapper);
    //
    //    @ParallelSupported
    //    public abstract  Stream>> flattGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Supplier>> mapFactory);
    //
    //    /**
    //     *
    //     * @param flatKeyMapper
    //     * @param valueMapper
    //     * @return
    //     * @see Collectors#toMultimap(Function, Function)
    //     */
    //    @ParallelSupported
    //    public abstract  Stream>> flattGroupBy(Throwables.Function, E> flatKeyMapper,
    //            Throwables.BiFunction valueMapper);
    //
    //    /**
    //     *
    //     * @param flatKeyMapper
    //     * @param valueMapper
    //     * @param mapFactory
    //     * @return
    //     * @see Collectors#toMultimap(Function, Function, Supplier)
    //     */
    //    @ParallelSupported
    //    public abstract  Stream>> flattGroupBy(Throwables.Function, E> flatKeyMapper,
    //            Throwables.BiFunction valueMapper, Supplier>> mapFactory);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flattGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Collector downstream);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flattGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Collector downstream, final Supplier> mapFactory);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flattGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Throwables.BiFunction valueMapper, final Collector downstream);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flattGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Throwables.BiFunction valueMapper, final Collector downstream,
    //            final Supplier> mapFactory);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flattGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Throwables.BiFunction valueMapper, BinaryOperator mergeFunction);
    //
    //    @ParallelSupported
    //    public abstract  Stream> flattGroupBy(final Throwables.Function, E> flatKeyMapper,
    //            final Throwables.BiFunction valueMapper, final BinaryOperator mergeFunction,
    //            final Supplier> mapFactory);

    /**
     *
     *
     * @param 
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream> groupByToEntry(final Function keyMapper);

    /**
     *
     *
     * @param 
     * @param keyMapper
     * @param mapFactory
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream> groupByToEntry(final Function keyMapper,
            final Supplier>> mapFactory);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @return
     * @see Collectors#toMultimap(Function, Function)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream> groupByToEntry(Function keyMapper, Function valueMapper);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mapFactory
     * @return
     * @see Collectors#toMultimap(Function, Function, Supplier)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream> groupByToEntry(Function keyMapper, Function valueMapper,
            Supplier>> mapFactory);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param downstream
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream groupByToEntry(final Function keyMapper, final Collector downstream);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param downstream
     * @param mapFactory
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream groupByToEntry(final Function keyMapper, final Collector downstream,
            final Supplier> mapFactory);

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param downstream
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream groupByToEntry(final Function keyMapper,
            final Function valueMapper, final Collector downstream);

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param downstream
     * @param mapFactory
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream groupByToEntry(final Function keyMapper,
            final Function valueMapper, final Collector downstream, final Supplier> mapFactory);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mergeFunction
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream groupByToEntry(final Function keyMapper,
            final Function valueMapper, BinaryOperator mergeFunction);

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mergeFunction
     * @param mapFactory
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream groupByToEntry(final Function keyMapper,
            final Function valueMapper, final BinaryOperator mergeFunction, final Supplier> mapFactory);

    /**
     *
     * @param predicate
     * @return
     * @see Collectors#partitioningBy(Predicate)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream>> partitionBy(final Predicate predicate);

    /**
     *
     *
     * @param 
     * @param predicate
     * @param downstream
     * @return
     * @see Collectors#partitioningBy(Predicate, Collector)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  Stream> partitionBy(final Predicate predicate, final Collector downstream);

    /**
     *
     * @param predicate
     * @return
     * @see Collectors#partitioningBy(Predicate)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract EntryStream> partitionByToEntry(final Predicate predicate);

    /**
     *
     *
     * @param 
     * @param predicate
     * @param downstream
     * @return
     * @see Collectors#partitioningBy(Predicate, Collector)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract  EntryStream partitionByToEntry(final Predicate predicate, final Collector downstream);

    /**
     *
     *
     * @param 
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public  Stream> countBy(final Function keyMapper) {
        return groupBy(keyMapper, Collectors.countingToInt());
    }

    /**
     *
     *
     * @param 
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public  EntryStream countByToEntry(final Function keyMapper) {
        return groupByToEntry(keyMapper, Collectors.countingToInt());
    }

    /**
     *
     * @param collapsible test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> collapse(final BiPredicate collapsible);

    /**
     *
     * @param 
     * @param collapsible test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.
     * @param supplier
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract > Stream collapse(final BiPredicate collapsible, Supplier supplier);

    /**
     * Merge series of adjacent elements which satisfy the given predicate using
     * the merger function and return a new stream.
     *
     * 
Example:
     * 
     * 
     * Stream.of(new Integer[0]).collapse((p, c) -> p < c, (r, c) -> r + c) => []
     * Stream.of(1).collapse((p, c) -> p < c, (r, c) -> r + c) => [1]
     * Stream.of(1, 2).collapse((p, c) -> p < c, (r, c) -> r + c) => [3]
     * Stream.of(1, 2, 3).collapse((p, c) -> p < c, (r, c) -> r + c) => [6]
     * Stream.of(1, 2, 3, 3, 2, 1).collapse((p, c) -> p < c, (r, c) -> r + c) => [6, 3, 2, 1]
     * 
     * 
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param collapsible test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.
     * @param mergeFunction
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream collapse(final BiPredicate collapsible, final BiFunction mergeFunction);

    /**
     *
     * @param 
     * @param collapsible test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.
     * @param init is used by {@code op} to generate the first result value in the series.
     * @param op
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream collapse(final BiPredicate collapsible, final U init, final BiFunction op);

    /**
     *
     * @param 
     * @param collapsible test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.
     * @param supplier
     * @param accumulator
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream collapse(final BiPredicate collapsible, final Supplier supplier,
            final BiConsumer accumulator);

    /**
     * Merge series of adjacent elements which satisfy the given predicate using
     * the merger function and return a new stream.
     *
     * 
Example:
     * 
     * 
     * Stream.of(new Integer[0]).collapse((p, c) -> p < c, Collectors.summingInt(Fn.unboxI())) => []
     * Stream.of(1).collapse((p, c) -> p < c, Collectors.summingInt(Fn.unboxI())) => [1]
     * Stream.of(1, 2).collapse((p, c) -> p < c, Collectors.summingInt(Fn.unboxI())) => [3]
     * Stream.of(1, 2, 3).collapse((p, c) -> p < c, Collectors.summingInt(Fn.unboxI())) => [6]
     * Stream.of(1, 2, 3, 3, 2, 1).collapse((p, c) -> p < c, Collectors.summingInt(Fn.unboxI())) => [6, 3, 2, 1]
     * 
     * 
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param 
     * @param collapsible test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.
     * @param collector
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream collapse(final BiPredicate collapsible, final Collector collector);

    /**
     *
     * @param collapsible test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.
     * @return
     */
    @Beta
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> collapse(final TriPredicate collapsible);

    /**
     *
     * @param 
     * @param collapsible test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.
     * @param supplier
     * @return
     */
    @Beta
    @SequentialOnly
    @IntermediateOp
    public abstract > Stream collapse(final TriPredicate collapsible,
            Supplier supplier);

    /**
     * Merge series of adjacent elements which satisfy the given predicate using
     * the merger function and return a new stream.
     *
     * 
Example:
     * 
     * 
     * Stream.of(new Integer[0]).collapse((f, p, c) -> f < c, (r, c) -> r + c) => []
     * Stream.of(1).collapse((f, p, c) -> f < c, (r, c) -> r + c) => [1]
     * Stream.of(1, 2).collapse((f, p, c) -> f < c, (r, c) -> r + c) => [3]
     * Stream.of(1, 2, 3).collapse((f, p, c) -> f < c, (r, c) -> r + c) => [6]
     * Stream.of(1, 2, 3, 3, 2, 1).collapse((f, p, c) -> f < c, (r, c) -> r + c) => [11, 1]
     * 
     * 
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param collapsible test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.
     * @param mergeFunction
     * @return
     */
    @Beta
    @SequentialOnly
    @IntermediateOp
    public abstract Stream collapse(final TriPredicate collapsible,
            final BiFunction mergeFunction);

    /**
     *
     * @param 
     * @param collapsible test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.
     * @param init is used by {@code op} to generate the first result value in the series.
     * @param op
     * @return
     */
    @Beta
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream collapse(final TriPredicate collapsible, final U init, final BiFunction op);

    /**
     *
     * @param 
     * @param collapsible test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.
     * @param supplier
     * @param accumulator
     * @return
     */
    @Beta
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream collapse(final TriPredicate collapsible, final Supplier supplier,
            final BiConsumer accumulator);

    /**
     * Merge series of adjacent elements which satisfy the given predicate using
     * the merger function and return a new stream.
     *
     * 
Example:
     * 
     * 
     * Stream.of(new Integer[0]).collapse((f, p, c) -> f < c, Collectors.summingInt(Fn.unboxI())) => []
     * Stream.of(1).collapse((f, p, c) -> f < c, Collectors.summingInt(Fn.unboxI())) => [1]
     * Stream.of(1, 2).collapse((f, p, c) -> f < c, Collectors.summingInt(Fn.unboxI())) => [3]
     * Stream.of(1, 2, 3).collapse((f, p, c) -> f < c, Collectors.summingInt(Fn.unboxI())) => [6]
     * Stream.of(1, 2, 3, 3, 2, 1).collapse((f, p, c) -> f < c, Collectors.summingInt(Fn.unboxI())) => [11, 1]
     * 
     * 
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param 
     * @param collapsible test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.
     * @param collector
     * @return
     */
    @Beta
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream collapse(final TriPredicate collapsible, final Collector collector);

    /**
     * Returns a {@code Stream} produced by iterative application of a accumulation function
     * to an initial element {@code init} and next element of the current stream.
     * Produces a {@code Stream} consisting of {@code init}, {@code acc(init, value1)},
     * {@code acc(acc(init, value1), value2)}, etc.
     *
     * 
This is an intermediate operation.
     *
     * 
Example:
     * 
     * 
     * Stream.of(new Integer[0]).scan((r, c) -> r + c) => []
     * Stream.of(1).scan((r, c) -> r + c) => [1]
     * Stream.of(1, 2).scan((r, c) -> r + c) => [1, 3]
     * Stream.of(1, 2, 3).scan((r, c) -> r + c) => [1, 3, 6]
     * Stream.of(1, 2, 3, 3, 2, 1).scan((r, c) -> r + c) => [1, 3, 6, 9, 11, 12]
     * 
     * 
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param accumulator the accumulation function
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream scan(final BiFunction accumulator);

    /**
     * Returns a {@code Stream} produced by iterative application of a accumulation function
     * to an initial element {@code init} and next element of the current stream.
     * Produces a {@code Stream} consisting of {@code init}, {@code acc(init, value1)},
     * {@code acc(acc(init, value1), value2)}, etc.
     *
     * 
This is an intermediate operation.
     *
     * 
Example:
     * 
     * 
     * Stream.of(new Integer[0]).scan(10, (r, c) -> r + c) => []
     * Stream.of(1).scan(10, (r, c) -> r + c) => [11]
     * Stream.of(1, 2).scan(10, (r, c) -> r + c) => [11, 13]
     * Stream.of(1, 2, 3).scan(10, (r, c) -> r + c) => [11, 13, 16]
     * Stream.of(1, 2, 3, 3, 2, 1).scan(10, (r, c) -> r + c) => [11, 13, 16, 19, 21, 22]
     * 
     * 
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param 
     * @param init 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
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream scan(final U init, final BiFunction accumulator);

    /**
     *
     *
     * @param 
     * @param init
     * @param accumulator
     * @param initIncluded
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream scan(final U init, final BiFunction accumulator, final boolean initIncluded);

    //    @SequentialOnly
    //    @IntermediateOp
    //    public  Stream scanInclusive(final U init, final BiFunction accumulator) {
    //        return scan(init, accumulator, true);
    //    }

    /**
     * Returns Stream of Stream with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param chunkSize the desired size of each sub sequence (the last may be smaller).
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> splitToSet(int chunkSize);

    /**
     * Returns Stream of Stream with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param 
     * @param chunkSize the desired size of each sub sequence (the last may be smaller).
     * @param collectionSupplier
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract > Stream split(int chunkSize, IntFunction collectionSupplier);

    /**
     *
     *
     * @param 
     * @param chunkSize the desired size of each sub sequence (the last may be smaller).
     * @param collector
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream split(int chunkSize, Collector collector);

    /**
     *
     *
     * @param predicate
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> splitToSet(Predicate predicate);

    /**
     *
     *
     * @param 
     * @param predicate
     * @param collectionSupplier
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract > Stream split(Predicate predicate, Supplier collectionSupplier);

    /**
     *
     *
     * @param 
     * @param predicate
     * @param collector
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream split(Predicate predicate, Collector collector);

    /**
     * Split the stream into two pieces at where turns to {@code false}.
     * The first piece will be loaded into memory.
     *
     * @param 
     * @param where
     * @param collector
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream splitAt(int where, Collector collector);

    /**
     * Split the stream into two pieces at where turns to {@code false}.
     * The first piece will be loaded into memory.
     *
     * @param 
     * @param where
     * @param collector
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream splitAt(Predicate where, Collector collector);

    /**
     *
     * @param windowSize
     * @return
     * @see #sliding(int, int)
     */
    @SequentialOnly
    @IntermediateOp
    public Stream> slidingToSet(int windowSize) {
        return slidingToSet(windowSize, 1);
    }

    /**
     *
     * @param windowSize
     * @param increment
     * @return
     * @see #sliding(int, int)
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> slidingToSet(int windowSize, int increment);

    /**
     *
     *
     * @param 
     * @param windowSize
     * @param collectionSupplier
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract > Stream sliding(int windowSize, IntFunction collectionSupplier);

    /**
     *
     *
     * @param 
     * @param windowSize
     * @param increment
     * @param collectionSupplier
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract > Stream sliding(int windowSize, int increment, IntFunction collectionSupplier);

    /**
     *
     *
     * @param 
     * @param windowSize
     * @param collector
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream sliding(int windowSize, Collector collector);

    /**
     *
     *
     * @param 
     * @param windowSize
     * @param increment
     * @param collector
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract  Stream sliding(int windowSize, int increment, Collector collector);

    /**
     * Stream.of(1).intersperse(9) --> [1]
     * Stream.of(1, 2, 3).intersperse(9) --> [1, 9, 2, 9, 3]
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param delimiter
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream intersperse(T delimiter);

    /**
     * Distinct and merge duplicated elements.
     *
     * @param mergeFunction
     * @return
     * @see #groupBy(Function, Function, BinaryOperator)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public Stream distinct(final BinaryOperator mergeFunction) {
        // ConcurrentHashMap is not required for parallel stream and it doesn't support null key.
        // final Supplier> supplier = isParallel() ? Suppliers. ofConcurrentHashMap() : Suppliers. ofLinkedHashMap();

        if (isParallel()) {
            final Supplier> supplier = Suppliers. ofMap();

            return groupBy(Fn. identity(), Fn. identity(), mergeFunction, supplier) //
                    .sequential()
                    .map(Fn.value())
                    .parallel(maxThreadNum(), executorNumForVirtualThread(), splitor(), asyncExecutor(), cancelUncompletedThreads());
        } else {
            final Supplier> supplier = Suppliers. ofLinkedHashMap();

            return groupBy(Fn. identity(), Fn. identity(), mergeFunction, supplier).map(Fn.value());
        }
    }

    /**
     * Distinct and filter by occurrences.
     *
     * @param occurrencesFilter
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    @TerminalOpTriggered
    public Stream distinct(final Predicate occurrencesFilter) {
        // ConcurrentHashMap is not required for parallel stream and it doesn't support null key.
        // final Supplier> supplier = isParallel() ? Suppliers. ofConcurrentHashMap() : Suppliers. ofLinkedHashMap();

        final Supplier> supplier = Suppliers. ofLinkedHashMap();

        if (isParallel()) {
            return newStream(sequential() //
                    .groupBy(Fn. identity(), Collectors.counting(), supplier)
                    .filter(Fn. testByValue(occurrencesFilter)) //
                    .map(Fn. key())
                    .iteratorEx(), sorted, cmp);
        } else {
            return newStream(groupBy(Fn. identity(), Collectors.counting(), supplier) //
                    .filter(Fn. testByValue(occurrencesFilter))
                    .map(Fn. key())
                    .iteratorEx(), sorted, cmp);
        }
    }

    /**
     * Distinct by the value mapped from keyMapper.
     *
     * @param keyMapper don't change value of the input parameter.
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract Stream distinctBy(Function keyMapper);

    /**
     * Distinct and merge duplicated elements.
     *
     * @param 
     * @param keyMapper
     * @param mergeFunction
     * @return
     * @see #groupBy(Function, Function, BinaryOperator)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public  Stream distinctBy(final Function keyMapper, final BinaryOperator mergeFunction) {
        // ConcurrentHashMap is not required for parallel stream and it doesn't support null key.
        // final Supplier> supplier = isParallel() ? Suppliers. ofConcurrentHashMap() : Suppliers. ofLinkedHashMap();

        if (isParallel()) {
            final Supplier> supplier = Suppliers. ofMap();

            return groupBy(keyMapper, Fn. identity(), mergeFunction, supplier) //
                    .sequential()
                    .map(Fn.value())
                    .parallel(maxThreadNum(), executorNumForVirtualThread(), splitor(), asyncExecutor(), cancelUncompletedThreads());
        } else {
            final Supplier> supplier = Suppliers. ofLinkedHashMap();

            return groupBy(keyMapper, Fn. identity(), mergeFunction, supplier).map(Fn.value());
        }
    }

    /**
     * Distinct and filter by occurrences.
     *
     * @param 
     * @param keyMapper
     * @param occurrencesFilter
     * @return
     * @see #groupBy(Function, Collector)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public  Stream distinctBy(final Function keyMapper, final Predicate, Long>> occurrencesFilter) {
        // ConcurrentHashMap is not required for parallel stream and it doesn't support null key.
        // final Supplier, Long>> supplier = isParallel() ? Suppliers., Long> ofConcurrentHashMap()
        //        : Suppliers., Long> ofLinkedHashMap();

        if (isParallel()) {
            final Supplier, Long>> supplier = Suppliers., Long> ofMap();

            return groupBy(Fn. keyed(keyMapper), Collectors.counting(), supplier) //
                    .sequential()
                    .filter(occurrencesFilter)
                    .map(Fn. kkv())
                    .parallel(maxThreadNum(), executorNumForVirtualThread(), splitor(), asyncExecutor(), cancelUncompletedThreads());
        } else {
            final Supplier, Long>> supplier = Suppliers., Long> ofLinkedHashMap();

            return groupBy(Fn. keyed(keyMapper), Collectors.counting(), supplier) //
                    .filter(occurrencesFilter)
                    .map(Fn. kkv());
        }
    }

    /**
     * Distinct and limit by {@code keyMapper}.
     *
     * @param 
     * @param keyMapper
     * @param limit
     * @return
     * @see #groupBy(Function, Collector)
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public  Stream distinctLimitBy(final Function keyMapper, final BiFunction, Integer> limit) {
        // ConcurrentHashMap is not required for parallel stream and it doesn't support null key.
        // final Supplier, Long>> supplier = isParallel() ? Suppliers., Long> ofConcurrentHashMap()
        //        : Suppliers., Long> ofLinkedHashMap();

        if (isParallel()) {
            return groupBy(keyMapper) //
                    .sequential()
                    .flatmap(it -> subList(it.getValue(), 0, limit.apply(it.getKey(), it.getValue())))
                    .parallel(maxThreadNum(), executorNumForVirtualThread(), splitor(), asyncExecutor(), cancelUncompletedThreads());
        } else {
            final Supplier>> supplier = Suppliers.> ofLinkedHashMap();

            return groupBy(keyMapper, Fn.identity(), supplier) //
                    .flatmap(it -> subList(it.getValue(), 0, limit.apply(it.getKey(), it.getValue())));
        }
    }

    /**
     *
     *
     * @param comparator
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream sorted(Comparator comparator);

    /**
     *
     *
     * @param keyMapper
     * @return
     */
    @SuppressWarnings("rawtypes")
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream sortedBy(Function keyMapper);

    /**
     *
     *
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream sortedByInt(ToIntFunction keyMapper);

    /**
     *
     *
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream sortedByLong(ToLongFunction keyMapper);

    /**
     *
     *
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream sortedByDouble(ToDoubleFunction keyMapper);

    /**
     *
     *
     * @param comparator
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream reverseSorted(Comparator comparator);

    /**
     *
     *
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream reverseSortedByInt(ToIntFunction keyMapper);

    /**
     *
     *
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream reverseSortedByLong(ToLongFunction keyMapper);

    /**
     *
     *
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream reverseSortedByDouble(ToDoubleFunction keyMapper);

    /**
     *
     *
     * @param keyMapper
     * @return
     */
    @SuppressWarnings("rawtypes")
    @ParallelSupported
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream reverseSortedBy(Function keyMapper);

    /**
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param n
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream top(int n);

    /**
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param n
     * @param comparator
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream top(int n, Comparator comparator);

    /**
     * Skip the range: [fromIndexInclusive, fromIndexInclusive].
     *
     * @param startInclusive
     * @param endExclusive
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream skipRange(int startInclusive, int endExclusive);

    //    /**
    //     *
    //     *
    //     * @return
    //     * @deprecated Use {@link #skipNulls()} instead
    //     */
    //    @Deprecated
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream skipNull();

    /**
     *
     *
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream skipNulls();

    /**
     * A queue with size up to n will be maintained to filter out the last n elements.
     * It may cause out of memory error if n is big enough.
     *
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param n
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream skipLast(int n);

    /**
     * A queue with size up to n will be maintained to filter out the last n elements.
     * It may cause out of memory error if n is big enough.
     *
     * 

     *
     * All the elements will be loaded to get the last {@code n} elements and the Stream will be closed after that, if a terminal operation is triggered.
     *
     * @param n
     * @return
     */
    @Beta
    @SequentialOnly
    @IntermediateOp
    public abstract Stream last(int n);

    /**
     *
     *
     * @param rateLimiter
     * @return
     */
    @Override
    public Stream rateLimited(final RateLimiter rateLimiter) {
        checkArgNotNull(rateLimiter, "rateLimiter");

        final Consumer action = it -> rateLimiter.acquire();

        if (isParallel()) {
            return sequential().onEach(action).parallel(maxThreadNum(), executorNumForVirtualThread(), splitor(), asyncExecutor(), cancelUncompletedThreads());
        } else {
            return onEach(action);
        }
    }

    /**
     *
     *
     * @param delay
     * @return
     */
    @Override
    public Stream delay(final Duration delay) {
        checkArgNotNull(delay, "delay");

        final long millis = delay.toMillis();

        final Consumer action = it -> N.sleepUninterruptibly(millis);

        if (isParallel()) {
            return sequential().onEach(action).parallel(maxThreadNum(), executorNumForVirtualThread(), splitor(), asyncExecutor(), cancelUncompletedThreads());
        } else {
            return onEach(action);
        }
    }

    //    // This is not frequently used method. it should not be defined as an api.
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public Stream> timed() {
    //        if (isParallel()) {
    //            return sequential().map(Timed::of).parallel(maxThreadNum(), executorNumForVirtualThread(), splitor(), asyncExecutor(), cancelUncompletedThreads());
    //        } else {
    //            return map(Timed::of);
    //        }
    //    }

    /**
     *
     *
     * @param action
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream peekFirst(Consumer action);

    /**
     *
     *
     * @param action
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream peekLast(Consumer action);

    /**
     *
     * @param predicate
     * @param action
     * @return
     */
    @Beta
    @IntermediateOp
    public Stream peekIf(final Predicate predicate, final Consumer action) {
        checkArgNotNull(predicate, "predicate");
        checkArgNotNull(action, "action");

        return peek(Fn.acceptIf(predicate, action));
    }

    /**
     *
     * @param predicate The first parameter is the element. The second parameter is the count of iterated elements, starts with 1.
     * @param action
     * @return
     */
    @Beta
    @IntermediateOp
    public Stream peekIf(final BiPredicate predicate, final Consumer action) {
        checkArgNotNull(predicate, "predicate");
        checkArgNotNull(action, "action");

        if (this.isParallel()) {
            final AtomicLong count = new AtomicLong();

            return onEach(it -> {
                if (predicate.test(it, count.incrementAndGet())) {
                    action.accept(it);
                }
            });
        } else {
            final MutableLong count = MutableLong.of(0);

            return onEach(it -> {
                if (predicate.test(it, count.incrementAndGet())) {
                    action.accept(it);
                }
            });
        }
    }

    // TODO First of all, it only works in sequential Stream, not parallel stream (and maybe not work in some other scenarios as well).
    // Secondly, these onErrorXXX methods make it more difficult and complicated to use Stream.
    // So, remove them.
    //    /**
    //     * This method should be only applied sequential {@code Stream} and whose up-streams are sequential {@code Streams} as well.
    //     * Because error happening in the operations executed by parallel stream will stop iteration on that {@Stream}, so the down-streams won't be able to continue.
    //     *
    //     * @param errorConsumer
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream onErrorContinue(Consumer errorConsumer);
    //
    //    /**
    //     * This method should be only applied sequential {@code Stream} and whose up-streams are sequential {@code Streams} as well.
    //     * Because error happening in the operations executed by parallel stream will stop iteration on that {@Stream}, so the down-streams won't be able to continue.
    //     *
    //     * @param type
    //     * @param errorConsumer
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream onErrorContinue(Class type, Consumer errorConsumer);
    //
    //    /**
    //     * This method should be only applied sequential {@code Stream} and whose up-streams are sequential {@code Streams} as well.
    //     * Because error happening in the operations executed by parallel stream will stop iteration on that {@Stream}, so the down-streams won't be able to continue.
    //     *
    //     * @param errorPredicate
    //     * @param errorConsumer
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream onErrorContinue(Predicate errorPredicate, Consumer errorConsumer);
    //
    //    /**
    //     * This method should be only applied sequential {@code Stream} and whose up-streams are sequential {@code Streams} as well.
    //     * Because error happening in the operations executed by parallel stream will stop iteration on that {@Stream}, so the down-streams won't be able to continue.
    //     *
    //     * @param errorPredicate
    //     * @param errorConsumer
    //     * @param maxErrorCountToStop
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream onErrorContinue(Predicate errorPredicate, Consumer errorConsumer, int maxErrorCountToStop);
    //
    //    /**
    //     * This method should be only applied sequential {@code Stream} and whose up-streams are sequential {@code Streams} as well.
    //     * Because error happening in the operations executed by parallel stream will stop iteration on that {@Stream}, so the down-streams won't be able to continue.
    //     *
    //     * @param fallbackValue
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream onErrorReturn(T fallbackValue);
    //
    //    /**
    //     * This method should be only applied sequential {@code Stream} and whose up-streams are sequential {@code Streams} as well.
    //     * Because error happening in the operations executed by parallel stream will stop iteration on that {@Stream}, so the down-streams won't be able to continue.
    //     *
    //     * @param type
    //     * @param fallbackValue
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream onErrorReturn(Class type, T fallbackValue);
    //
    //    /**
    //     * This method should be only applied sequential {@code Stream} and whose up-streams are sequential {@code Streams} as well.
    //     * Because error happening in the operations executed by parallel stream will stop iteration on that {@Stream}, so the down-streams won't be able to continue.
    //     *
    //     * @param predicate
    //     * @param fallbackValue
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream onErrorReturn(Predicate predicate, T fallbackValue);
    //
    //    /**
    //     * This method should be only applied sequential {@code Stream} and whose up-streams are sequential {@code Streams} as well.
    //     * Because error happening in the operations executed by parallel stream will stop iteration on that {@Stream}, so the down-streams won't be able to continue.
    //     *
    //     * @param predicate
    //     * @param supplierForFallbackValue
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream onErrorReturn(Predicate predicate, Supplier supplierForFallbackValue);
    //
    //    /**
    //     * This method should be only applied sequential {@code Stream} and whose up-streams are sequential {@code Streams} as well.
    //     * Because error happening in the operations executed by parallel stream will stop iteration on that {@Stream}, so the down-streams won't be able to continue.
    //     *
    //     * @param predicate
    //     * @param mapperForFallbackValue
    //     * @param maxErrorCountToStop
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream onErrorReturn(Predicate predicate, Function mapperForFallbackValue,
    //            int maxErrorCountToStop);
    //
    //    /**
    //     *
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @IntermediateOp
    //    public abstract Stream onErrorStop();

    //    @Beta
    //    @ParallelSupported
    //    @TerminalOp
    //    public abstract void foreach(java.util.function.Consumer action);

    /**
     *
     *
     * @param 
     * @param action
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  void forEach(Throwables.Consumer action) throws E;

    /**
     *
     *
     * @param 
     * @param action
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  void forEachIndexed(Throwables.IntObjConsumer action) throws E;

    /**
     * Iterate and execute {@code action} until the flag is set true.
     * Flag can only be set after at least one element is iterated and executed by {@code action}.
     *
     * @param 
     * @param action the second parameter is a flag to break the for-each loop.
     *        Set it to {@code true} to break the loop if you don't want to continue the {@code action}.
     *        Iteration on this stream will also be stopped when this flag is set to {@code true}.
     * @throws E
     * @see {@link #forEachUntil(MutableBoolean, Throwables.Consumer)}
     */
    @Beta
    @ParallelSupported
    @TerminalOp
    public abstract  void forEachUntil(Throwables.BiConsumer action) throws E;

    /**
     * Iterate and execute {@code action} until {@code flagToBreak} is set true.
     * If {@code flagToBreak} is set to true at the begin, there will be no element iterated from stream before this stream is stopped and closed.
     *
     * @param 
     * @param flagToBreak a flag to break the for-each loop.
     *        Set it to {@code true} to break the loop if you don't want to continue the {@code action}.
     *        Iteration on this stream will also be stopped when this flag is set to {@code true}.
     * @param action
     * @throws E
     * @see {@link #forEachUntil(Throwables.BiConsumer)}
     */
    @Beta
    @ParallelSupported
    @TerminalOp
    public abstract  void forEachUntil(MutableBoolean flagToBreak, Throwables.Consumer action) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param action
     * @param onComplete
     * @throws E
     * @throws E2
     */
    @ParallelSupported
    @TerminalOp
    public abstract  void forEach(Throwables.Consumer action, Throwables.Runnable onComplete)
            throws E, E2;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param flatMapper
     * @param action
     * @throws E
     * @throws E2
     */
    @ParallelSupported
    @TerminalOp
    public abstract  void forEach(
            final Throwables.Function, E> flatMapper, final Throwables.BiConsumer action)
            throws E, E2;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param flatMapper
     * @param flatMapper2
     * @param action
     * @throws E
     * @throws E2
     * @throws E3
     */
    @ParallelSupported
    @TerminalOp
    public abstract  void forEach(
            final Throwables.Function, E> flatMapper,
            final Throwables.Function, E2> flatMapper2,
            final Throwables.TriConsumer action) throws E, E2, E3;

    /**
     *
     *
     * @param 
     * @param action
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  void forEachPair(final Throwables.BiConsumer action) throws E;

    /**
     *
     *
     * @param 
     * @param increment
     * @param action
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  void forEachPair(final int increment, final Throwables.BiConsumer action) throws E;

    /**
     *
     *
     * @param 
     * @param action
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  void forEachTriple(final Throwables.TriConsumer action) throws E;

    /**
     *
     *
     * @param 
     * @param increment
     * @param action
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  void forEachTriple(final int increment, final Throwables.TriConsumer action)
            throws E;

    /**
     *
     *
     * @param 
     * @param predicate
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  boolean anyMatch(Throwables.Predicate predicate) throws E;

    /**
     *
     *
     * @param 
     * @param predicate
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  boolean allMatch(Throwables.Predicate predicate) throws E;

    /**
     *
     *
     * @param 
     * @param predicate
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  boolean noneMatch(Throwables.Predicate predicate) throws E;

    /**
     *
     *
     * @param 
     * @param atLeast
     * @param atMost
     * @param predicate
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  boolean nMatch(long atLeast, long atMost, Throwables.Predicate predicate) throws E;

    /**
     * Returns the first element matched by {@code predicateForFirst} if found, Otherwise an empty {@code Optional} will be returned.
     *
     * @param 
     * @param predicate
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Optional findFirst(Throwables.Predicate predicate) throws E;

    /**
     * Returns the last element matched by {@code predicateForFirst} if found, Otherwise an empty {@code Optional} will be returned.
     *
     * 

     * Consider using: {@code stream.reversed().findFirst(predicate)} for better performance if possible.
     *
     * @param 
     * @param predicate
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Optional findLast(Throwables.Predicate predicate) throws E;

    /**
     * Returns any element matched by {@code predicateForFirst} if found, Otherwise an empty {@code Optional} will be returned.
     * It's same as {@code findFirst} and always returns the first element matched by {@code predicateForFirst} if found in sequential stream.
     * In parallel stream, it may have better performance than {@code findFirst}.
     *
     * @param 
     * @param predicate
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Optional findAny(Throwables.Predicate predicate) throws E;

    /**
     * Returns the first element matched by {@code predicateForFirst} if found or the first element if this stream is not empty
     * Otherwise an empty {@code Optional} will be returned.
     *
     * @param 
     * @param predicateForFirst
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Optional findFirstOrAny(Throwables.Predicate predicateForFirst) throws E;

    /**
     * Returns the first element matched by {@code predicateForFirst} if found or any element matched by {@code predicateForAny} (If this is a sequential stream, it will always be the first element matched by {@code predicateForAny}).
     * Otherwise an empty {@code Optional} will be returned.
     *
     * @param 
     * @param 
     * @param predicateForFirst
     * @param predicateForAny
     * @return
     * @throws E
     * @throws E2
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Optional findFirstOrAny(Throwables.Predicate predicateForFirst,
            Throwables.Predicate predicateForAny) throws E, E2;

    /**
     * Returns the first element matched by {@code predicateForFirst} if found or the last element if this stream is not empty
     * Otherwise an empty {@code Optional} will be returned.
     *
     * @param 
     * @param predicateForFirst
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Optional findFirstOrLast(Throwables.Predicate predicateForFirst) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param predicateForFirst
     * @param predicateForLast
     * @return
     * @throws E
     * @throws E2
     */
    @Beta
    @SequentialOnly
    @TerminalOp
    public abstract  Optional findFirstOrLast(Throwables.Predicate predicateForFirst,
            Throwables.Predicate predicateForLast) throws E, E2;

    /**
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param 
     * @param 
     * @param 
     * @param init
     * @param predicateForFirst
     * @param predicateForLast
     * @return
     * @throws E
     * @throws E2
     */
    @Beta
    @SequentialOnly
    @TerminalOp
    public abstract  Optional findFirstOrLast(final U init,
            final Throwables.BiPredicate predicateForFirst, final Throwables.BiPredicate predicateForLast)
            throws E, E2;

    /**
     * 

     * This method only runs sequentially, even in parallel stream.
     *
     * @param 
     * @param 
     * @param 
     * @param preFunc
     * @param predicateForFirst
     * @param predicateForLast
     * @return
     * @throws E
     * @throws E2
     */
    @Beta
    @SequentialOnly
    @TerminalOp
    public abstract  Optional findFirstOrLast(final Function preFunc,
            final Throwables.BiPredicate predicateForFirst, final Throwables.BiPredicate predicateForLast)
            throws E, E2;

    /**
     *
     *
     * @param a
     * @return
     */
    @SequentialOnly
    @TerminalOp
    public abstract boolean containsAll(T... a);

    /**
     *
     *
     * @param c
     * @return
     */
    @SequentialOnly
    @TerminalOp
    public abstract boolean containsAll(Collection c);

    /**
     *
     *
     * @param a
     * @return
     */
    @SequentialOnly
    @TerminalOp
    public abstract boolean containsAny(T... a);

    /**
     *
     *
     * @param c
     * @return
     */
    @SequentialOnly
    @TerminalOp
    public abstract boolean containsAny(Collection c);

    /**
     *
     *
     * @param 
     * @param generator
     * @return
     */
    @SequentialOnly
    @TerminalOp
    public abstract  A[] toArray(IntFunction generator);

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#toMap(Function, Function)
     */
    @ParallelSupported
    @TerminalOp
    public  ImmutableMap toImmutableMap(Throwables.Function keyMapper,
            Throwables.Function valueMapper) throws E, E2 {
        return ImmutableMap.wrap(toMap(keyMapper, valueMapper));
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mergeFunction
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#toMap(Function, Function)
     */
    @ParallelSupported
    @TerminalOp
    public  ImmutableMap toImmutableMap(Throwables.Function keyMapper,
            Throwables.Function valueMapper, BinaryOperator mergeFunction) throws E, E2 {
        return ImmutableMap.wrap(toMap(keyMapper, valueMapper, mergeFunction));
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#toMap(Function, Function)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map toMap(Throwables.Function keyMapper,
            Throwables.Function valueMapper) throws E, E2;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mergeFunction
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#toMap(Function, Function, BinaryOperator)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map toMap(Throwables.Function keyMapper,
            Throwables.Function valueMapper, BinaryOperator mergeFunction) throws E, E2;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mapFactory
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#toMap(Function, Function, Supplier)
     */
    @ParallelSupported
    @TerminalOp
    public abstract , E extends Exception, E2 extends Exception> M toMap(Throwables.Function keyMapper,
            Throwables.Function valueMapper, Supplier mapFactory) throws E, E2;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mergeFunction
     * @param mapFactory
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#toMap(Function, Function, BinaryOperator, Supplier)
     */
    @ParallelSupported
    @TerminalOp
    public abstract , E extends Exception, E2 extends Exception> M toMap(Throwables.Function keyMapper,
            Throwables.Function valueMapper, BinaryOperator mergeFunction, Supplier mapFactory) throws E, E2;

    //    /**
    //     *
    //     * @param keyMapper
    //     * @param downstream
    //     * @return
    //     * @see #groupTo(Throwables.Function, Collector)
    //     * @deprecated replaced by {@code groupTo}
    //     */
    //    @Deprecated
    //    @ParallelSupported
    //    @TerminalOp
    //    public final  Map toMap(Throwables.Function keyMapper,
    //            final Collector downstream) throws E {
    //        return groupTo(keyMapper, downstream);
    //    }
    //
    //    /**
    //     *
    //     * @param keyMapper
    //     * @param downstream
    //     * @param mapFactory
    //     * @return
    //     * @see #groupTo(Throwables.Function, Collector, Supplier)
    //     * @deprecated replaced by {@code groupTo}
    //     */
    //    @Deprecated
    //    @ParallelSupported
    //    @TerminalOp
    //    public final , E extends Exception> M toMap(Throwables.Function keyMapper,
    //            final Collector downstream, final Supplier mapFactory) throws E {
    //        return groupTo(keyMapper, downstream, mapFactory);
    //    }
    //
    //    /**
    //     *
    //     * @param keyMapper
    //     * @param valueMapper
    //     * @param downstream
    //     * @return
    //     * @see #groupTo(Throwables.Function, Throwables.Function, Collector)
    //     * @deprecated replaced by {@code groupTo}
    //     */
    //    @Deprecated
    //    @ParallelSupported
    //    @TerminalOp
    //    public final  Map toMap(Throwables.Function keyMapper,
    //            Throwables.Function valueMapper, final Collector downstream) throws E, E2 {
    //        return groupTo(keyMapper, valueMapper, downstream);
    //    }
    //
    //    /**
    //     *
    //     * @param keyMapper
    //     * @param valueMapper
    //     * @param downstream
    //     * @param mapFactory
    //     * @return
    //     * @see #groupTo(Throwables.Function, Throwables.Function, Collector, Supplier)
    //     * @deprecated replaced by {@code groupTo}
    //     */
    //    @Deprecated
    //    @ParallelSupported
    //    @TerminalOp
    //    public final , E extends Exception, E2 extends Exception> M toMap(Throwables.Function keyMapper,
    //            Throwables.Function valueMapper, final Collector downstream, final Supplier mapFactory)
    //            throws E, E2 {
    //        return groupTo(keyMapper, valueMapper, downstream, mapFactory);
    //    }

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @return
     * @throws E
     * @see Collectors#groupingBy(Function)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map> groupTo(Throwables.Function keyMapper) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param mapFactory
     * @return
     * @throws E
     * @see Collectors#groupingBy(Function, Supplier)
     */
    @ParallelSupported
    @TerminalOp
    public abstract >, E extends Exception> M groupTo(Throwables.Function keyMapper,
            final Supplier mapFactory) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @return
     * @throws E
     * @throws E2
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map> groupTo(Throwables.Function keyMapper,
            Throwables.Function valueMapper) throws E, E2;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mapFactory
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#toMultimap(Function, Function, Supplier)
     */
    @ParallelSupported
    @TerminalOp
    public abstract >, E extends Exception, E2 extends Exception> M groupTo(
            Throwables.Function keyMapper, Throwables.Function valueMapper,
            Supplier mapFactory) throws E, E2;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param downstream
     * @return
     * @throws E
     * @see Collectors#groupingBy(Function, Collector)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map groupTo(Throwables.Function keyMapper,
            final Collector downstream) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param downstream
     * @param mapFactory
     * @return
     * @throws E
     * @see Collectors#groupingBy(Function, Collector, Supplier)
     */
    @ParallelSupported
    @TerminalOp
    public abstract , E extends Exception> M groupTo(Throwables.Function keyMapper,
            final Collector downstream, final Supplier mapFactory) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param downstream
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#groupingBy(Function, Collector)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map groupTo(Throwables.Function keyMapper,
            Throwables.Function valueMapper, final Collector downstream) throws E, E2;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param downstream
     * @param mapFactory
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#groupingBy(Function, Collector, Supplier)
     */
    @ParallelSupported
    @TerminalOp
    public abstract , E extends Exception, E2 extends Exception> M groupTo(
            Throwables.Function keyMapper, Throwables.Function valueMapper,
            final Collector downstream, final Supplier mapFactory) throws E, E2;

    //    /**
    //     *
    //     * @param 
    //     * @param 
    //     * @param flatKeyMapper
    //     * @return
    //     * @throws E
    //     */
    //    @ParallelSupported
    //    @TerminalOp
    //    public abstract  Map> flatGroupTo(Throwables.Function, E> flatKeyMapper)
    //            throws E;
    //
    //    /**
    //     *
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param flatKeyMapper
    //     * @param mapFactory
    //     * @return
    //     * @throws E
    //     */
    //    @ParallelSupported
    //    @TerminalOp
    //    public abstract >, E extends Exception> M flatGroupTo(
    //            final Throwables.Function, E> flatKeyMapper, final Supplier mapFactory) throws E;
    //
    //    /**
    //     *
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param flatKeyMapper
    //     * @param valueMapper
    //     * @return
    //     * @throws E
    //     * @throws E2
    //     */
    //    @ParallelSupported
    //    @TerminalOp
    //    public abstract  Map> flatGroupTo(
    //            Throwables.Function, E> flatKeyMapper,
    //            Throwables.BiFunction valueMapper) throws E, E2;
    //
    //    /**
    //     *
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param flatKeyMapper
    //     * @param valueMapper
    //     * @param mapFactory
    //     * @return
    //     * @throws E
    //     * @throws E2
    //     */
    //    @ParallelSupported
    //    @TerminalOp
    //    public abstract >, E extends Exception, E2 extends Exception> M flatGroupTo(
    //            Throwables.Function, E> flatKeyMapper,
    //            Throwables.BiFunction valueMapper, Supplier mapFactory) throws E, E2;

    /**
     *
     * @param 
     * @param 
     * @param flatKeyMapper
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map> flatGroupTo(Throwables.Function, E> flatKeyMapper)
            throws E;

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param flatKeyMapper
     * @param mapFactory
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract >, E extends Exception> M flatGroupTo(
            final Throwables.Function, E> flatKeyMapper, final Supplier mapFactory) throws E;

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param flatKeyMapper
     * @param valueMapper
     * @return
     * @throws E
     * @throws E2
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map> flatGroupTo(
            Throwables.Function, E> flatKeyMapper,
            Throwables.BiFunction valueMapper) throws E, E2;

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param flatKeyMapper
     * @param valueMapper
     * @param mapFactory
     * @return
     * @throws E
     * @throws E2
     */
    @ParallelSupported
    @TerminalOp
    public abstract >, E extends Exception, E2 extends Exception> M flatGroupTo(
            Throwables.Function, E> flatKeyMapper,
            Throwables.BiFunction valueMapper, Supplier mapFactory) throws E, E2;

    //    /**
    //     *
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param flatKeyMapper
    //     * @param downstream
    //     * @return
    //     * @throws E
    //     */
    //    @ParallelSupported
    //    @TerminalOp
    //    public abstract  Map flatGroupTo(final Throwables.Function, E> flatKeyMapper,
    //            final Collector downstream) throws E;
    //
    //    /**
    //     *
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param flatKeyMapper
    //     * @param downstream
    //     * @param mapFactory
    //     * @return
    //     * @throws E
    //     */
    //    @ParallelSupported
    //    @TerminalOp
    //    public abstract , E extends Exception> M flatGroupTo(
    //            final Throwables.Function, E> flatKeyMapper, final Collector downstream,
    //            final Supplier mapFactory) throws E;
    //
    //    /**
    //     *
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param flatKeyMapper
    //     * @param valueMapper
    //     * @param downstream
    //     * @return
    //     * @throws E
    //     * @throws E2
    //     */
    //    @ParallelSupported
    //    @TerminalOp
    //    public abstract  Map flatGroupTo(
    //            final Throwables.Function, E> flatKeyMapper,
    //            final Throwables.BiFunction valueMapper, final Collector downstream) throws E, E2;
    //
    //    /**
    //     *
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param 
    //     * @param flatKeyMapper
    //     * @param valueMapper
    //     * @param downstream
    //     * @param mapFactory
    //     * @return
    //     * @throws E
    //     * @throws E2
    //     */
    //    @ParallelSupported
    //    @TerminalOp
    //    public abstract , E extends Exception, E2 extends Exception> M flatGroupTo(
    //            final Throwables.Function, E> flatKeyMapper,
    //            final Throwables.BiFunction valueMapper, final Collector downstream,
    //            final Supplier mapFactory) throws E, E2;

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param flatKeyMapper
     * @param downstream
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map flatGroupTo(final Throwables.Function, E> flatKeyMapper,
            final Collector downstream) throws E;

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param flatKeyMapper
     * @param downstream
     * @param mapFactory
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract , E extends Exception> M flatGroupTo(
            final Throwables.Function, E> flatKeyMapper, final Collector downstream,
            final Supplier mapFactory) throws E;

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param flatKeyMapper
     * @param valueMapper
     * @param downstream
     * @return
     * @throws E
     * @throws E2
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map flatGroupTo(
            final Throwables.Function, E> flatKeyMapper,
            final Throwables.BiFunction valueMapper, final Collector downstream) throws E, E2;

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param flatKeyMapper
     * @param valueMapper
     * @param downstream
     * @param mapFactory
     * @return
     * @throws E
     * @throws E2
     */
    @ParallelSupported
    @TerminalOp
    public abstract , E extends Exception, E2 extends Exception> M flatGroupTo(
            final Throwables.Function, E> flatKeyMapper,
            final Throwables.BiFunction valueMapper, final Collector downstream,
            final Supplier mapFactory) throws E, E2;

    /**
     *
     *
     * @param 
     * @param predicate
     * @return
     * @throws E
     * @see Collectors#partitioningBy(Predicate)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map> partitionTo(final Throwables.Predicate predicate) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param predicate
     * @param downstream
     * @return
     * @throws E
     * @see Collectors#partitioningBy(Predicate, Collector)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Map partitionTo(final Throwables.Predicate predicate,
            final Collector downstream) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param keyMapper
     * @return
     * @throws E
     * @see Collectors#toMultimap(Function, Function)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  ListMultimap toMultimap(Throwables.Function keyMapper) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param mapFactory
     * @return
     * @throws E
     * @see Collectors#toMultimap(Function, Function, Supplier)
     */
    @ParallelSupported
    @TerminalOp
    public abstract , M extends Multimap, E extends Exception> M toMultimap(
            Throwables.Function keyMapper, Supplier mapFactory) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#toMultimap(Function, Function)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  ListMultimap toMultimap(Throwables.Function keyMapper,
            Throwables.Function valueMapper) throws E, E2;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param keyMapper
     * @param valueMapper
     * @param mapFactory
     * @return
     * @throws E
     * @throws E2
     * @see Collectors#toMultimap(Function, Function, Supplier)
     */
    @ParallelSupported
    @TerminalOp
    public abstract , M extends Multimap, E extends Exception, E2 extends Exception> M toMultimap(
            Throwables.Function keyMapper, Throwables.Function valueMapper,
            Supplier mapFactory) throws E, E2;

    /**
     * The first row will be used as column names if its type is array or list,
     * or obtain the column names from first row if its type is bean or map.
     *
     * @return
     * @see {@link N#newDataSet(Collection)}
     */
    @SequentialOnly
    @TerminalOp
    public abstract DataSet toDataSet();

    /**
     * If the specified {@code columnNames} is null or empty, the first row will be used as column names if its type is array or list,
     * or obtain the column names from first row if its type is bean or map.
     *
     * @param columnNames
     * @return
     * @see {@link N#newDataSet(Collection, Collection)}
     */
    @SequentialOnly
    @TerminalOp
    public abstract DataSet toDataSet(final List columnNames);

    /**
     *
     *
     * @param joiner
     * @return
     */
    @SequentialOnly
    @TerminalOp
    public abstract String join(final Joiner joiner);

    /**
     * This method will always run sequentially, even in parallel stream.
     *
     * @param 
     * @param accumulator
     * @return
     * @throws E
     * @see #reduce(Throwables.BinaryOperator)
     */
    @SequentialOnly
    @TerminalOp
    public abstract  Optional foldLeft(Throwables.BinaryOperator accumulator) throws E;

    /**
     * This method will always run sequentially, even in parallel stream.
     *
     * @param 
     * @param 
     * @param identity
     * @param accumulator
     * @return
     * @throws E
     * @see #reduce(Object, Throwables.BiFunction, Throwables.BinaryOperator)
     */
    @SequentialOnly
    @TerminalOp
    public abstract  U foldLeft(U identity, Throwables.BiFunction accumulator) throws E;

    /**
     * This method will always run sequentially, even in parallel stream.
     *
     * @param 
     * @param accumulator
     * @return
     * @throws E
     * @see #reduce(Throwables.BinaryOperator)
     */
    @SequentialOnly
    @TerminalOp
    public abstract  Optional foldRight(Throwables.BinaryOperator accumulator) throws E;

    /**
     * This method will always run sequentially, even in parallel stream.
     *
     * @param 
     * @param 
     * @param identity
     * @param accumulator
     * @return
     * @throws E
     * @see #reduce(Object, Throwables.BiFunction, Throwables.BinaryOperator)
     */
    @SequentialOnly
    @TerminalOp
    public abstract  U foldRight(U identity, Throwables.BiFunction accumulator) throws E;

    /**
     *
     *
     * @param 
     * @param accumulator
     * @return
     * @throws E
     * @see #foldLeft(Throwables.BinaryOperator)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  Optional reduce(Throwables.BinaryOperator accumulator) throws E;

    /**
     *
     *
     * @param 
     * @param identity
     * @param accumulator
     * @return
     * @throws E
     * @see #foldLeft(Object, Throwables.BiFunction)
     */
    @ParallelSupported
    @TerminalOp
    public  T reduce(T identity, Throwables.BinaryOperator accumulator) throws E {
        return reduce(identity, accumulator, accumulator);
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param identity
     * @param accumulator
     * @param combiner
     * @return
     * @throws E
     * @see #foldLeft(Object, Throwables.BiFunction)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  U reduce(U identity, Throwables.BiFunction accumulator,
            Throwables.BinaryOperator combiner) throws E;

    /**
     *
     *
     * @param 
     * @param accumulator
     * @param conditionToBreak the input parameter is the return value of {@code accumulator}, not the element from this Stream.
     *        Returns {@code true} to break the loop if you don't want to continue the {@code action}.
     *        Iteration on this stream will also be stopped when this flag is set to {@code true}.
     * @return
     * @throws E
     * @see #foldLeft(Throwables.BinaryOperator)
     */
    @Beta
    @ParallelSupported
    @TerminalOp
    public abstract  Optional reduceUntil(Throwables.BinaryOperator accumulator,
            Throwables.Predicate conditionToBreak) throws E;

    /**
     *
     *
     * @param 
     * @param accumulator
     * @param conditionToBreak the first input parameter is the return value of {@code accumulator}, the second input parameter is the element from this Stream.
     *        Returns {@code true} to break the loop if you don't want to continue the {@code action}.
     *        Iteration on this stream will also be stopped when this flag is set to {@code true}.
     * @return
     * @throws E
     * @see #foldLeft(Throwables.BinaryOperator)
     */
    @Beta
    @ParallelSupported
    @TerminalOp
    public abstract  Optional reduceUntil(Throwables.BinaryOperator accumulator,
            Throwables.BiPredicate conditionToBreak) throws E;

    /**
     *
     *
     * @param 
     * @param identity
     * @param accumulator
     * @param conditionToBreak the input parameter is the return value of {@code accumulator}, not the element from this Stream.
     *        Returns {@code true} to break the loop if you don't want to continue the {@code action}.
     *        Iteration on this stream will also be stopped when this flag is set to {@code true}.
     * @return
     * @throws E
     * @see #foldLeft(Object, Throwables.BiFunction)
     */
    @Beta
    @ParallelSupported
    @TerminalOp
    public  T reduceUntil(T identity, Throwables.BinaryOperator accumulator, Throwables.Predicate conditionToBreak)
            throws E {
        return reduceUntil(identity, accumulator, accumulator, conditionToBreak);
    }

    /**
     *
     *
     * @param 
     * @param identity
     * @param accumulator
     * @param conditionToBreak the first input parameter is the return value of {@code accumulator}, the second input parameter is the element from this Stream.
     *        Returns {@code true} to break the loop if you don't want to continue the {@code action}.
     *        Iteration on this stream will also be stopped when this flag is set to {@code true}.
     * @return
     * @throws E
     * @see #foldLeft(Object, Throwables.BiFunction)
     */
    @Beta
    @ParallelSupported
    @TerminalOp
    public  T reduceUntil(T identity, Throwables.BinaryOperator accumulator,
            Throwables.BiPredicate conditionToBreak) throws E {
        return reduceUntil(identity, accumulator, accumulator, conditionToBreak);
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param identity
     * @param accumulator
     * @param combiner
     * @param conditionToBreak the input parameter is the return value of {@code accumulator}, not the element from this Stream.
     *        Returns {@code true} to break the loop if you don't want to continue the {@code action}.
     *        Iteration on this stream will also be stopped when this flag is set to {@code true}.
     * @return
     * @throws E
     * @see #foldLeft(Object, Throwables.BiFunction)
     */
    @Beta
    @ParallelSupported
    @TerminalOp
    public abstract  U reduceUntil(U identity, Throwables.BiFunction accumulator,
            Throwables.BinaryOperator combiner, Throwables.Predicate conditionToBreak) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param identity
     * @param accumulator
     * @param combiner
     * @param conditionToBreak the first input parameter is the return value of {@code accumulator}, the second input parameter is the element from this Stream.
     *        Returns {@code true} to break the loop if you don't want to continue the {@code action}.
     *        Iteration on this stream will also be stopped when this flag is set to {@code true}.
     * @return
     * @throws E
     * @see #foldLeft(Object, Throwables.BiFunction)
     */
    @Beta
    @ParallelSupported
    @TerminalOp
    public abstract  U reduceUntil(U identity, Throwables.BiFunction accumulator,
            Throwables.BinaryOperator combiner, Throwables.BiPredicate conditionToBreak) throws E;

    /**
     *
     * @param  if {@code R} is {@code  Map/Collection/StringBuilder/Multiset/LongMultiset/Multimap/BooleanList/IntList/.../DoubleList}, It's not required to specified {@code combiner}.
     * Otherwise, {@code combiner} must be specified.
     * @param supplier
     * @param accumulator
     * @param combiner
     * @return
     * @see #collect(Supplier, BiConsumer)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner);

    /**
     * Only call this method when the returned type {@code R} is one types: {@code Collection/Map/StringBuilder/Multiset/LongMultiset/Multimap/BooleanList/IntList/.../DoubleList}.
     * Otherwise, please call {@link #collect(Supplier, BiConsumer, BiConsumer)}.
     *
     * @param 
     * @param supplier
     * @param accumulator
     * @return
     * @see #collect(Supplier, BiConsumer, BiConsumer)
     */
    @ParallelSupported
    @TerminalOp
    public abstract  R collect(Supplier supplier, BiConsumer accumulator);

    /**
     *
     *
     * @param 
     * @param collector
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract  R collect(Collector collector);

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param downstream
     * @param func
     * @return
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  RR collectThenApply(Collector downstream,
            Throwables.Function func) throws E;

    /**
     *
     * @param 
     * @param 
     * @param downstream
     * @param consumer
     * @throws E
     */
    @ParallelSupported
    @TerminalOp
    public abstract  void collectThenAccept(Collector downstream, Throwables.Consumer consumer) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param func
     * @return
     * @throws E
     */
    @SequentialOnly
    @TerminalOp
    public abstract  R toListThenApply(Throwables.Function, ? extends R, E> func) throws E;

    /**
     *
     * @param 
     * @param consumer
     * @throws E
     */
    @SequentialOnly
    @TerminalOp
    public abstract  void toListThenAccept(Throwables.Consumer, E> consumer) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param func
     * @return
     * @throws E
     */
    @SequentialOnly
    @TerminalOp
    public abstract  R toSetThenApply(Throwables.Function, ? extends R, E> func) throws E;

    /**
     *
     * @param 
     * @param consumer
     * @throws E
     */
    @SequentialOnly
    @TerminalOp
    public abstract  void toSetThenAccept(Throwables.Consumer, E> consumer) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param supplier
     * @param func
     * @return
     * @throws E
     */
    @SequentialOnly
    @TerminalOp
    public abstract , E extends Exception> R toCollectionThenApply(Supplier supplier,
            Throwables.Function func) throws E;

    /**
     *
     *
     * @param 
     * @param 
     * @param supplier
     * @param consumer
     * @throws E
     */
    @SequentialOnly
    @TerminalOp
    public abstract , E extends Exception> void toCollectionThenAccept(Supplier supplier,
            Throwables.Consumer consumer) throws E;

    /**
     *
     *
     * @param comparator
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract Optional min(Comparator comparator);

    /**
     *
     *
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @TerminalOp
    @SuppressWarnings("rawtypes")
    public Optional minBy(final Function keyMapper) {
        final Comparator comparator = Comparators.nullsLastBy(keyMapper);

        return min(comparator);
    }

    /**
     *
     *
     * @param comparator
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract List minAll(Comparator comparator);

    /**
     *
     *
     * @param comparator
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract Optional max(Comparator comparator);

    /**
     *
     *
     * @param keyMapper
     * @return
     */
    @ParallelSupported
    @TerminalOp
    @SuppressWarnings("rawtypes")
    public Optional maxBy(final Function keyMapper) {
        final Comparator comparator = Comparators.nullsFirstBy(keyMapper);

        return max(comparator);
    }

    /**
     *
     *
     * @param comparator
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract List maxAll(Comparator comparator);

    /**
     *
     * @param k
     * @param comparator
     * @return Optional.empty() if there is no element or count less than k, otherwise the kth largest element.
     */
    @ParallelSupported
    @TerminalOp
    public abstract Optional kthLargest(int k, Comparator comparator);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract long sumInt(ToIntFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract long sumLong(ToLongFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract double sumDouble(ToDoubleFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract OptionalDouble averageInt(ToIntFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract OptionalDouble averageLong(ToLongFunction mapper);

    /**
     *
     *
     * @param mapper
     * @return
     */
    @ParallelSupported
    @TerminalOp
    public abstract OptionalDouble averageDouble(ToDoubleFunction mapper);

    /**
     *
     *
     * @param comparator
     * @return
     */
    @SequentialOnly
    @TerminalOp
    public abstract Optional> percentiles(Comparator comparator);

    /**
     *
     *
     * @return
     */
    @SequentialOnly
    @TerminalOp
    public abstract boolean hasDuplicates();

    // It won't work for findFirst/only/anyMatch...
    //    @ParallelSupported
    //    @TerminalOp
    //    public abstract  Pair countAnd(Throwables.Function, ? extends R, E> terminalAction) throws E;

    /**
     * 
     * 
     * Stream.of(1, 2, 3).combinations().forEach(Fn.println());
     * // output
     * []
     * [1]
     * [2]
     * [3]
     * [1, 2]
     * [1, 3]
     * [2, 3]
     * [1, 2, 3]
     * 
     * 
     *
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> combinations();

    /**
     * 
     * 
     * Stream.of(1, 2, 3).combinations(2).forEach(Fn.println());
     * // output
     * [1, 2]
     * [1, 3]
     * [2, 3]
     * 
     * 
     *
     * @param len
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> combinations(int len);

    /**
     * It's same as {@code N.cartesianProduct(N.repeat(toList(), len))} if {@code repeat} is {@code true}.
     * 
     * 
     * Stream.of(1, 2, 3).combinations(2, true).forEach(Fn.println());
     * // output
     * [1, 1]
     * [1, 2]
     * [1, 3]
     * [2, 1]
     * [2, 2]
     * [2, 3]
     * [3, 1]
     * [3, 2]
     * [3, 3]
     * 
     * 
     *
     * @param len
     * @param repeat
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> combinations(int len, boolean repeat);

    /**
     * 
     * 
     * Stream.of(1, 2, 3).permutations().forEach(Fn.println());
     * // output
     * [1, 2, 3]
     * [1, 3, 2]
     * [3, 1, 2]
     * [3, 2, 1]
     * [2, 3, 1]
     * [2, 1, 3]
     * 
     * 
     *
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> permutations();

    /**
     * 
     * 
     * Stream.of(1, 2, 3).orderedPermutations().forEach(Fn.println());
     * // output
     * [1, 2, 3]
     * [1, 3, 2]
     * [2, 1, 3]
     * [2, 3, 1]
     * [3, 1, 2]
     * [3, 2, 1]
     * 
     * 
     *
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> orderedPermutations();

    /**
     *
     *
     * @param comparator
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> orderedPermutations(Comparator comparator);

    /**
     *
     *
     * @param cs
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    @SafeVarargs
    public final Stream> cartesianProduct(Collection... cs) {
        return cartesianProduct(Arrays.asList(cs));
    }

    /**
     *
     *
     * @param cs
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream> cartesianProduct(Collection> cs);

    /**
     * Intersect with the specified Collection by the values mapped by mapper.
     *
     * @param 
     * @param mapper
     * @param c
     * @return
     * @see N#intersection(Collection, Collection)
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream intersection(Function mapper, Collection c);

    /**
     * Except with the specified Collection by the values mapped by mapper.
     *
     * @param 
     * @param mapper
     * @param c
     * @return
     * @see N#difference(Collection, Collection)
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream difference(Function mapper, Collection c);

    /**
     *
     * @param defaultValue
     * @return
     * @see #appendIfEmpty(Object...)
     */
    @SequentialOnly
    @IntermediateOp
    public final Stream defaultIfEmpty(final T defaultValue) {
        return appendIfEmpty(defaultValue);
    }

    //    /**
    //     *
    //     * @param defaultValues
    //     * @return
    //     * @see #appendIfEmpty(Object...)
    //     */
    //    @SequentialOnly
    //    @IntermediateOp
    //    public final Stream defaultIfEmpty(final Collection defaultValues) {
    //        return appendIfEmpty(defaultValues);
    //    }

    /**
     *
     * @param supplier
     * @return
     * @see #appendIfEmpty(Supplier)
     */
    @SequentialOnly
    @IntermediateOp
    public final Stream defaultIfEmpty(final Supplier> supplier) {
        return appendIfEmpty(supplier);
    }

    //    @SequentialOnly
    //    public abstract Stream appendAlll(Collection> cs);

    /**
     *
     *
     * @param a
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    @SafeVarargs
    public final Stream prepend(T... a) {
        return prepend(Arrays.asList(a));
    }

    /**
     *
     *
     * @param c
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream prepend(Collection c);

    /**
     *
     *
     * @param a
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    @SafeVarargs
    public final Stream append(T... a) {
        return append(Arrays.asList(a));
    }

    /**
     *
     *
     * @param c
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream append(Collection c);

    //    @SequentialOnly
    //    public abstract Stream appendAlll(Collection> cs);

    //    @SequentialOnly
    //    public abstract Stream prependAlll(Collection> cs);

    /**
     *
     *
     * @param a
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    @SafeVarargs
    public final Stream appendIfEmpty(T... a) {
        return appendIfEmpty(Arrays.asList(a));
    }

    /**
     *
     *
     * @param c
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream appendIfEmpty(Collection c);

    //    /**
    //     * Returns a reusable stream which can be repeatedly used.
    //     *
    //     * 

    //     * All elements will be loaded to memory.
    //     *
    //     * @param generator
    //     * @return
    //     */
    //    @SequentialOnly
    //    public abstract Stream cached(IntFunction generator);

    //    /**
    //     * The Stream will be closed finally, no matter it's empty or not.
    //     *
    //     * @param func
    //     * @return
    //     */
    //    @Beta
    //    public abstract  Optional applyIfNotEmpty(Try.Function, ? extends R, E> func) throws E;
    //
    //    /**
    //     * The Stream will be closed finally, no matter it's empty or not.
    //     *
    //     * @param action
    //     *
    //     */
    //    @Beta
    //    public abstract  void acceptIfNotEmpty(Try.Consumer, E> action) throws E;

    /**
     *
     *
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    @TerminalOpTriggered
    public abstract Stream> rollup();

    /**
     * Returns a new Stream with elements from a temporary queue which is filled by reading the elements from this Stream asynchronously with a new thread.
     * Default queue size is 64.
     * 

     * Mostly it's for {@code read-write with different threads} mode.
     *
     * @return
     * @see #buffered()
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream buffered();

    /**
     * Returns a new Stream with elements from a temporary queue which is filled by reading the elements from this Stream asynchronously with a new thread.
     * 

     * Mostly it's for {@code read-write with different threads} mode.
     * @param bufferSize
     * @return
     * @see #buffered(int)
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream buffered(int bufferSize);

    /**
     * Returns a new Stream with elements from a temporary queue which is filled by reading the elements from this Stream asynchronously with a new thread.
     * 

     * Mostly it's for {@code read-write with different threads} mode.
     *
     * @param queueToBuffer
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream buffered(final BlockingQueue queueToBuffer);

    //    /**
    //     * Returns a new Stream with elements from a temporary queue which is filled by reading the elements from this Stream asynchronously with a new thread.
    //     * Default queue size is 64.
    //     *
    //     * @return
    //     */
    //    @SequentialOnly
    //    @IntermediateOp
    //    public Stream buffered() {
    //        return queued();
    //    }
    //
    //    /**
    //     * Returns a new Stream with elements from a temporary queue which is filled by reading the elements from this Stream asynchronously with a new thread.
    //     *
    //     * @param bufferSize
    //     * @return
    //     */
    //    @SequentialOnly
    //    @IntermediateOp
    //    public Stream buffered(final int bufferSize) {
    //        return queued(bufferSize);
    //    }

    //    /**
    //     *
    //     * @param b
    //     * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    //     * @return
    //     * @deprecated replaced by {@code mergeWith(Stream, BiFunction)}
    //     * @see #mergeWith(Stream, BiFunction)
    //     */
    //    @Deprecated
    //    @SequentialOnly
    //    @IntermediateOp
    //    public Stream merge(final Stream b, final BiFunction nextSelector) {
    //        return mergeWith(b, nextSelector);
    //    }

    /**
     *
     * @param b
     * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream mergeWith(final Collection b, final BiFunction nextSelector);

    /**
     *
     * @param b
     * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
     * @return
     */
    @SequentialOnly
    @IntermediateOp
    public abstract Stream mergeWith(final Stream b, final BiFunction nextSelector);

    /**
     *
     *
     * @param 
     * @param 
     * @param b
     * @param zipFunction
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream zipWith(final Collection b, final BiFunction zipFunction);

    /**
     *
     *
     * @param 
     * @param 
     * @param b
     * @param valueForNoneA
     * @param valueForNoneB
     * @param zipFunction
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream zipWith(final Collection b, final T valueForNoneA, final T2 valueForNoneB,
            final BiFunction zipFunction);

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param b
     * @param c
     * @param zipFunction
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream zipWith(final Collection b, final Collection c,
            final TriFunction zipFunction);

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param b
     * @param c
     * @param valueForNoneA
     * @param valueForNoneB
     * @param valueForNoneC
     * @param zipFunction
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream zipWith(final Collection b, final Collection c, final T valueForNoneA, final T2 valueForNoneB,
            final T3 valueForNoneC, final TriFunction zipFunction);

    /**
     *
     *
     * @param 
     * @param 
     * @param b
     * @param zipFunction
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream zipWith(final Stream b, final BiFunction zipFunction);

    /**
     *
     *
     * @param 
     * @param 
     * @param b
     * @param valueForNoneA
     * @param valueForNoneB
     * @param zipFunction
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream zipWith(final Stream b, final T valueForNoneA, final T2 valueForNoneB,
            final BiFunction zipFunction);

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param b
     * @param c
     * @param zipFunction
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream zipWith(final Stream b, final Stream c,
            final TriFunction zipFunction);

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param b
     * @param c
     * @param valueForNoneA
     * @param valueForNoneB
     * @param valueForNoneC
     * @param zipFunction
     * @return
     */
    @ParallelSupported
    @IntermediateOp
    public abstract  Stream zipWith(final Stream b, final Stream c, final T valueForNoneA, final T2 valueForNoneB, final T3 valueForNoneC,
            final TriFunction zipFunction);

    /**
     *
     *
     * @param output
     * @return
     * @see #onEach(Object)
     * @see #onEachE(com.landawn.abacus.util.Throwables.Consumer)
     */
    @Beta
    @SequentialOnly
    @IntermediateOp
    public abstract Stream saveEach(File output);

    /**
     * 

     * 
     *     final Holder resultHolder = new Holder<>();
     *     thisStream.injectNewStream(newStream -> resultHolder.set(newStream.filter(...).map(...).join(",")));
     * 
     * 

     * 
     * final BlockingQueue queue = new ArrayBlockingQueue<>(32);
     * N.asyncExecute(() -> Stream.observe(queue, Duration.ofMillis(100)).filter(s -> s.startsWith("a")).forEach(Fn.println()));
     * N.asList("a", "b", "ab", "bc", "1", "a").forEach(queue::add);
     * N.sleep(10);
     * N.println("==================");
     * N.sleep(100);
     * N.println("==================");
     * N.sleep(10);
     * 
     * 

     * 
     * final BlockingQueue queue = new ArrayBlockingQueue<>(32);
     * final MutableBoolean hasMore = MutableBoolean.of(true);
     * N.asyncExecute(() -> Stream.observe(queue, () -> hasMore.value(), 10).filter(s -> s.startsWith("a")).forEach(Fn.println()));
     * N.asList("a", "b", "ab", "bc", "1", "a").forEach(queue::add);
     * N.println("==================");
     * hasMore.setFalse();
     * N.sleep(50);
     * N.println("==================");
     * 
     *