com.landawn.abacus.util.ExceptionalStream Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of abacus-common Show documentation
A general programming library in Java/Android. It's easy to learn and simple to use with concise and powerful APIs.
There is a newer version: 5.2.4
/*
 * Copyright (C) 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;

import java.io.BufferedReader;
import java.io.Closeable;
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.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Deque;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.concurrent.Executor;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collector;
import java.util.stream.StreamSupport;

import com.landawn.abacus.annotation.Beta;
import com.landawn.abacus.annotation.IntermediateOp;
import com.landawn.abacus.annotation.Internal;
import com.landawn.abacus.annotation.LazyEvaluation;
import com.landawn.abacus.annotation.SequentialOnly;
import com.landawn.abacus.annotation.TerminalOp;
import com.landawn.abacus.annotation.TerminalOpTriggered;
import com.landawn.abacus.exception.TooManyElementsException;
import com.landawn.abacus.logging.Logger;
import com.landawn.abacus.logging.LoggerFactory;
import com.landawn.abacus.parser.JSONParser;
import com.landawn.abacus.parser.JSONSerializationConfig;
import com.landawn.abacus.parser.JSONSerializationConfig.JSC;
import com.landawn.abacus.parser.ParserFactory;
import com.landawn.abacus.parser.ParserUtil;
import com.landawn.abacus.parser.ParserUtil.BeanInfo;
import com.landawn.abacus.parser.ParserUtil.PropInfo;
import com.landawn.abacus.type.Type;
import com.landawn.abacus.util.Fn.Factory;
import com.landawn.abacus.util.Fn.Fnn;
import com.landawn.abacus.util.Fn.Suppliers;
import com.landawn.abacus.util.If.OrElse;
import com.landawn.abacus.util.Strings.StringUtil;
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.stream.Collectors;
import com.landawn.abacus.util.stream.DoubleStream;
import com.landawn.abacus.util.stream.IntStream;
import com.landawn.abacus.util.stream.LongStream;
import com.landawn.abacus.util.stream.ObjIteratorEx;
import com.landawn.abacus.util.stream.Stream;

/**
 * The Stream will be automatically closed after execution(A terminal method is executed/triggered).
 *
 * @author Haiyang Li
 * @param 
 * @param 
 * @since 1.3
 *
 * @see BaseStream
 * @see Stream
 * @see IntStream
 * @see LongStream
 * @see DoubleStream
 * @see Collectors
 * @see com.landawn.abacus.util.Fn.Fnn
 * @see com.landawn.abacus.util.Comparators
 * @see com.landawn.abacus.util.ExceptionUtil
 */
@LazyEvaluation
@SequentialOnly
@com.landawn.abacus.annotation.Immutable
@SuppressWarnings("java:S1192")
public class ExceptionalStream implements Closeable, Immutable {

    static final Logger logger = LoggerFactory.getLogger(ExceptionalStream.class);

    static final Object NONE = N.NULL_MASK;

    static final Random RAND = new SecureRandom();

    static final Throwables.Function GET_AS_INT = OptionalInt::get;

    static final Throwables.Function GET_AS_LONG = OptionalLong::get;

    static final Throwables.Function GET_AS_DOUBLE = OptionalDouble::get;

    @SuppressWarnings("rawtypes")
    static final Throwables.Function GET_AS_IT = it -> it.orElse(null);

    static final Throwables.Function GET_AS_INT_JDK = java.util.OptionalInt::getAsInt;

    static final Throwables.Function GET_AS_LONG_JDK = java.util.OptionalLong::getAsLong;

    static final Throwables.Function GET_AS_DOUBLE_JDK = java.util.OptionalDouble::getAsDouble;

    @SuppressWarnings("rawtypes")
    static final Throwables.Function GET_AS_IT_JDK = it -> it.orElse(null);

    static final Throwables.Predicate IS_PRESENT_INT = OptionalInt::isPresent;

    static final Throwables.Predicate IS_PRESENT_LONG = OptionalLong::isPresent;

    static final Throwables.Predicate IS_PRESENT_DOUBLE = OptionalDouble::isPresent;

    @SuppressWarnings("rawtypes")
    static final Throwables.Predicate IS_PRESENT_IT = Optional::isPresent;

    static final Throwables.Predicate IS_PRESENT_INT_JDK = java.util.OptionalInt::isPresent;

    static final Throwables.Predicate IS_PRESENT_LONG_JDK = java.util.OptionalLong::isPresent;

    static final Throwables.Predicate IS_PRESENT_DOUBLE_JDK = java.util.OptionalDouble::isPresent;

    @SuppressWarnings("rawtypes")
    static final Throwables.Predicate IS_PRESENT_IT_JDK = java.util.Optional::isPresent;

    static final Throwables.Function, Object>, Object, Exception> KK = t -> t.getKey().val();

    private final ExceptionalIterator elements;

    private final boolean sorted;

    private final Comparator cmp;

    private final Deque> closeHandlers;

    private boolean isClosed = false;

    ExceptionalStream(final ExceptionalIterator iter) {
        this(iter, false, null, null);
    }

    ExceptionalStream(final ExceptionalIterator iter, final Deque> closeHandlers) {
        this(iter, false, null, closeHandlers);
    }

    ExceptionalStream(final ExceptionalIterator iter, final boolean sorted, final Comparator comparator,
            final Deque> closeHandlers) {
        this.elements = iter;
        this.sorted = sorted;
        this.cmp = comparator;
        this.closeHandlers = closeHandlers;
    }

    /**
     *
     * @param 
     * @param 
     * @return
     */
    public static  ExceptionalStream empty() {
        return new ExceptionalStream<>(ExceptionalIterator.EMPTY);
    }

    /**
     *
     * @param 
     * @param 
     * @param e
     * @return
     */
    public static  ExceptionalStream just(final T e) {
        return of(e);
    }

    /**
     *
     * @param 
     * @param 
     * @param e
     * @param exceptionType
     * @return
     */
    public static  ExceptionalStream just(final T e, @SuppressWarnings("unused") final Class exceptionType) { //NOSONAR
        return of(e);
    }

    /**
     * Returns an empty {@code Stream} if the specified {@code t} is null.
     *
     * @param 
     * @param 
     * @param e
     * @return
     */
    public static  ExceptionalStream ofNullable(final T e) {
        if (e == null) {
            return empty();
        }

        return of(e);
    }

    /**
     * Returns an empty {@code Stream} if the specified {@code t} is null.
     *
     * @param 
     * @param 
     * @param e
     * @param exceptionType
     * @return
     */
    public static  ExceptionalStream ofNullable(final T e, @SuppressWarnings("unused") final Class exceptionType) { //NOSONAR
        if (e == null) {
            return empty();
        }

        return of(e);
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @return
     * @see Stream.of(T[]).checked(SomeCheckedException.class)...
     */
    public static  ExceptionalStream of(final T... a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        final int len = N.len(a);

        return newStream(new ExceptionalIterator() {
            private int position = 0;

            @Override
            public boolean hasNext() throws E {
                return position < len;
            }

            @Override
            public T next() throws E {
                if (position >= len) {
                    throw new NoSuchElementException();
                }

                return a[position++];
            }

            @Override
            public long count() throws E {
                return len - position; //NOSONAR
            }

            @Override
            public void advance(long n) throws E {
                if (n > len - position) {
                    position = len;
                } else {
                    position += n;
                }
            }
        });
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @return
     */
    public static  ExceptionalStream of(final Collection c) {
        if (N.isNullOrEmpty(c)) {
            return empty();
        }

        @SuppressWarnings("deprecation")
        final T[] a = (T[]) InternalUtil.getInternalArray(c);

        if (a != null) {
            final int len = c.size();

            return newStream(new ExceptionalIterator() {
                private int position = 0;

                @Override
                public boolean hasNext() throws E {
                    return position < len;
                }

                @Override
                public T next() throws E {
                    if (position >= len) {
                        throw new NoSuchElementException();
                    }

                    return a[position++];
                }

                @Override
                public long count() throws E {
                    return len - position; //NOSONAR
                }

                @Override
                public void advance(long n) throws E {
                    if (n > len - position) {
                        position = len;
                    } else {
                        position += n;
                    }
                }
            });
        }

        return of(c.iterator());
    }

    /**
     *
     * @param 
     * @param 
     * @param iter
     * @return
     */
    public static  ExceptionalStream of(final Iterator iter) {
        if (iter == null) {
            return empty();
        }

        return newStream(ExceptionalIterator. of(iter));
    }

    /**
     *
     * @param 
     * @param 
     * @param iterable
     * @return
     */
    public static  ExceptionalStream of(final Iterable iterable) {
        if (iterable == null) {
            return empty();
        }

        if (iterable instanceof Collection) {
            return of((Collection) iterable);
        } else {
            return of(iterable.iterator());
        }
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param 
     * @param m
     * @return
     */
    public static  ExceptionalStream, E> of(final Map m) {
        if (N.isNullOrEmpty(m)) {
            return empty();
        }

        return of(m.entrySet());
    }

    /**
     *
     * @param 
     * @param 
     * @param stream
     * @return
     */
    public static  ExceptionalStream of(final Stream stream) {
        return checked(stream, false);
    }

    /**
     *
     * @param 
     * @param 
     * @param stream
     * @return
     */
    public static  ExceptionalStream of(final java.util.stream.Stream stream) {
        if (stream == null) {
            return empty();
        }

        return ExceptionalStream. of(stream.iterator()).onClose(stream::close);
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @param exceptionType
     * @return
     */
    public static  ExceptionalStream of(final Collection c,
            @SuppressWarnings("unused") final Class exceptionType) { //NOSONAR
        return of(c);
    }

    /**
     *
     * @param 
     * @param 
     * @param iter
     * @param exceptionType
     * @return
     */
    public static  ExceptionalStream of(final Iterator iter,
            @SuppressWarnings("unused") final Class exceptionType) { //NOSONAR
        return of(iter);
    }

    /**
     *
     * @param 
     * @param 
     * @param iterable
     * @param exceptionType
     * @return
     */
    public static  ExceptionalStream of(final Iterable iterable,
            @SuppressWarnings("unused") final Class exceptionType) { //NOSONAR
        return of(iterable);
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param 
     * @param m
     * @param exceptionType
     * @return
     */
    public static  ExceptionalStream, E> of(final Map m,
            @SuppressWarnings("unused") final Class exceptionType) { //NOSONAR
        return of(m);
    }

    /**
     *
     * @param 
     * @param 
     * @param stream
     * @param exceptionType
     * @return
     */
    public static  ExceptionalStream of(final Stream stream,
            @SuppressWarnings("unused") final Class exceptionType) { //NOSONAR
        return of(stream);
    }

    /**
     *
     * @param 
     * @param 
     * @param stream
     * @param exceptionType
     * @return
     */
    public static  ExceptionalStream of(final java.util.stream.Stream stream,
            @SuppressWarnings("unused") final Class exceptionType) { //NOSONAR
        return of(stream);
    }

    /**
     *
     *
     * @param 
     * @param a
     * @return
     */
    public static  ExceptionalStream of(final boolean[] a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        final int len = N.len(a);

        return newStream(new ExceptionalIterator() {
            private int position = 0;

            @Override
            public boolean hasNext() throws E {
                return position < len;
            }

            @Override
            public Boolean next() throws E {
                return a[position++];
            }

            @Override
            public long count() throws E {
                return len - position; //NOSONAR
            }

            @Override
            public void advance(long n) throws E {
                if (n > len - position) {
                    position = len;
                } else {
                    position += n;
                }
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param a
     * @return
     */
    public static  ExceptionalStream of(final char[] a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        final int len = N.len(a);

        return newStream(new ExceptionalIterator() {
            private int position = 0;

            @Override
            public boolean hasNext() throws E {
                return position < len;
            }

            @Override
            public Character next() throws E {
                return a[position++];
            }

            @Override
            public long count() throws E {
                return len - position; //NOSONAR
            }

            @Override
            public void advance(long n) throws E {
                if (n > len - position) {
                    position = len;
                } else {
                    position += n;
                }
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param a
     * @return
     */
    public static  ExceptionalStream of(final byte[] a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        final int len = N.len(a);

        return newStream(new ExceptionalIterator() {
            private int position = 0;

            @Override
            public boolean hasNext() throws E {
                return position < len;
            }

            @Override
            public Byte next() throws E {
                return a[position++];
            }

            @Override
            public long count() throws E {
                return len - position; //NOSONAR
            }

            @Override
            public void advance(long n) throws E {
                if (n > len - position) {
                    position = len;
                } else {
                    position += n;
                }
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param a
     * @return
     */
    public static  ExceptionalStream of(final short[] a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        final int len = N.len(a);

        return newStream(new ExceptionalIterator() {
            private int position = 0;

            @Override
            public boolean hasNext() throws E {
                return position < len;
            }

            @Override
            public Short next() throws E {
                return a[position++];
            }

            @Override
            public long count() throws E {
                return len - position; //NOSONAR
            }

            @Override
            public void advance(long n) throws E {
                if (n > len - position) {
                    position = len;
                } else {
                    position += n;
                }
            }
        });
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    public static  ExceptionalStream of(final int[] a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        final int len = N.len(a);

        return newStream(new ExceptionalIterator() {
            private int position = 0;

            @Override
            public boolean hasNext() throws E {
                return position < len;
            }

            @Override
            public Integer next() throws E {
                return a[position++];
            }

            @Override
            public long count() throws E {
                return len - position; //NOSONAR
            }

            @Override
            public void advance(long n) throws E {
                if (n > len - position) {
                    position = len;
                } else {
                    position += n;
                }
            }
        });
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    public static  ExceptionalStream of(final long[] a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        final int len = N.len(a);

        return newStream(new ExceptionalIterator() {
            private int position = 0;

            @Override
            public boolean hasNext() throws E {
                return position < len;
            }

            @Override
            public Long next() throws E {
                return a[position++];
            }

            @Override
            public long count() throws E {
                return len - position; //NOSONAR
            }

            @Override
            public void advance(long n) throws E {
                if (n > len - position) {
                    position = len;
                } else {
                    position += n;
                }
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param a
     * @return
     */
    public static  ExceptionalStream of(final float[] a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        final int len = N.len(a);

        return newStream(new ExceptionalIterator() {
            private int position = 0;

            @Override
            public boolean hasNext() throws E {
                return position < len;
            }

            @Override
            public Float next() throws E {
                return a[position++];
            }

            @Override
            public long count() throws E {
                return len - position; //NOSONAR
            }

            @Override
            public void advance(long n) throws E {
                if (n > len - position) {
                    position = len;
                } else {
                    position += n;
                }
            }
        });
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    public static  ExceptionalStream of(final double[] a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        final int len = N.len(a);

        return newStream(new ExceptionalIterator() {
            private int position = 0;

            @Override
            public boolean hasNext() throws E {
                return position < len;
            }

            @Override
            public Double next() throws E {
                return a[position++];
            }

            @Override
            public long count() throws E {
                return len - position; //NOSONAR
            }

            @Override
            public void advance(long n) throws E {
                if (n > len - position) {
                    position = len;
                } else {
                    position += n;
                }
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param op
     * @return
     */
    public static  ExceptionalStream of(final Optional op) {
        return op == null || !op.isPresent() ? ExceptionalStream. empty() : ExceptionalStream. of(op.get()); //NOSONAR
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param op
     * @return
     */
    public static  ExceptionalStream of(final java.util.Optional op) {
        return op == null || !op.isPresent() ? ExceptionalStream. empty() : ExceptionalStream. of(op.get()); //NOSONAR
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param map
     * @return
     */
    public static  ExceptionalStream ofKeys(final Map map) {
        if (N.isNullOrEmpty(map)) {
            return empty();
        }

        return of(map.keySet());
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param map
     * @param valueFilter
     * @return
     */
    public static  ExceptionalStream ofKeys(final Map map, final Throwables.Predicate valueFilter) {
        if (N.isNullOrEmpty(map)) {
            return empty();
        }

        return ExceptionalStream. of(map).filter(Fnn. testByValue(valueFilter)).map(Fnn. key());
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param map
     * @param filter
     * @return
     */
    public static  ExceptionalStream ofKeys(final Map map,
            final Throwables.BiPredicate filter) {
        if (N.isNullOrEmpty(map)) {
            return empty();
        }

        return ExceptionalStream. of(map).filter(Fn.Entries.ep(filter)).map(Fnn. key());
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param map
     * @return
     */
    public static  ExceptionalStream ofValues(final Map map) {
        if (N.isNullOrEmpty(map)) {
            return empty();
        }

        return of(map.values());
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param map
     * @param keyFilter
     * @return
     */
    public static  ExceptionalStream ofValues(final Map map, final Throwables.Predicate keyFilter) {
        if (N.isNullOrEmpty(map)) {
            return empty();
        }

        return ExceptionalStream. of(map).filter(Fnn. testByKey(keyFilter)).map(Fnn. value());
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param 
     * @param map
     * @param filter
     * @return
     */
    public static  ExceptionalStream ofValues(final Map map,
            final Throwables.BiPredicate filter) {
        if (N.isNullOrEmpty(map)) {
            return empty();
        }

        return ExceptionalStream. of(map).filter(Fn.Entries.ep(filter)).map(Fnn. value());
    }

    //    /**
    //     * Lazy evaluation.
    //     * 

    //     *
    //     * This is equal to: {@code ExceptionalStream.just(supplier).flatmap(it -> it.get())}.
    //     *
    //     * @param supplier
    //     * @return
    //     */
    //    @Beta
    //    public static  ExceptionalStream from(final Throwables.Supplier, ? extends E> supplier) {
    //        N.checkArgNotNull(supplier, "supplier");
    //
    //        return ExceptionalStream., ? extends E>, E> just(supplier)
    //                .flatmap(Throwables.Supplier::get);
    //    }

    /**
     * Lazy evaluation.
     * 

     *
     * This is equal to: {@code ExceptionalStream.just(supplier).flatMap(it -> it.get())}.
     *
     * @param 
     * @param 
     * @param supplier
     * @return
     */
    public static  ExceptionalStream defer(
            final Throwables.Supplier, ? extends E> supplier) {
        N.checkArgNotNull(supplier, "supplier");

        return ExceptionalStream., ? extends E>, E> just(supplier)
                .flatMap(Throwables.Supplier::get);
    }

    /**
     *
     * @param 
     * @param 
     * @param hasNext
     * @param next
     * @return
     */
    public static  ExceptionalStream iterate(final Throwables.BooleanSupplier hasNext,
            final Throwables.Supplier next) {
        N.checkArgNotNull(hasNext, "hasNext");
        N.checkArgNotNull(next, "next");

        return newStream(new ExceptionalIterator() {
            private boolean hasNextVal = false;

            @Override
            public boolean hasNext() throws E {
                if (!hasNextVal) {
                    hasNextVal = hasNext.getAsBoolean();
                }

                return hasNextVal;
            }

            @Override
            public T next() throws E {
                if (!hasNextVal && !hasNext()) {
                    throw new NoSuchElementException();
                }

                hasNextVal = false;
                return next.get();
            }
        });
    }

    /**
     *
     * @param 
     * @param 
     * @param init
     * @param hasNext
     * @param f
     * @return
     */
    public static  ExceptionalStream iterate(final T init, final Throwables.BooleanSupplier hasNext,
            final Throwables.UnaryOperator f) {
        N.checkArgNotNull(hasNext, "hasNext");
        N.checkArgNotNull(f, "f");

        return newStream(new ExceptionalIterator() {
            private final T none = (T) NONE;
            private T t = none;
            private boolean hasNextVal = false;

            @Override
            public boolean hasNext() throws E {
                if (!hasNextVal) {
                    hasNextVal = hasNext.getAsBoolean();
                }

                return hasNextVal;
            }

            @Override
            public T next() throws E {
                if (!hasNextVal && !hasNext()) {
                    throw new NoSuchElementException();
                }

                hasNextVal = false;
                return t = (t == none) ? init : f.apply(t);
            }
        });
    }

    /**
     *
     * @param 
     * @param 
     * @param init
     * @param hasNext
     * @param f
     * @return
     */
    public static  ExceptionalStream iterate(final T init, final Throwables.Predicate hasNext,
            final Throwables.UnaryOperator f) {
        N.checkArgNotNull(hasNext, "hasNext");
        N.checkArgNotNull(f, "f");

        return newStream(new ExceptionalIterator() {
            private final T none = (T) NONE;
            private T t = none;
            private T cur = none;
            private boolean hasMore = true;
            private boolean hasNextVal = false;

            @Override
            public boolean hasNext() throws E {
                if (!hasNextVal && hasMore) {
                    hasNextVal = hasNext.test((cur = (t == none ? init : f.apply(t))));

                    if (!hasNextVal) {
                        hasMore = false;
                    }
                }

                return hasNextVal;
            }

            @Override
            public T next() throws E {
                if (!hasNextVal && !hasNext()) {
                    throw new NoSuchElementException();
                }

                t = cur;
                cur = none;
                hasNextVal = false;
                return t;
            }
        });
    }

    /**
     *
     * @param 
     * @param 
     * @param init
     * @param f
     * @return
     */
    public static  ExceptionalStream iterate(final T init, final Throwables.UnaryOperator f) {
        N.checkArgNotNull(f, "f");

        return newStream(new ExceptionalIterator() {
            private final T none = (T) NONE;
            private T t = none;

            @Override
            public boolean hasNext() throws E {
                return true;
            }

            @Override
            public T next() throws E {
                return t = t == none ? init : f.apply(t);
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param supplier
     * @return
     */
    public static  ExceptionalStream generate(final Throwables.Supplier supplier) {
        N.checkArgNotNull(supplier, "supplier");

        return newStream(new ExceptionalIterator() {
            @Override
            public boolean hasNext() throws E {
                return true;
            }

            @Override
            public T next() throws E {
                return supplier.get();
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param element
     * @param n
     * @return
     */
    public static  ExceptionalStream repeat(final T element, final long n) {
        N.checkArgNotNegative(n, "n");

        if (n == 0) {
            return empty();
        }

        return newStream(new ExceptionalIterator() {
            private long cnt = n;

            @Override
            public boolean hasNext() throws E {
                return cnt > 0;
            }

            @Override
            public T next() throws E {
                if (cnt-- <= 0) {
                    throw new NoSuchElementException();
                }

                return element;
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param startInclusive
     * @param endExclusive
     * @return
     */
    public static  ExceptionalStream range(final int startInclusive, final int endExclusive) {
        return IntStream.range(startInclusive, endExclusive).boxed(). checked();
    }

    /**
     *
     *
     * @param 
     * @param startInclusive
     * @param endExclusive
     * @param by
     * @return
     */
    public static  ExceptionalStream range(final int startInclusive, final int endExclusive, final int by) {
        return IntStream.range(startInclusive, endExclusive, by).boxed(). checked();
    }

    /**
     *
     *
     * @param 
     * @param startInclusive
     * @param endExclusive
     * @return
     */
    public static  ExceptionalStream rangeClosed(final int startInclusive, final int endExclusive) {
        return IntStream.rangeClosed(startInclusive, endExclusive).boxed(). checked();
    }

    /**
     *
     *
     * @param 
     * @param startInclusive
     * @param endExclusive
     * @param by
     * @return
     */
    public static  ExceptionalStream rangeClosed(final int startInclusive, final int endExclusive, final int by) {
        return IntStream.rangeClosed(startInclusive, endExclusive, by).boxed(). checked();
    }

    /**
     *
     *
     * @param 
     * @param str
     * @param delimiter
     * @return
     */
    public static  ExceptionalStream split(final CharSequence str, final CharSequence delimiter) {
        return of(Splitter.with(delimiter).iterate(str));
    }

    /**
     *
     * @param file
     * @return
     */
    public static ExceptionalStream lines(final File file) {
        return lines(file, Charsets.UTF_8);
    }

    /**
     *
     * @param file
     * @param charset
     * @return
     */
    public static ExceptionalStream lines(final File file, final Charset charset) {
        N.checkArgNotNull(file, "file");

        final ExceptionalIterator iter = createLazyLineIterator(file, null, charset, null, true);

        return newStream(iter).onClose(newCloseHandler(iter)); //NOSONAR
    }

    /**
     *
     * @param path
     * @return
     */
    public static ExceptionalStream lines(final Path path) {
        return lines(path, Charsets.UTF_8);
    }

    /**
     *
     * @param path
     * @param charset
     * @return
     */
    public static ExceptionalStream lines(final Path path, final Charset charset) {
        N.checkArgNotNull(path, "path");

        final ExceptionalIterator iter = createLazyLineIterator(null, path, charset, null, true);

        return newStream(iter).onClose(newCloseHandler(iter));
    }

    /**
     *
     * @param reader
     * @return
     */
    public static ExceptionalStream lines(final Reader reader) {
        N.checkArgNotNull(reader, "reader");

        return newStream(createLazyLineIterator(null, null, Charsets.UTF_8, reader, false));
    }

    /**
     *
     *
     * @param parentPath
     * @return
     */
    public static ExceptionalStream listFiles(final File parentPath) {
        if (!parentPath.exists()) {
            return empty();
        }

        return of(parentPath.listFiles());
    }

    /**
     *
     *
     * @param parentPath
     * @param recursively
     * @return
     */
    public static ExceptionalStream listFiles(final File parentPath, final boolean recursively) {
        if (!parentPath.exists()) {
            return empty();
        } else if (!recursively) {
            return of(parentPath.listFiles());
        }

        final ExceptionalIterator iter = new ExceptionalIterator<>() {
            private final Queue paths = N.asLinkedList(parentPath);
            private File[] subFiles = null;
            private int cursor = 0;

            @Override
            public boolean hasNext() {
                if ((subFiles == null || cursor >= subFiles.length) && paths.size() > 0) {
                    cursor = 0;
                    subFiles = null;

                    while (paths.size() > 0) {
                        subFiles = paths.poll().listFiles();

                        if (N.notNullOrEmpty(subFiles)) {
                            break;
                        }
                    }
                }

                return subFiles != null && cursor < subFiles.length;
            }

            @Override
            public File next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }

                if (subFiles[cursor].isDirectory()) {
                    paths.offer(subFiles[cursor]);
                }

                return subFiles[cursor++];
            }
        };

        return newStream(iter);
    }

    /**
     * Creates the lazy line iterator.
     *
     * @param file
     * @param path
     * @param charset
     * @param reader
     * @param closeReader
     * @return
     */
    private static ExceptionalIterator createLazyLineIterator(final File file, final Path path, final Charset charset, final Reader reader,
            final boolean closeReader) {
        return ExceptionalIterator.defer(new Throwables.Supplier, IOException>() {
            private ExceptionalIterator lazyIter = null;

            @Override
            public synchronized ExceptionalIterator get() {
                if (lazyIter == null) {
                    lazyIter = new ExceptionalIterator<>() {
                        private BufferedReader bufferedReader;

                        { //NOSONAR
                            if (reader != null) {
                                bufferedReader = reader instanceof BufferedReader ? ((BufferedReader) reader) : new BufferedReader(reader);
                            } else if (file != null) {
                                bufferedReader = IOUtil.newBufferedReader(file, charset == null ? Charsets.UTF_8 : charset);
                            } else {
                                bufferedReader = IOUtil.newBufferedReader(path, charset == null ? Charsets.UTF_8 : charset);
                            }
                        }

                        private String cachedLine;
                        private boolean finished = false;

                        @Override
                        public boolean hasNext() throws IOException {
                            if (this.cachedLine != null) {
                                return true;
                            } else if (this.finished) {
                                return false;
                            } else {
                                this.cachedLine = this.bufferedReader.readLine();
                                if (this.cachedLine == null) {
                                    this.finished = true;
                                    return false;
                                } else {
                                    return true;
                                }
                            }
                        }

                        @Override
                        public String next() throws IOException {
                            if (!this.hasNext()) {
                                throw new NoSuchElementException("No more lines");
                            } else {
                                String res = this.cachedLine;
                                this.cachedLine = null;
                                return res;
                            }
                        }

                        @Override
                        public void close() throws IOException {
                            if (closeReader) {
                                IOUtil.close(bufferedReader);
                            }
                        }
                    };
                }

                return lazyIter;
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  ExceptionalStream concat(final T[]... a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        return of(Iterators.concat(a));
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  ExceptionalStream concat(final Iterable... a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        return of(Iterators.concat(a));
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  ExceptionalStream concat(final Iterator... a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        return of(Iterators.concat(a));
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  ExceptionalStream concat(final ExceptionalStream... a) {
        if (N.isNullOrEmpty(a)) {
            return empty();
        }

        return concat(Array.asList(a));
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @return
     */
    public static  ExceptionalStream concat(final Collection> c) {
        if (N.isNullOrEmpty(c)) {
            return empty();
        }

        return newStream(new ExceptionalIterator() {
            private final Iterator> iterators = c.iterator();
            private ExceptionalStream cur;
            private ExceptionalIterator iter;

            @Override
            public boolean hasNext() throws E {
                while ((iter == null || !iter.hasNext()) && iterators.hasNext()) {
                    if (cur != null) {
                        cur.close();
                    }

                    cur = iterators.next();
                    iter = cur == null ? null : cur.elements;
                }

                return iter != null && iter.hasNext();
            }

            @Override
            public T next() throws E {
                if ((iter == null || !iter.hasNext()) && !hasNext()) {
                    throw new NoSuchElementException();
                }

                return iter.next();
            }
        }, mergeCloseHandlers(c));
    }

    /**
     * Zip together the "a" and "b" arrays until one of them runs out of values.
     * Each pair of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final A[] a, final B[] b,
            final Throwables.BiFunction zipFunction) {
        return zip(ObjIterator.of(a), ObjIterator.of(b), zipFunction);
    }

    /**
     * Zip together the "a", "b" and "c" arrays until one of them runs out of values.
     * Each triple of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final A[] a, final B[] b, final C[] c,
            final Throwables.TriFunction zipFunction) {
        return zip(ObjIterator.of(a), ObjIterator.of(b), ObjIterator.of(c), zipFunction);
    }

    /**
     * Zip together the "a" and "b" arrays until one of them runs out of values.
     * Each pair of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final Iterable a, final Iterable b,
            final Throwables.BiFunction zipFunction) {
        return zip(N.iterate(a), N.iterate(b), zipFunction);
    }

    /**
     * Zip together the "a", "b" and "c" arrays until one of them runs out of values.
     * Each triple of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final Iterable a, final Iterable b,
            final Iterable c, final Throwables.TriFunction zipFunction) {
        return zip(N.iterate(a), N.iterate(b), N.iterate(c), zipFunction);
    }

    /**
     * Zip together the "a" and "b" iterators until one of them runs out of values.
     * Each pair of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final Iterator a, final Iterator b,
            final Throwables.BiFunction zipFunction) {
        return newStream(new ExceptionalIterator() {
            private final Iterator iterA = a == null ? ObjIterator. empty() : a;
            private final Iterator iterB = b == null ? ObjIterator. empty() : b;

            @Override
            public boolean hasNext() throws E {
                return iterA.hasNext() && iterB.hasNext();
            }

            @Override
            public T next() throws E {
                return zipFunction.apply(iterA.next(), iterB.next());
            }
        });
    }

    /**
     * Zip together the "a", "b" and "c" iterators until one of them runs out of values.
     * Each triple of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final Iterator a, final Iterator b,
            final Iterator c, final Throwables.TriFunction zipFunction) {
        return newStream(new ExceptionalIterator() {
            private final Iterator iterA = a == null ? ObjIterator. empty() : a;
            private final Iterator iterB = b == null ? ObjIterator. empty() : b;
            private final Iterator iterC = c == null ? ObjIterator. empty() : c;

            @Override
            public boolean hasNext() throws E {
                return iterA.hasNext() && iterB.hasNext() && iterC.hasNext();
            }

            @Override
            public T next() throws E {
                return zipFunction.apply(iterA.next(), iterB.next(), iterC.next());
            }
        });
    }

    /**
     * Zip together the "a" and "b" streams until one of them runs out of values.
     * Each pair of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final ExceptionalStream a,
            final ExceptionalStream b, final Throwables.BiFunction zipFunction) {
        return newStream(new ExceptionalIterator() {
            private final ExceptionalIterator iterA = iterate(a);
            private final ExceptionalIterator iterB = iterate(b);

            @Override
            public boolean hasNext() throws E {
                return iterA.hasNext() && iterB.hasNext();
            }

            @Override
            public T next() throws E {
                return zipFunction.apply(iterA.next(), iterB.next());
            }
        }, mergeCloseHandlers(Array.asList(a, b)));
    }

    /**
     * Zip together the "a", "b" and "c" streams until one of them runs out of values.
     * Each triple of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final ExceptionalStream a,
            final ExceptionalStream b, final ExceptionalStream c,
            final Throwables.TriFunction zipFunction) {
        return newStream(new ExceptionalIterator() {
            private final ExceptionalIterator iterA = iterate(a);
            private final ExceptionalIterator iterB = iterate(b);
            private final ExceptionalIterator iterC = iterate(c);

            @Override
            public boolean hasNext() throws E {
                return iterA.hasNext() && iterB.hasNext() && iterC.hasNext();
            }

            @Override
            public T next() throws E {
                return zipFunction.apply(iterA.next(), iterB.next(), iterC.next());
            }
        }, mergeCloseHandlers(Array.asList(a, b, c)));
    }

    /**
     * Zip together the "a" and "b" iterators until all of them runs out of values.
     * Each pair of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param valueForNoneA value to fill if "a" runs out of values first.
     * @param valueForNoneB value to fill if "b" runs out of values first.
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final A[] a, final B[] b, final A valueForNoneA, final B valueForNoneB,
            final Throwables.BiFunction zipFunction) {
        return zip(ObjIterator.of(a), ObjIterator.of(b), valueForNoneA, valueForNoneB, zipFunction);
    }

    /**
     * Zip together the "a", "b" and "c" iterators until all of them runs out of values.
     * Each triple of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param valueForNoneA value to fill if "a" runs out of values.
     * @param valueForNoneB value to fill if "b" runs out of values.
     * @param valueForNoneC value to fill if "c" runs out of values.
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final A[] a, final B[] b, final C[] c, final A valueForNoneA,
            final B valueForNoneB, final C valueForNoneC, final Throwables.TriFunction zipFunction) {
        return zip(ObjIterator.of(a), ObjIterator.of(b), ObjIterator.of(c), valueForNoneA, valueForNoneB, valueForNoneC, zipFunction);
    }

    /**
     * Zip together the "a" and "b" iterators until all of them runs out of values.
     * Each pair of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param valueForNoneA value to fill if "a" runs out of values first.
     * @param valueForNoneB value to fill if "b" runs out of values first.
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final Iterable a, final Iterable b,
            final A valueForNoneA, final B valueForNoneB, final Throwables.BiFunction zipFunction) {
        return zip(N.iterate(a), N.iterate(b), valueForNoneA, valueForNoneB, zipFunction);
    }

    /**
     * Zip together the "a", "b" and "c" iterators until all of them runs out of values.
     * Each triple of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param valueForNoneA value to fill if "a" runs out of values.
     * @param valueForNoneB value to fill if "b" runs out of values.
     * @param valueForNoneC value to fill if "c" runs out of values.
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final Iterable a, final Iterable b,
            final Iterable c, final A valueForNoneA, final B valueForNoneB, final C valueForNoneC,
            final Throwables.TriFunction zipFunction) {
        return zip(N.iterate(a), N.iterate(b), N.iterate(c), valueForNoneA, valueForNoneB, valueForNoneC, zipFunction);
    }

    /**
     * Zip together the "a" and "b" iterators until all of them runs out of values.
     * Each pair of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param valueForNoneA value to fill if "a" runs out of values first.
     * @param valueForNoneB value to fill if "b" runs out of values first.
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final Iterator a, final Iterator b,
            final A valueForNoneA, final B valueForNoneB, final Throwables.BiFunction zipFunction) {
        return newStream(new ExceptionalIterator() {
            private final Iterator iterA = a == null ? ObjIterator. empty() : a;
            private final Iterator iterB = b == null ? ObjIterator. empty() : b;

            @Override
            public boolean hasNext() throws E {
                return iterA.hasNext() || iterB.hasNext();
            }

            @Override
            public T next() throws E {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }

                return zipFunction.apply(iterA.hasNext() ? iterA.next() : valueForNoneA, iterB.hasNext() ? iterB.next() : valueForNoneB);
            }
        });
    }

    /**
     * Zip together the "a", "b" and "c" iterators until all of them runs out of values.
     * Each triple of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param valueForNoneA value to fill if "a" runs out of values.
     * @param valueForNoneB value to fill if "b" runs out of values.
     * @param valueForNoneC value to fill if "c" runs out of values.
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final Iterator a, final Iterator b,
            final Iterator c, final A valueForNoneA, final B valueForNoneB, final C valueForNoneC,
            final Throwables.TriFunction zipFunction) {
        return newStream(new ExceptionalIterator() {
            private final Iterator iterA = a == null ? ObjIterator. empty() : a;
            private final Iterator iterB = b == null ? ObjIterator. empty() : b;
            private final Iterator iterC = c == null ? ObjIterator. empty() : c;

            @Override
            public boolean hasNext() throws E {
                return iterA.hasNext() || iterB.hasNext() || iterC.hasNext();
            }

            @Override
            public T next() throws E {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }

                return zipFunction.apply(iterA.hasNext() ? iterA.next() : valueForNoneA, iterB.hasNext() ? iterB.next() : valueForNoneB,
                        iterC.hasNext() ? iterC.next() : valueForNoneC);
            }
        });
    }

    /**
     * Zip together the "a" and "b" streams until one of them runs out of values.
     * Each pair of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param valueForNoneA
     * @param valueForNoneB
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final ExceptionalStream a,
            final ExceptionalStream b, final A valueForNoneA, final B valueForNoneB,
            final Throwables.BiFunction zipFunction) {
        return newStream(new ExceptionalIterator() {
            private final ExceptionalIterator iterA = iterate(a);
            private final ExceptionalIterator iterB = iterate(b);

            @Override
            public boolean hasNext() throws E {
                return iterA.hasNext() || iterB.hasNext();
            }

            @Override
            public T next() throws E {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }

                return zipFunction.apply(iterA.hasNext() ? iterA.next() : valueForNoneA, iterB.hasNext() ? iterB.next() : valueForNoneB);
            }
        }, mergeCloseHandlers(Array.asList(a, b)));
    }

    /**
     * Zip together the "a", "b" and "c" streams until one of them runs out of values.
     * Each triple of values is combined into a single value using the supplied zipFunction function.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param valueForNoneA
     * @param valueForNoneB
     * @param valueForNoneC
     * @param zipFunction
     * @return
     */
    public static  ExceptionalStream zip(final ExceptionalStream a,
            final ExceptionalStream b, final ExceptionalStream c, final A valueForNoneA, final B valueForNoneB,
            final C valueForNoneC, final Throwables.TriFunction zipFunction) {
        return newStream(new ExceptionalIterator() {
            private final ExceptionalIterator iterA = iterate(a);
            private final ExceptionalIterator iterB = iterate(b);
            private final ExceptionalIterator iterC = iterate(c);

            @Override
            public boolean hasNext() throws E {
                return iterA.hasNext() || iterB.hasNext() || iterC.hasNext();
            }

            @Override
            public T next() throws E {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }

                return zipFunction.apply(iterA.hasNext() ? iterA.next() : valueForNoneA, iterB.hasNext() ? iterB.next() : valueForNoneB,
                        iterC.hasNext() ? iterC.next() : valueForNoneC);
            }
        }, mergeCloseHandlers(Array.asList(a, b, c)));
    }

    private static  Deque> mergeCloseHandlers(
            Collection> closeHandlersList) {
        if (N.isNullOrEmpty(closeHandlersList)) {
            return null;
        }

        int count = 0;

        for (ExceptionalStream s : closeHandlersList) {
            count += N.size(s.closeHandlers);
        }

        if (count == 0) {
            return null;
        }

        final Deque> newCloseHandlers = new ArrayDeque<>(count);

        for (ExceptionalStream s : closeHandlersList) {
            if (s.isClosed || isEmptyCloseHandlers(s.closeHandlers)) {
                continue;
            }

            newCloseHandlers.addAll(s.closeHandlers);
        }

        return newCloseHandlers;
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
     * @return
     */
    public static  ExceptionalStream merge(final T[] a, final T[] b,
            final Throwables.BiFunction nextSelector) {
        if (N.isNullOrEmpty(a)) {
            return of(b);
        } else if (N.isNullOrEmpty(b)) {
            return of(a);
        }

        return newStream(new ExceptionalIterator() {
            private final int lenA = a.length;
            private final int lenB = b.length;
            private int cursorA = 0;
            private int cursorB = 0;

            @Override
            public boolean hasNext() {
                return cursorA < lenA || cursorB < lenB;
            }

            @Override
            public T next() throws E {
                if (cursorA < lenA) {
                    if (cursorB < lenB) {
                        if (nextSelector.apply(a[cursorA], b[cursorB]) == MergeResult.TAKE_FIRST) {
                            return a[cursorA++];
                        } else {
                            return b[cursorB++];
                        }
                    } else {
                        return a[cursorA++];
                    }
                } else if (cursorB < lenB) {
                    return b[cursorB++];
                } else {
                    throw new NoSuchElementException();
                }
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
     * @return
     */
    public static  ExceptionalStream merge(final T[] a, final T[] b, final T[] c,
            final Throwables.BiFunction nextSelector) {
        return merge(merge(a, b, nextSelector).iteratorEx(), ExceptionalIterator. of(N.iterate(c)), nextSelector);
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
     * @return
     */
    public static  ExceptionalStream merge(final Iterable a, final Iterable b,
            final Throwables.BiFunction nextSelector) {
        return merge(N.iterate(a), N.iterate(b), nextSelector);
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
     * @return
     */
    public static  ExceptionalStream merge(final Iterable a, final Iterable b,
            final Iterable c, final Throwables.BiFunction nextSelector) {
        return merge(N.iterate(a), N.iterate(b), N.iterate(c), nextSelector);
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
     * @return
     */
    public static  ExceptionalStream merge(final Iterator a, final Iterator b,
            final Throwables.BiFunction nextSelector) {
        return merge(ExceptionalIterator. of(a), ExceptionalIterator. of(b), nextSelector);
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
     * @return
     */
    public static  ExceptionalStream merge(final Iterator a, final Iterator b,
            final Iterator c, final Throwables.BiFunction nextSelector) {
        return merge(merge(a, b, nextSelector).iteratorEx(), ExceptionalIterator. of(c), nextSelector);
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
     * @return
     */
    public static  ExceptionalStream merge(final ExceptionalStream a, final ExceptionalStream b,
            final Throwables.BiFunction nextSelector) {
        return merge(iterate(a), iterate(b), nextSelector).onClose(() -> {
            try {
                if (a != null) {
                    a.close();
                }
            } finally {
                if (b != null) {
                    b.close();
                }
            }
        });
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @param nextSelector
     * @return
     */
    public static  ExceptionalStream merge(final ExceptionalStream a, final ExceptionalStream b,
            final ExceptionalStream c, final Throwables.BiFunction nextSelector) {
        return merge(merge(a, b, nextSelector), c, nextSelector);
    }

    static  ExceptionalStream merge(final ExceptionalIterator a, final ExceptionalIterator b,
            final Throwables.BiFunction nextSelector) {
        return newStream(new ExceptionalIterator() {
            private final ExceptionalIterator iterA = a == null ? ExceptionalIterator.EMPTY : (ExceptionalIterator) a;
            private final ExceptionalIterator iterB = b == null ? ExceptionalIterator.EMPTY : (ExceptionalIterator) b;

            private T nextA = null;
            private T nextB = null;
            private boolean hasNextA = false;
            private boolean hasNextB = false;

            @Override
            public boolean hasNext() throws E {
                return hasNextA || hasNextB || iterA.hasNext() || iterB.hasNext();
            }

            @Override
            public T next() throws E {
                if (hasNextA) {
                    if (iterB.hasNext()) {
                        if (nextSelector.apply(nextA, (nextB = iterB.next())) == MergeResult.TAKE_FIRST) {
                            hasNextA = false;
                            hasNextB = true;
                            return nextA;
                        } else {
                            return nextB;
                        }
                    } else {
                        hasNextA = false;
                        return nextA;
                    }
                } else if (hasNextB) {
                    if (iterA.hasNext()) {
                        if (nextSelector.apply((nextA = iterA.next()), nextB) == MergeResult.TAKE_FIRST) {
                            return nextA;
                        } else {
                            hasNextA = true;
                            hasNextB = false;
                            return nextB;
                        }
                    } else {
                        hasNextB = false;
                        return nextB;
                    }
                } else if (iterA.hasNext()) {
                    if (iterB.hasNext()) {
                        if (nextSelector.apply((nextA = iterA.next()), (nextB = iterB.next())) == MergeResult.TAKE_FIRST) {
                            hasNextB = true;
                            return nextA;
                        } else {
                            hasNextA = true;
                            return nextB;
                        }
                    } else {
                        return iterA.next();
                    }
                } else if (iterB.hasNext()) {
                    return iterB.next();
                } else {
                    throw new NoSuchElementException();
                }
            }
        });
    }

    /**
     *
     * @param predicate
     * @return
     */
    @IntermediateOp
    public ExceptionalStream filter(final Throwables.Predicate predicate) {
        assertNotClosed();

        return newStream(new ExceptionalIterator() {
            private boolean hasNext = false;
            private T next = null;

            @Override
            public boolean hasNext() throws E {
                if (!hasNext) {
                    while (elements.hasNext()) {
                        next = elements.next();

                        if (predicate.test(next)) {
                            hasNext = true;
                            break;
                        }
                    }
                }

                return hasNext;
            }

            @Override
            public T next() throws E {
                if (!hasNext && !hasNext()) {
                    throw new NoSuchElementException();
                }

                hasNext = false;

                return next;
            }
        }, sorted, cmp, closeHandlers);
    }

    /**
     *
     * @param predicate
     * @param actionOnDroppedItem
     * @return
     */
    @IntermediateOp
    public ExceptionalStream filter(final Throwables.Predicate predicate,
            final Throwables.Consumer actionOnDroppedItem) {
        assertNotClosed();

        return filter(value -> {
            if (!predicate.test(value)) {
                actionOnDroppedItem.accept(value);
                return false;
            }

            return true;
        });
    }

    /**
     *
     * @param predicate
     * @return
     */
    @IntermediateOp
    public ExceptionalStream takeWhile(final Throwables.Predicate predicate) {
        assertNotClosed();

        return newStream(new ExceptionalIterator() {
            private boolean hasMore = true;
            private boolean hasNext = false;
            private T next = null;

            @Override
            public boolean hasNext() throws E {
                if (!hasNext && hasMore && elements.hasNext()) {
                    next = elements.next();

                    if (predicate.test(next)) {
                        hasNext = true;
                    } else {
                        hasMore = false;
                    }
                }

                return hasNext;
            }

            @Override
            public T next() throws E {
                if (!hasNext && !hasNext()) {
                    throw new NoSuchElementException();
                }

                hasNext = false;

                return next;
            }
        }, sorted, cmp, closeHandlers);
    }

    /**
     *
     * @param predicate
     * @return
     */
    @IntermediateOp
    public ExceptionalStream dropWhile(final Throwables.Predicate predicate) {
        assertNotClosed();

        return newStream(new ExceptionalIterator() {
            private boolean hasNext = false;
            private T next = null;
            private boolean dropped = false;

            @Override
            public boolean hasNext() throws E {
                if (!hasNext) {
                    if (!dropped) {
                        dropped = true;

                        while (elements.hasNext()) {
                            next = elements.next();

                            if (!predicate.test(next)) {
                                hasNext = true;
                                break;
                            }
                        }
                    } else if (elements.hasNext()) {
                        next = elements.next();
                        hasNext = true;
                    }
                }

                return hasNext;
            }

            @Override
            public T next() throws E {
                if (!hasNext && !hasNext()) {
                    throw new NoSuchElementException();
                }

                hasNext = false;

                return next;
            }

        }, sorted, cmp, closeHandlers);
    }

    /**
     *
     * @param predicate
     * @param actionOnDroppedItem
     * @return
     */
    @IntermediateOp
    public ExceptionalStream dropWhile(final Throwables.Predicate predicate,
            final Throwables.Consumer actionOnDroppedItem) {
        assertNotClosed();

        return dropWhile(value -> {
            if (!predicate.test(value)) {
                actionOnDroppedItem.accept(value);
                return false;
            }

            return true;
        });
    }

    /**
     *
     * @param predicate
     * @return
     */
    @Beta
    @IntermediateOp
    public ExceptionalStream skipUntil(final Throwables.Predicate predicate) {
        return dropWhile(Fnn.not(predicate));
    }

    /**
     * Distinct and filter by occurrences.
     *
     * @return
     */
    @IntermediateOp
    public ExceptionalStream distinct() {
        assertNotClosed();

        final Set