• Home
• com.landawn
• abacus-util-all
• 0.9.79
• source code
• Seq.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.Seq Maven / Gradle / Ivy

/*
 * Copyright (c) 2017, 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.util.AbstractCollection;
import java.util.AbstractList;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.ConcurrentModificationException;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Random;
import java.util.RandomAccess;
import java.util.Set;

import com.landawn.abacus.util.function.BiConsumer;
import com.landawn.abacus.util.function.BiFunction;
import com.landawn.abacus.util.function.BiPredicate;
import com.landawn.abacus.util.function.BinaryOperator;
import com.landawn.abacus.util.function.Consumer;
import com.landawn.abacus.util.function.Function;
import com.landawn.abacus.util.function.IndexedBiFunction;
import com.landawn.abacus.util.function.IndexedConsumer;
import com.landawn.abacus.util.function.IntFunction;
import com.landawn.abacus.util.function.Predicate;
import com.landawn.abacus.util.function.Supplier;
import com.landawn.abacus.util.function.ToBooleanFunction;
import com.landawn.abacus.util.function.ToByteFunction;
import com.landawn.abacus.util.function.ToCharFunction;
import com.landawn.abacus.util.function.ToDoubleFunction;
import com.landawn.abacus.util.function.ToFloatFunction;
import com.landawn.abacus.util.function.ToIntFunction;
import com.landawn.abacus.util.function.ToLongFunction;
import com.landawn.abacus.util.function.ToShortFunction;
import com.landawn.abacus.util.function.TriConsumer;
import com.landawn.abacus.util.function.TriFunction;
import com.landawn.abacus.util.stream.Collector;
import com.landawn.abacus.util.stream.Collectors;

/**
 * It's an read-only wrapper for Collection to support more daily used/functional methods.
 * All the operations are null safety. And an empty String/Array/Collection/Optional/NullabLe will be returned if possible, instead of null.
 * 
 * 

 * Seq should not be passed as a parameter or returned as a result because it's a pure utility class for the operations/calculation based on Collection/Array
 * 
 * @since 0.8
 * 
 * @author Haiyang Li
 */
public final class Seq extends ImmutableCollection {
    /**
     * The returned Seq and the specified Collection are backed by the same data.
     * Any changes to one will appear in the other.
     * 
     * @param c
     */
    Seq(final Collection c) {
        super(c);
    }

    public static  Seq just(T t) {
        return of(t);
    }

    @SafeVarargs
    public static  Seq of(final T... a) {
        return of(Arrays.asList(a));
    }

    /**
     * The returned Seq and the specified Collection are backed by the same data.
     * Any changes to one will appear in the other.
     * 
     * @param c
     * @return
     * @throws NullPointerException if the specified Collection is null.
     */
    public static  Seq of(Collection c) {
        return new Seq<>(c);
    }

    /**
     * 
     * @param map
     * @return
     * @throws NullPointerException if the specified Map is null.
     */
    public static  Seq> of(Map map) {
        return of(map == null ? null : map.entrySet());
    }

    /**
     * Returns the Collection the Seq is backed with recursively.
     * 
     * @return
     */
    public Collection interior() {
        if (coll == null) {
            return coll;
        }

        Collection tmp = coll;

        if (tmp instanceof Seq) {
            while (tmp instanceof Seq) {
                tmp = ((Seq) tmp).coll;
            }
        }

        if (tmp instanceof SubCollection) {
            while (tmp instanceof SubCollection) {
                tmp = ((SubCollection) tmp).c;
            }
        }

        if (tmp instanceof Seq) {
            return ((Seq) tmp).interior();
        } else {
            return tmp;
        }
    }

    @Override
    public boolean contains(Object e) {
        if (N.isNullOrEmpty(coll)) {
            return false;
        }

        return coll.contains(e);
    }

    @Override
    public boolean containsAll(Collection c) {
        if (N.isNullOrEmpty(coll)) {
            return false;
        } else if (N.isNullOrEmpty(c)) {
            return true;
        }

        return coll.containsAll(c);
    }

    public boolean containsAll(Object[] a) {
        if (N.isNullOrEmpty(coll)) {
            return false;
        } else if (N.isNullOrEmpty(a)) {
            return true;
        }

        return containsAll(Arrays.asList(a));
    }

    public boolean containsAny(Collection c) {
        if (N.isNullOrEmpty(coll) || N.isNullOrEmpty(c)) {
            return false;
        }

        return !disjoint(c);
    }

    public boolean containsAny(Object[] a) {
        if (N.isNullOrEmpty(coll) || N.isNullOrEmpty(a)) {
            return false;
        }

        return !disjoint(a);
    }

    public boolean disjoint(final Collection c) {
        return Seq.disjoint(this.coll, c);
    }

    public boolean disjoint(final Object[] a) {
        if (N.isNullOrEmpty(a)) {
            return true;
        }

        return disjoint(Arrays.asList(a));
    }

    /**
     * 
     * @param b
     * @return
     * @see IntList#intersection(IntList)
     */
    public List intersection(Collection b) {
        if (N.isNullOrEmpty(coll) || N.isNullOrEmpty(b)) {
            return new ArrayList<>();
        }

        final Multiset bOccurrences = Multiset.from(b);
        final List result = new ArrayList<>(N.min(9, size(), b.size()));

        for (T e : coll) {
            if (bOccurrences.getAndRemove(e) > 0) {
                result.add(e);
            }
        }

        return result;
    }

    public List intersection(final Object[] a) {
        if (N.isNullOrEmpty(coll) || N.isNullOrEmpty(a)) {
            return new ArrayList<>();
        }

        return intersection(Arrays.asList(a));
    }

    /**
     * 
     * @param b
     * @return
     * @see IntList#difference(IntList)
     */
    public List difference(Collection b) {
        if (N.isNullOrEmpty(coll)) {
            return new ArrayList<>();
        } else if (N.isNullOrEmpty(b)) {
            return new ArrayList<>(coll);
        }

        final Multiset bOccurrences = Multiset.from(b);
        final List result = new ArrayList<>(N.min(size(), N.max(9, size() - b.size())));

        for (T e : coll) {
            if (bOccurrences.getAndRemove(e) < 1) {
                result.add(e);
            }
        }

        return result;
    }

    public List difference(final Object[] a) {
        if (N.isNullOrEmpty(coll)) {
            return new ArrayList<>();
        } else if (N.isNullOrEmpty(a)) {
            return new ArrayList<>(coll);
        }

        return difference(Arrays.asList(a));
    }

    /**
     * 
     * @param b
     * @return this.difference(b).addAll(b.difference(this))
     * @see IntList#symmetricDifference(IntList)
     */
    public List symmetricDifference(Collection b) {
        if (N.isNullOrEmpty(b)) {
            return N.isNullOrEmpty(coll) ? new ArrayList() : new ArrayList<>(coll);
        } else if (N.isNullOrEmpty(coll)) {
            return new ArrayList<>(b);
        }

        final Multiset bOccurrences = Multiset.from(b);
        final List result = new ArrayList<>(N.max(9, Math.abs(size() - b.size())));

        for (T e : coll) {
            if (bOccurrences.getAndRemove(e) < 1) {
                result.add(e);
            }
        }

        for (T e : b) {
            if (bOccurrences.getAndRemove(e) > 0) {
                result.add(e);
            }

            if (bOccurrences.isEmpty()) {
                break;
            }
        }

        return result;
    }

    public List symmetricDifference(final T[] a) {
        if (N.isNullOrEmpty(a)) {
            return N.isNullOrEmpty(coll) ? new ArrayList() : new ArrayList<>(coll);
        } else if (N.isNullOrEmpty(coll)) {
            return N.asList(a);
        }

        return symmetricDifference(Arrays.asList(a));
    }

    public int occurrencesOf(final Object objectToFind) {
        return N.isNullOrEmpty(coll) ? 0 : N.occurrencesOf(coll, objectToFind);
    }

    @SuppressWarnings("rawtypes")
    public NullabLe min() {
        return size() == 0 ? (NullabLe) NullabLe.empty() : NullabLe.of((T) N.min((Collection) coll));
    }

    public NullabLe min(Comparator cmp) {
        return size() == 0 ? (NullabLe) NullabLe.empty() : NullabLe.of(N.min(coll, cmp));
    }

    @SuppressWarnings("rawtypes")
    public NullabLe median() {
        return size() == 0 ? (NullabLe) NullabLe.empty() : NullabLe.of((T) N.median((Collection) coll));
    }

    public NullabLe median(Comparator cmp) {
        return size() == 0 ? (NullabLe) NullabLe.empty() : NullabLe.of(N.median(coll, cmp));
    }

    @SuppressWarnings("rawtypes")
    public NullabLe max() {
        return size() == 0 ? (NullabLe) NullabLe.empty() : NullabLe.of((T) N.max((Collection) coll));
    }

    public NullabLe max(Comparator cmp) {
        return size() == 0 ? (NullabLe) NullabLe.empty() : NullabLe.of(N.max(coll, cmp));
    }

    @SuppressWarnings("rawtypes")
    public NullabLe kthLargest(final int k) {
        return size() < k ? (NullabLe) NullabLe.empty() : NullabLe.of((T) N.kthLargest((Collection) coll, k));
    }

    public NullabLe kthLargest(final int k, Comparator cmp) {
        return size() < k ? (NullabLe) NullabLe.empty() : NullabLe.of(N.kthLargest(coll, k, cmp));
    }

    public int sumInt() {
        if (N.isNullOrEmpty(coll)) {
            return 0;
        }

        int result = 0;

        for (T e : coll) {
            if (e != null) {
                result += ((Number) e).intValue();
            }
        }

        return result;
    }

    public int sumInt(final ToIntFunction mapper) {
        if (N.isNullOrEmpty(coll)) {
            return 0;
        }

        int result = 0;

        for (T e : coll) {
            result += mapper.applyAsInt(e);
        }

        return result;
    }

    public long sumLong() {
        if (N.isNullOrEmpty(coll)) {
            return 0L;
        }

        long result = 0;

        for (T e : coll) {
            if (e != null) {
                result += ((Number) e).longValue();
            }
        }

        return result;
    }

    public long sumLong(final ToLongFunction mapper) {
        if (N.isNullOrEmpty(coll)) {
            return 0L;
        }

        long result = 0L;

        for (T e : coll) {
            result += mapper.applyAsLong(e);
        }

        return result;
    }

    public double sumDouble() {
        if (N.isNullOrEmpty(coll)) {
            return 0D;
        }

        return sumDouble((ToDoubleFunction) new ToDoubleFunction() {
            @Override
            public double applyAsDouble(Number value) {
                return value == null ? 0d : value.doubleValue();
            }
        });
    }

    public double sumDouble(final ToDoubleFunction mapper) {
        return size() == 0 ? 0d : N.sumDouble(coll, mapper);
    }

    public OptionalDouble averageInt() {
        return size() == 0 ? OptionalDouble.empty() : OptionalDouble.of(((double) sumInt()) / size());
    }

    public OptionalDouble averageInt(final ToIntFunction mapper) {
        return size() == 0 ? OptionalDouble.empty() : OptionalDouble.of(((double) sumInt(mapper)) / size());
    }

    public OptionalDouble averageLong() {
        return size() == 0 ? OptionalDouble.empty() : OptionalDouble.of(((double) sumLong()) / size());
    }

    public OptionalDouble averageLong(final ToLongFunction mapper) {
        return size() == 0 ? OptionalDouble.empty() : OptionalDouble.of(((double) sumLong(mapper)) / size());
    }

    public OptionalDouble averageDouble() {
        return averageDouble((ToDoubleFunction) new ToDoubleFunction() {
            @Override
            public double applyAsDouble(Number value) {
                return value == null ? 0d : value.doubleValue();
            }
        });
    }

    public OptionalDouble averageDouble(final ToDoubleFunction mapper) {
        return size() == 0 ? OptionalDouble.empty() : N.averageDouble(coll, mapper);
    }

    public void forEach(final Consumer action) {
        N.forEach(coll, action);
    }

    //    public void forEach(int fromIndex, final int toIndex, final Consumer action) {
    //        N.forEach(coll, fromIndex, toIndex, action);
    //    }

    public void forEach(final IndexedConsumer action) {
        N.forEach(coll, action);
    }

    //    public void forEach(int fromIndex, final int toIndex, final IndexedConsumer action) {
    //        N.forEach(coll, fromIndex, toIndex, action);
    //    }

    public  R forEach(final R seed, BiFunction accumulator, final BiPredicate conditionToBreak) {
        return N.forEach(coll, seed, accumulator, conditionToBreak);
    }

    //    public  R forEach(int fromIndex, final int toIndex, final R seed, final BiFunction accumulator,
    //            final BiPredicate conditionToBreak) {
    //        return N.forEach(coll, fromIndex, toIndex, seed, accumulator, conditionToBreak);
    //    }

    /**
     * Execute accumulator on each element till true is returned by conditionToBreak
     * 
     * @param seed The seed element is both the initial value of the reduction and the default result if there are no elements.
     * @param accumulator
     * @param conditionToBreak break if true is return.
     * @return
     */
    public  R forEach(final R seed, final IndexedBiFunction accumulator, final BiPredicate conditionToBreak) {
        return N.forEach(coll, seed, accumulator, conditionToBreak);
    }

    public  void forEach(final Function> mapper, final BiConsumer action) {
        if (N.isNullOrEmpty(coll)) {
            return;
        }

        for (T e : coll) {
            final Collection c = mapper.apply(e);
            if (N.notNullOrEmpty(c)) {
                for (U u : c) {
                    action.accept(e, u);
                }
            }
        }
    }

    public  void forEach(final Function> mapper2, final Function> mapper3,
            final TriConsumer action) {
        if (N.isNullOrEmpty(coll)) {
            return;
        }

        for (T e : coll) {
            final Collection c2 = mapper2.apply(e);
            if (N.notNullOrEmpty(c2)) {
                for (T2 t2 : c2) {
                    final Collection c3 = mapper3.apply(t2);
                    if (N.notNullOrEmpty(c3)) {
                        for (T3 t3 : c3) {
                            action.accept(e, t2, t3);
                        }
                    }
                }
            }
        }
    }

    public void forEachPair(final BiConsumer action) {
        forEachPair(action, 1);
    }

    public void forEachPair(final BiConsumer action, final int increment) {
        final int windowSize = 2;
        N.checkArgument(windowSize > 0 && increment > 0, "'windowSize'=%s and 'increment'=%s must not be less than 1", windowSize, increment);

        if (N.isNullOrEmpty(coll)) {
            return;
        }

        final Iterator iter = coll.iterator();
        final T NONE = (T) N.NULL_MASK;
        T prev = NONE;

        while (iter.hasNext()) {
            if (increment > windowSize && prev != NONE) {
                int skipNum = increment - windowSize;

                while (skipNum-- > 0 && iter.hasNext()) {
                    iter.next();
                }

                if (iter.hasNext() == false) {
                    break;
                }

                prev = NONE;
            }

            if (increment == 1) {
                action.accept(prev == NONE ? iter.next() : prev, (prev = (iter.hasNext() ? iter.next() : null)));
            } else {
                action.accept(iter.next(), (prev = (iter.hasNext() ? iter.next() : null)));
            }
        }
    }

    public void forEachTriple(final TriConsumer action) {
        forEachTriple(action, 1);
    }

    public void forEachTriple(final TriConsumer action, final int increment) {
        final int windowSize = 3;
        N.checkArgument(windowSize > 0 && increment > 0, "'windowSize'=%s and 'increment'=%s must not be less than 1", windowSize, increment);

        if (N.isNullOrEmpty(coll)) {
            return;
        }

        final Iterator iter = coll.iterator();
        final T NONE = (T) N.NULL_MASK;
        T prev = NONE;
        T prev2 = NONE;

        while (iter.hasNext()) {
            if (increment > windowSize && prev != NONE) {
                int skipNum = increment - windowSize;

                while (skipNum-- > 0 && iter.hasNext()) {
                    iter.next();
                }

                if (iter.hasNext() == false) {
                    break;
                }

                prev = NONE;
            }

            if (increment == 1) {
                action.accept(prev2 == NONE ? iter.next() : prev2, (prev2 = (prev == NONE ? (iter.hasNext() ? iter.next() : null) : prev)),
                        (prev = (iter.hasNext() ? iter.next() : null)));
            } else if (increment == 2) {
                action.accept(prev == NONE ? iter.next() : prev, (prev2 = (iter.hasNext() ? iter.next() : null)),
                        (prev = (iter.hasNext() ? iter.next() : null)));
            } else {
                action.accept(iter.next(), (prev2 = (iter.hasNext() ? iter.next() : null)), (prev = (iter.hasNext() ? iter.next() : null)));
            }
        }
    }

    //    /**
    //     * Execute accumulator on each element till true is returned by conditionToBreak
    //     * 
    //     * @param fromIndex
    //     * @param toIndex
    //     * @param seed The seed element is both the initial value of the reduction and the default result if there are no elements.
    //     * @param accumulator
    //     * @param conditionToBreak break if true is return.
    //     * @return
    //     */
    //    public  R forEach(int fromIndex, final int toIndex, final R seed, final IndexedBiFunction accumulator,
    //            final BiPredicate conditionToBreak) {
    //        return N.forEach(coll, fromIndex, toIndex, seed, accumulator, conditionToBreak);
    //    }

    public NullabLe first() {
        if (size() == 0) {
            return NullabLe.empty();
        }

        if (coll instanceof List && coll instanceof RandomAccess) {
            return NullabLe.of(((List) coll).get(0));
        } else {
            return NullabLe.of(coll.iterator().next());
        }
    }

    /**
     * Return at most first n elements.
     * 
     * @param n
     * @return
     */
    public List first(final int n) {
        N.checkArgument(n >= 0, "'n' can't be negative: " + n);

        if (N.isNullOrEmpty(coll) || n == 0) {
            return new ArrayList<>();
        } else if (coll.size() <= n) {
            return new ArrayList<>(coll);
        } else if (coll instanceof List) {
            return new ArrayList<>(((List) coll).subList(0, n));
        } else {
            return new ArrayList<>(slice(0, n));
        }
    }

    public NullabLe last() {
        if (size() == 0) {
            return NullabLe.empty();
        }

        if (coll instanceof List && coll instanceof RandomAccess) {
            return NullabLe.of(((List) coll).get(size() - 1));
        } else {
            final Iterator iter = iterator();
            T e = null;

            while (iter.hasNext()) {
                e = iter.next();
            }

            return NullabLe.of(e);
        }
    }

    /**
     * Return at most last n elements.
     * 
     * @param n
     * @return
     */
    public List last(final int n) {
        N.checkArgument(n >= 0, "'n' can't be negative: " + n);

        if (N.isNullOrEmpty(coll) || n == 0) {
            return new ArrayList<>();
        } else if (coll.size() <= n) {
            return new ArrayList<>(coll);
        } else if (coll instanceof List) {
            return new ArrayList<>(((List) coll).subList(coll.size() - n, coll.size()));
        } else {
            return new ArrayList<>(slice(coll.size() - n, coll.size()));
        }
    }

    public NullabLe findFirst(Predicate predicate) {
        if (size() == 0) {
            return NullabLe.empty();
        }

        for (T e : coll) {
            if (predicate.test(e)) {
                return NullabLe.of(e);
            }
        }

        return NullabLe.empty();
    }

    public NullabLe findLast(Predicate predicate) {
        if (size() == 0) {
            return NullabLe.empty();
        }

        if (coll instanceof List) {
            final List list = (List) coll;

            if (coll instanceof RandomAccess) {
                for (int i = size() - 1; i >= 0; i--) {
                    if (predicate.test(list.get(i))) {
                        return NullabLe.of(list.get(i));
                    }
                }
            } else {
                final ListIterator iter = list.listIterator(list.size());
                T pre = null;

                while (iter.hasPrevious()) {
                    if (predicate.test((pre = iter.previous()))) {
                        return NullabLe.of(pre);
                    }
                }
            }

            return NullabLe.empty();
        } else {
            T result = (T) N.NULL_MASK;

            for (T e : coll) {
                if (predicate.test(e)) {
                    result = e;
                }
            }

            return result == N.NULL_MASK ? (NullabLe) NullabLe.empty() : NullabLe.of(result);
        }
    }

    public OptionalInt findFirstIndex(Predicate predicate) {
        if (size() == 0) {
            return OptionalInt.empty();
        }

        int idx = 0;

        for (T e : coll) {
            if (predicate.test(e)) {
                return OptionalInt.of(idx);
            }

            idx++;
        }

        return OptionalInt.empty();
    }

    public OptionalInt findLastIndex(Predicate predicate) {
        if (size() == 0) {
            return OptionalInt.empty();
        }

        if (coll instanceof List) {
            final List list = (List) coll;

            if (coll instanceof RandomAccess) {
                for (int i = size() - 1; i >= 0; i--) {
                    if (predicate.test(list.get(i))) {
                        return OptionalInt.of(i);
                    }
                }
            } else {
                final ListIterator iter = list.listIterator(list.size());

                for (int i = size() - 1; iter.hasPrevious(); i--) {
                    if (predicate.test(iter.previous())) {
                        return OptionalInt.of(i);
                    }
                }
            }

            return OptionalInt.empty();
        } else {
            int result = -1;
            int idx = 0;

            for (T e : coll) {
                if (predicate.test(e)) {
                    result = idx;
                }

                idx++;
            }

            return result == -1 ? OptionalInt.empty() : OptionalInt.of(result);
        }
    }

    public NullabLe findFirstOrLast(final Predicate predicateForFirst, final Predicate predicateForLast) {
        if (N.isNullOrEmpty(coll)) {
            return NullabLe. empty();
        }

        final Iterator iter = iterator();
        T last = (T) N.NULL_MASK;
        T next = null;

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

            if (predicateForFirst.test(next)) {
                return NullabLe.of(next);
            } else if (predicateForLast.test(next)) {
                last = next;
            }
        }

        return last == N.NULL_MASK ? NullabLe. empty() : NullabLe.of(last);
    }

    public OptionalInt findFirstOrLastIndex(final Predicate predicateForFirst, final Predicate predicateForLast) {
        if (N.isNullOrEmpty(coll)) {
            return OptionalInt.empty();
        }

        final Iterator iter = iterator();
        T next = null;
        int idx = 0, lastIndex = -1;

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

            if (predicateForFirst.test(next)) {
                return OptionalInt.of(idx);
            } else if (predicateForLast.test(next)) {
                lastIndex = idx;
            }

            idx++;
        }

        return lastIndex == -1 ? OptionalInt.empty() : OptionalInt.of(lastIndex);
    }

    public Pair, NullabLe> findFirstAndLast(final Predicate predicate) {
        return findFirstAndLast(predicate, predicate);
    }

    public Pair, NullabLe> findFirstAndLast(final Predicate predicateForFirst, final Predicate predicateForLast) {
        if (N.isNullOrEmpty(coll)) {
            return Pair.of(NullabLe. empty(), NullabLe. empty());
        }

        return Pair.of(findFirst(predicateForFirst), findLast(predicateForLast));
    }

    public Pair findFirstAndLastIndex(final Predicate predicate) {
        return findFirstAndLastIndex(predicate, predicate);
    }

    public Pair findFirstAndLastIndex(final Predicate predicateForFirst, final Predicate predicateForLast) {
        if (N.isNullOrEmpty(coll)) {
            return Pair.of(OptionalInt.empty(), OptionalInt.empty());
        }

        return Pair.of(findFirstIndex(predicateForFirst), findLastIndex(predicateForLast));
    }

    public boolean allMatch(Predicate filter) {
        if (N.isNullOrEmpty(coll)) {
            return true;
        }

        for (T e : coll) {
            if (filter.test(e) == false) {
                return false;
            }
        }

        return true;
    }

    public boolean anyMatch(Predicate filter) {
        if (N.isNullOrEmpty(coll)) {
            return false;
        }

        for (T e : coll) {
            if (filter.test(e)) {
                return true;
            }
        }

        return false;
    }

    public boolean noneMatch(Predicate filter) {
        if (N.isNullOrEmpty(coll)) {
            return true;
        }

        for (T e : coll) {
            if (filter.test(e)) {
                return false;
            }
        }

        return true;
    }

    public boolean hasDuplicates() {
        return N.hasDuplicates(coll, false);
    }

    public int count(Predicate filter) {
        return N.count(coll, filter);
    }

    public List filter(Predicate filter) {
        return N.filter(coll, filter);
    }

    public List filter(Predicate filter, final int max) {
        return N.filter(coll, filter, max);
    }

    public  List filter(final U seed, final BiPredicate predicate) {
        return filter(new Predicate() {
            @Override
            public boolean test(T value) {
                return predicate.test(value, seed);
            }
        });
    }

    //    public  List filterThenMap(Predicate filter, final Function mapper) {
    //        if (N.isNullOrEmpty(coll)) {
    //            return new ArrayList<>();
    //        }
    //
    //        final List res = new ArrayList<>();
    //
    //        for (T e : coll) {
    //            if (filter.test(e)) {
    //                res.add(mapper.apply(e));
    //            }
    //        }
    //
    //        return res;
    //    }
    //
    //    public  List filterThenFlatMap(Predicate filter, final Function> mapper) {
    //        if (N.isNullOrEmpty(coll)) {
    //            return new ArrayList<>();
    //        }
    //
    //        final List res = new ArrayList<>();
    //
    //        for (T e : coll) {
    //            if (filter.test(e)) {
    //                res.addAll(mapper.apply(e));
    //            }
    //        }
    //
    //        return res;
    //    }
    //
    //    public  List filterThenFlatMap2(Predicate filter, final Function mapper) {
    //        if (N.isNullOrEmpty(coll)) {
    //            return new ArrayList<>();
    //        }
    //
    //        final List res = new ArrayList<>();
    //        R[] a = null;
    //
    //        for (T e : coll) {
    //            if (filter.test(e)) {
    //                a = mapper.apply(e);
    //
    //                if (N.notNullOrEmpty(a)) {
    //                    if (a.length < 9) {
    //                        for (R r : a) {
    //                            res.add(r);
    //                        }
    //                    } else {
    //                        res.addAll(Arrays.asList(a));
    //                    }
    //                }
    //            }
    //        }
    //
    //        return res;
    //    }
    //
    //    public NullabLe filterThenReduce(Predicate filter, final BinaryOperator accumulator) {
    //        if (N.isNullOrEmpty(coll)) {
    //            return NullabLe. empty();
    //        }
    //
    //        T result = (T) N.NULL_MASK;
    //
    //        for (T e : coll) {
    //            if (filter.test(e)) {
    //                result = result == N.NULL_MASK ? e : accumulator.apply(result, e);
    //            }
    //        }
    //
    //        return result == N.NULL_MASK ? NullabLe. empty() : NullabLe.of(result);
    //    }
    //
    //    public  NullabLe filterThenReduce(Predicate filter, final U identity, final BiFunction accumulator) {
    //        if (N.isNullOrEmpty(coll)) {
    //            return NullabLe.of(identity);
    //        }
    //
    //        U result = identity;
    //
    //        for (T e : coll) {
    //            if (filter.test(e)) {
    //                result = accumulator.apply(result, e);
    //            }
    //        }
    //
    //        return NullabLe.of(result);
    //    }
    //
    //    public  R filterThenCollect(Predicate filter, final Supplier supplier, final BiConsumer accumulator) {
    //        final R result = supplier.get();
    //
    //        if (N.notNullOrEmpty(coll)) {
    //            for (T e : coll) {
    //                if (filter.test(e)) {
    //                    accumulator.accept(result, e);
    //                }
    //            }
    //        }
    //
    //        return result;
    //    }
    //
    //    public  R filterThenCollect(Predicate filter, final Collector collector) {
    //        final BiConsumer accumulator = collector.accumulator();
    //        final A result = collector.supplier().get();
    //
    //        if (N.notNullOrEmpty(coll)) {
    //            for (T e : coll) {
    //                if (filter.test(e)) {
    //                    accumulator.accept(result, e);
    //                }
    //            }
    //        }
    //
    //        return collector.finisher().apply(result);
    //    }

    public List takeWhile(Predicate filter) {
        final List result = new ArrayList<>(N.min(9, size()));

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            if (filter.test(e)) {
                result.add(e);
            } else {
                break;
            }
        }

        return result;
    }

    public  List takeWhile(final U seed, final BiPredicate predicate) {
        return takeWhile(new Predicate() {
            @Override
            public boolean test(T value) {
                return predicate.test(value, seed);
            }
        });
    }

    public List takeWhileInclusive(Predicate filter) {
        final List result = new ArrayList<>(N.min(9, size()));

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.add(e);

            if (filter.test(e) == false) {
                break;
            }
        }

        return result;
    }

    public  List takeWhileInclusive(final U seed, final BiPredicate predicate) {
        return takeWhileInclusive(new Predicate() {
            @Override
            public boolean test(T value) {
                return predicate.test(value, seed);
            }
        });
    }

    public List dropWhile(Predicate filter) {
        final List result = new ArrayList<>(N.min(9, size()));

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        final Iterator iter = iterator();
        T e = null;

        while (iter.hasNext()) {
            e = iter.next();

            if (filter.test(e) == false) {
                result.add(e);
                break;
            }
        }

        while (iter.hasNext()) {
            result.add(iter.next());
        }

        return result;
    }

    public  List dropWhile(final U seed, final BiPredicate predicate) {
        return dropWhile(new Predicate() {
            @Override
            public boolean test(T value) {
                return predicate.test(value, seed);
            }
        });
    }

    public List skipUntil(final Predicate filter) {
        return dropWhile(new Predicate() {
            @Override
            public boolean test(T value) {
                return !filter.test(value);
            }
        });
    }

    public  List skipUntil(final U seed, final BiPredicate predicate) {
        return dropWhile(new Predicate() {
            @Override
            public boolean test(T value) {
                return !predicate.test(value, seed);
            }
        });
    }

    public  List map(final Function func) {
        return N.map(coll, func);
    }

    public BooleanList mapToBoolean(final ToBooleanFunction func) {
        return N.mapToBoolean(coll, func);
    }

    public CharList mapToChar(final ToCharFunction func) {
        return N.mapToChar(coll, func);
    }

    public ByteList mapToByte(final ToByteFunction func) {
        return N.mapToByte(coll, func);
    }

    public ShortList mapToShort(final ToShortFunction func) {
        return N.mapToShort(coll, func);
    }

    public IntList mapToInt(final ToIntFunction func) {
        return N.mapToInt(coll, func);
    }

    public LongList mapToLong(final ToLongFunction func) {
        return N.mapToLong(coll, func);
    }

    public FloatList mapToFloat(final ToFloatFunction func) {
        return N.mapToFloat(coll, func);
    }

    public DoubleList mapToDouble(final ToDoubleFunction func) {
        return N.mapToDouble(coll, func);
    }

    public  List flatMap(final Function> func) {
        final List result = new ArrayList<>(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.addAll(func.apply(e));
        }

        return result;
    }

    public  List flatMap2(final Function func) {
        final List result = new ArrayList<>(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        R[] a = null;
        for (T e : coll) {
            a = func.apply(e);

            if (N.notNullOrEmpty(a)) {
                if (a.length < 9) {
                    for (R r : a) {
                        result.add(r);
                    }
                } else {
                    result.addAll(Arrays.asList(a));
                }
            }
        }

        return result;
    }

    public BooleanList flatMapToBoolean(final Function> func) {
        final BooleanList result = new BooleanList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            for (boolean b : func.apply(e)) {
                result.add(b);
            }
        }

        return result;
    }

    public BooleanList flatMapToBoolean2(final Function func) {
        final BooleanList result = new BooleanList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.addAll(func.apply(e));
        }

        return result;
    }

    public CharList flatMapToChar(final Function> func) {
        final CharList result = new CharList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            for (char b : func.apply(e)) {
                result.add(b);
            }
        }

        return result;
    }

    public CharList flatMapToChar2(final Function func) {
        final CharList result = new CharList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.addAll(func.apply(e));
        }

        return result;
    }

    public ByteList flatMapToByte(final Function> func) {
        final ByteList result = new ByteList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            for (byte b : func.apply(e)) {
                result.add(b);
            }
        }

        return result;
    }

    public ByteList flatMapToByte2(final Function func) {
        final ByteList result = new ByteList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.addAll(func.apply(e));
        }

        return result;
    }

    public ShortList flatMapToShort(final Function> func) {
        final ShortList result = new ShortList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            for (short b : func.apply(e)) {
                result.add(b);
            }
        }

        return result;
    }

    public ShortList flatMapToShort2(final Function func) {
        final ShortList result = new ShortList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.addAll(func.apply(e));
        }

        return result;
    }

    public IntList flatMapToInt(final Function> func) {
        final IntList result = new IntList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            for (int b : func.apply(e)) {
                result.add(b);
            }
        }

        return result;
    }

    public IntList flatMapToInt2(final Function func) {
        final IntList result = new IntList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.addAll(func.apply(e));
        }

        return result;
    }

    public LongList flatMapToLong(final Function> func) {
        final LongList result = new LongList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            for (long b : func.apply(e)) {
                result.add(b);
            }
        }

        return result;
    }

    public LongList flatMapToLong2(final Function func) {
        final LongList result = new LongList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.addAll(func.apply(e));
        }

        return result;
    }

    public FloatList flatMapToFloat(final Function> func) {
        final FloatList result = new FloatList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            for (float b : func.apply(e)) {
                result.add(b);
            }
        }

        return result;
    }

    public FloatList flatMapToFloat2(final Function func) {
        final FloatList result = new FloatList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.addAll(func.apply(e));
        }

        return result;
    }

    public DoubleList flatMapToDouble(final Function> func) {
        final DoubleList result = new DoubleList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            for (double b : func.apply(e)) {
                result.add(b);
            }
        }

        return result;
    }

    public DoubleList flatMapToDouble2(final Function func) {
        final DoubleList result = new DoubleList(size() > N.MAX_ARRAY_SIZE / 2 ? N.MAX_ARRAY_SIZE : size() * 2);

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.addAll(func.apply(e));
        }

        return result;
    }

    public  List flatMap(final Function> mapper, final BiFunction func) {
        if (N.isNullOrEmpty(coll)) {
            return new ArrayList();
        }

        final List result = new ArrayList(N.max(9, coll.size()));

        for (T e : coll) {
            final Collection c = mapper.apply(e);
            if (N.notNullOrEmpty(c)) {
                for (U u : c) {
                    result.add(func.apply(e, u));
                }
            }
        }

        return result;
    }

    public  List flatMap(final Function> mapper2,
            final Function> mapper3, final TriFunction func) {
        if (N.isNullOrEmpty(coll)) {
            return new ArrayList();
        }

        final List result = new ArrayList(N.max(9, coll.size()));

        for (T e : coll) {
            final Collection c2 = mapper2.apply(e);
            if (N.notNullOrEmpty(c2)) {
                for (T2 t2 : c2) {
                    final Collection c3 = mapper3.apply(t2);
                    if (N.notNullOrEmpty(c3)) {
                        for (T3 t3 : c3) {
                            result.add(func.apply(e, t2, t3));
                        }
                    }
                }
            }
        }

        return result;
    }

    /**
     * Merge series of adjacent elements which satisfy the given predicate using
     * the merger function and return a new stream.
     * 
     * 

     * This method only run sequentially, even in parallel stream.
     * 
     * @param collapsible
     * @param mergeFunction
     * @return
     */
    public List collapse(final BiPredicate collapsible, final BiFunction mergeFunction) {
        final List result = new ArrayList<>();

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        final Iterator iter = iterator();
        boolean hasNext = false;
        T next = null;

        while (hasNext || iter.hasNext()) {
            T res = hasNext ? next : (next = iter.next());

            while ((hasNext = iter.hasNext())) {
                if (collapsible.test(next, (next = iter.next()))) {
                    res = mergeFunction.apply(res, next);
                } else {
                    break;
                }
            }

            result.add(res);
        }

        return result;
    }

    /**
     * Merge series of adjacent elements which satisfy the given predicate using
     * the merger function and return a new stream.
     * 
     * 

     * This method only run sequentially, even in parallel stream.
     * 
     * @param collapsible
     * @param collector
     * @return
     */
    public  List collapse(final BiPredicate collapsible, final Collector collector) {
        final List result = new ArrayList<>();

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        final Supplier supplier = collector.supplier();
        final BiConsumer accumulator = collector.accumulator();
        final Function finisher = collector.finisher();
        final Iterator iter = iterator();
        boolean hasNext = false;
        T next = null;

        while (hasNext || iter.hasNext()) {
            final A c = supplier.get();
            accumulator.accept(c, hasNext ? next : (next = iter.next()));

            while ((hasNext = iter.hasNext())) {
                if (collapsible.test(next, (next = iter.next()))) {
                    accumulator.accept(c, next);
                } else {
                    break;
                }
            }

            result.add(finisher.apply(c));
        }

        return result;
    }

    /**
     * Returns a {@code Stream} produced by iterative application of a accumulation function
     * to an initial element {@code identity} and next element of the current stream.
     * Produces a {@code Stream} consisting of {@code identity}, {@code acc(identity, value1)},
     * {@code acc(acc(identity, value1), value2)}, etc.
     *
     * 
This is an intermediate operation.
     *
     * 
Example:
     * 
     * accumulator: (a, b) -> a + b
     * stream: [1, 2, 3, 4, 5]
     * result: [1, 3, 6, 10, 15]
     * 
     * 
     * 

     * This method only run sequentially, even in parallel stream.
     *
     * @param accumulator  the accumulation function
     * @return the new stream which has the extract same size as this stream.
     */
    public List scan(final BiFunction accumulator) {
        final List result = new ArrayList<>();

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        final Iterator iter = iterator();
        T next = null;

        if (iter.hasNext()) {
            result.add((next = iter.next()));
        }

        while (iter.hasNext()) {
            result.add((next = accumulator.apply(next, iter.next())));
        }

        return result;
    }

    /**
     * Returns a {@code Stream} produced by iterative application of a accumulation function
     * to an initial element {@code identity} and next element of the current stream.
     * Produces a {@code Stream} consisting of {@code identity}, {@code acc(identity, value1)},
     * {@code acc(acc(identity, value1), value2)}, etc.
     *
     * 
This is an intermediate operation.
     *
     * 
Example:
     * 
     * seed:10
     * accumulator: (a, b) -> a + b
     * stream: [1, 2, 3, 4, 5]
     * result: [11, 13, 16, 20, 25]
     * 
     * 
     * 

     * This method only run sequentially, even in parallel stream.
     *
     * @param seed the initial value. it's only used once by accumulator to calculate the fist element in the returned stream. 
     * It will be ignored if this stream is empty and won't be the first element of the returned stream.
     * 
     * @param accumulator  the accumulation function
     * @return the new stream which has the extract same size as this stream.
     */
    public  List scan(final R seed, final BiFunction accumulator) {
        final List result = new ArrayList<>();

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        final Iterator iter = iterator();
        R next = seed;

        while (iter.hasNext()) {
            result.add((next = accumulator.apply(next, iter.next())));
        }

        return result;
    }

    /**
     * This is equivalent to:
     * 
     * 
     *    if (isEmpty()) {
     *        return NullabLe.empty();
     *    }
     *
     *    final Iterator iter = iterator();
     *    T result = iter.next();
     *
     *    while (iter.hasNext()) {
     *        result = accumulator.apply(result, iter.next());
     *    }
     *
     *    return NullabLe.of(result);
     * 
     * 
     * 
     * @param accumulator
     * @return
     */
    public NullabLe reduce(BinaryOperator accumulator) {
        if (isEmpty()) {
            return NullabLe.empty();
        }

        final Iterator iter = iterator();
        T result = iter.next();

        while (iter.hasNext()) {
            result = accumulator.apply(result, iter.next());
        }

        return NullabLe.of(result);
    }

    /**
     * This is equivalent to:
     * 
     * 
     *     if (isEmpty()) {
     *         return identity;
     *     }
     * 
     *     final Iterator iter =  iterator();
     *     U result = identity;
     * 
     *     while (iter.hasNext()) {
     *         result = accumulator.apply(result, iter.next());
     *     }
     * 
     *     return result;
     * 
     * 
     * 
     * @param identity
     * @param accumulator
     * @return
     */
    public  U reduce(U identity, BiFunction accumulator) {
        if (isEmpty()) {
            return identity;
        }

        final Iterator iter = iterator();
        U result = identity;

        while (iter.hasNext()) {
            result = accumulator.apply(result, iter.next());
        }

        return result;
    }

    public  R collect(final Supplier supplier, final BiConsumer accumulator) {
        final R result = supplier.get();

        if (N.notNullOrEmpty(coll)) {
            for (T e : coll) {
                accumulator.accept(result, e);
            }
        }

        return result;
    }

    public  R collect(final Collector collector) {
        final BiConsumer accumulator = collector.accumulator();
        final A result = collector.supplier().get();

        if (N.notNullOrEmpty(coll)) {
            for (T e : coll) {
                accumulator.accept(result, e);
            }
        }

        return collector.finisher().apply(result);
    }

    public  RR collectAndThen(final Collector downstream, final Function finisher) {
        return finisher.apply(collect(downstream));
    }

    @SafeVarargs
    public final List append(T... a) {
        return append(Arrays.asList(a));
    }

    public List append(final Collection c) {
        return Seq.concat(this, c);
    }

    @SafeVarargs
    public final List prepend(T... a) {
        return prepend(Arrays.asList(a));
    }

    public List prepend(final Collection c) {
        return Seq.concat(c, this);
    }

    public List merge(final Collection b, final BiFunction nextSelector) {
        return Seq.merge(this, b, nextSelector);
    }

    public  List zipWith(final Collection b, final BiFunction zipFunction) {
        return Seq.zip(this, b, zipFunction);
    }

    public  List zipWith(final Collection b, final T valueForNoneA, final B valueForNoneB, final BiFunction zipFunction) {
        return Seq.zip(this, b, valueForNoneA, valueForNoneB, zipFunction);
    }

    public  List zipWith(final Collection b, final Collection c, final TriFunction zipFunction) {
        return Seq.zip(this, b, c, zipFunction);
    }

    public  List zipWith(final Collection b, final Collection c, final T valueForNoneA, final B valueForNoneB, final C valueForNoneC,
            final TriFunction zipFunction) {
        return Seq.zip(this, b, c, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction);
    }

    public List intersperse(T value) {
        if (isEmpty()) {
            return new ArrayList<>();
        }

        final int size = size();
        final List result = new ArrayList<>(size * 2 - 1);
        int idx = 0;

        for (T e : coll) {
            result.add(e);

            if (++idx < size) {
                result.add(value);
            }
        }

        return result;
    }

    public List> indexed() {
        final List> result = new ArrayList<>(size());

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        int idx = 0;

        for (T e : coll) {
            result.add(Indexed.of(e, idx++));
        }

        return result;
    }

    /**
     *
     * @return a new List with distinct elements
     */
    public List distinct() {
        return N.distinct(coll);
    }

    /**
     * 
     * @param keyExtractor don't change value of the input parameter.
     * @return
     */
    public List distinctBy(final Function keyExtractor) {
        return N.distinctBy(coll, keyExtractor);
    }

    @SuppressWarnings("rawtypes")
    public List top(final int n) {
        return N.top((Collection) coll, n);
    }

    public List top(final int n, final Comparator cmp) {
        return N.top(coll, n, cmp);
    }

    /**
     * Returns consecutive sub lists of this list, each of the same size (the final list may be smaller),
     * or an empty List if the specified list is null or empty.
     *
     * @return
     */
    public List> split(int size) {
        return N.split(coll, size);
    }

    public  List> split(final Predicate predicate) {
        N.requireNonNull(predicate);

        if (N.isNullOrEmpty(coll)) {
            return new ArrayList<>();
        }

        final BiFunction predicate2 = new BiFunction() {
            @Override
            public Boolean apply(T t, Object u) {
                return predicate.test(t);
            }
        };

        return split(null, predicate2, null);
    }

    public  List> split(final U identity, final BiFunction predicate, final Consumer identityUpdate) {
        N.requireNonNull(predicate);

        if (N.isNullOrEmpty(coll)) {
            return new ArrayList<>();
        }

        final List> res = new ArrayList<>();
        final Iterator elements = iterator();
        T next = (T) N.NULL_MASK;
        boolean preCondition = false;

        while (next != N.NULL_MASK || elements.hasNext()) {
            final List piece = new ArrayList<>();

            if (next == N.NULL_MASK) {
                next = elements.next();
            }

            while (next != N.NULL_MASK) {
                if (piece.size() == 0) {
                    piece.add(next);
                    preCondition = predicate.apply(next, identity);
                    next = elements.hasNext() ? elements.next() : (T) N.NULL_MASK;
                } else if (predicate.apply(next, identity) == preCondition) {
                    piece.add(next);
                    next = elements.hasNext() ? elements.next() : (T) N.NULL_MASK;
                } else {
                    if (identityUpdate != null) {
                        identityUpdate.accept(identity);
                    }

                    break;
                }
            }

            res.add(piece);
        }

        return res;
    }

    /**
     * 
     * @param n
     * @return
     */
    @SuppressWarnings("rawtypes")
    public Pair, List> splitAt(final int n) {
        N.checkArgument(n >= 0, "'n' can't be negative: ", n);

        List left = null;
        List right = null;

        if (N.isNullOrEmpty(coll)) {
            left = new ArrayList<>();
            right = new ArrayList<>();
        } else if (n == 0) {
            left = new ArrayList<>();
            right = new ArrayList<>(coll);
        } else if (n >= coll.size()) {
            left = new ArrayList<>();
            right = new ArrayList<>(coll);
        } else if (coll instanceof List) {
            left = new ArrayList<>(((List) coll).subList(0, n));
            right = new ArrayList<>(((List) coll).subList(n, size()));
        } else {
            left = new ArrayList<>(slice(0, n));
            right = new ArrayList<>(slice(n, size()));
        }

        return Pair.of(left, right);
    }

    public Pair, List> splitBy(final Predicate predicate) {
        N.requireNonNull(predicate);

        final List left = new ArrayList<>();
        final List right = new ArrayList<>();

        if (N.notNullOrEmpty(coll)) {
            final Iterator iter = iterator();
            T next = (T) N.NULL_MASK;

            while (iter.hasNext() && predicate.test((next = iter.next()))) {
                left.add(next);

                next = (T) N.NULL_MASK;
            }

            if (next != N.NULL_MASK) {
                right.add(next);
            }

            while (iter.hasNext()) {
                right.add(iter.next());
            }
        }

        return Pair.of(left, right);
    }

    public String join() {
        return join(N.ELEMENT_SEPARATOR);
    }

    public String join(final char delimiter) {
        return N.join(coll, delimiter);
    }

    public String join(final String delimiter) {
        return N.join(coll, delimiter);
    }

    @Override
    public boolean isEmpty() {
        return coll == null || coll.isEmpty();
    }

    @Override
    public int size() {
        return coll == null ? 0 : coll.size();
    }

    @Override
    public Object[] toArray() {
        return coll == null ? N.EMPTY_OBJECT_ARRAY : coll.toArray();
    }

    @Override
    public  A[] toArray(A[] a) {
        return coll == null ? a : coll.toArray(a);
    }

    public List toList() {
        return coll == null ? new ArrayList() : new ArrayList(coll);
    }

    public > R toList(final IntFunction supplier) {
        final R result = supplier.apply(size());

        if (N.notNullOrEmpty(coll)) {
            result.addAll(coll);
        }

        return result;
    }

    public Set toSet() {
        return coll == null ? new HashSet() : new HashSet(coll);
    }

    public > R toSet(final IntFunction supplier) {
        final R result = supplier.apply(size());

        if (N.notNullOrEmpty(coll)) {
            result.addAll(coll);
        }

        return result;
    }

    public Multiset toMultiset() {
        final Multiset result = new Multiset<>(N.initHashCapacity(size()));

        if (N.notNullOrEmpty(coll)) {
            result.addAll(coll);
        }

        return result;
    }

    public Multiset toMultiset(final IntFunction> supplier) {
        final Multiset result = supplier.apply(N.initHashCapacity(size()));

        if (N.notNullOrEmpty(coll)) {
            result.addAll(coll);
        }

        return result;
    }

    public  Map toMap(Function keyExtractor, Function valueMapper) {
        final Supplier> mapFactory = Fn.Suppliers.ofMap();

        return toMap(keyExtractor, valueMapper, mapFactory);
    }

    public > M toMap(Function keyExtractor, Function valueMapper,
            Supplier mapFactory) {
        final BinaryOperator mergeFunction = Fn.throwingMerger();

        return toMap(keyExtractor, valueMapper, mergeFunction, mapFactory);
    }

    public  Map toMap(Function keyExtractor, Function valueMapper,
            BinaryOperator mergeFunction) {
        final Supplier> mapFactory = Fn.Suppliers.ofMap();

        return toMap(keyExtractor, valueMapper, mergeFunction, mapFactory);
    }

    public > M toMap(Function keyExtractor, Function valueMapper,
            BinaryOperator mergeFunction, Supplier mapFactory) {
        final M result = mapFactory.get();
        final Iterator iter = iterator();
        T element = null;

        while (iter.hasNext()) {
            element = iter.next();
            merge(result, keyExtractor.apply(element), valueMapper.apply(element), mergeFunction);
        }

        return result;
    }

    @SuppressWarnings("hiding")
    public  Map toMap(Function classifier, Collector downstream) {
        final Supplier> mapFactory = Fn.Suppliers.ofMap();

        return toMap(classifier, downstream, mapFactory);
    }

    @SuppressWarnings("hiding")
    public > M toMap(final Function classifier, final Collector downstream,
            final Supplier mapFactory) {
        final M result = mapFactory.get();
        final Supplier downstreamSupplier = downstream.supplier();
        final BiConsumer downstreamAccumulator = downstream.accumulator();
        final Map intermediate = (Map) result;
        final Iterator iter = iterator();
        K key = null;
        A v = null;
        T element = null;

        while (iter.hasNext()) {
            element = iter.next();
            key = N.requireNonNull(classifier.apply(element), "element cannot be mapped to a null key");

            if ((v = intermediate.get(key)) == null) {
                if ((v = downstreamSupplier.get()) != null) {
                    intermediate.put(key, v);
                }
            }

            downstreamAccumulator.accept(v, element);
        }

        final BiFunction function = new BiFunction() {
            @Override
            public A apply(K k, A v) {
                return (A) downstream.finisher().apply(v);
            }
        };

        replaceAll(intermediate, function);

        return result;
    }

    public  Map> groupTo(Function classifier) {
        final Supplier>> mapFactory = Fn.Suppliers.ofMap();

        return groupTo(classifier, mapFactory);
    }

    public >> M groupTo(Function classifier, Supplier mapFactory) {
        final Collector> downstream = Collectors.toList();

        return toMap(classifier, downstream, mapFactory);
    }

    public  Map> groupTo(Function keyExtractor, Function valueMapper) {
        return toMap(keyExtractor, (Collector>) (Collector) Collectors.mapping(valueMapper, Collectors.toList()));
    }

    @SuppressWarnings("rawtypes")
    public >> M groupTo(Function keyExtractor, Function valueMapper,
            Supplier mapFactory) {
        return toMap(keyExtractor, (Collector>) (Collector) Collectors.mapping(valueMapper, Collectors.toList()), mapFactory);
    }

    /**
     * 
     * @param keyExtractor
     * @return
     */
    public  ListMultimap toMultimap(Function keyExtractor) {
        final ListMultimap result = N.newListMultimap();

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.put(keyExtractor.apply(e), e);
        }

        return result;
    }

    public , M extends Multimap> M toMultimap(Function keyExtractor, Supplier mapFactory) {
        final M result = mapFactory.get();

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.put(keyExtractor.apply(e), e);
        }

        return result;
    }

    /**
     * 
     * @param keyExtractor
     * @param valueMapper
     * @return
     */
    public  ListMultimap toMultimap(Function keyExtractor, Function valueMapper) {
        final ListMultimap result = N.newListMultimap();

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.put(keyExtractor.apply(e), valueMapper.apply(e));
        }

        return result;
    }

    public , M extends Multimap> M toMultimap(Function keyExtractor,
            Function valueMapper, Supplier mapFactory) {
        final M result = mapFactory.get();

        if (N.isNullOrEmpty(coll)) {
            return result;
        }

        for (T e : coll) {
            result.put(keyExtractor.apply(e), valueMapper.apply(e));
        }

        return result;
    }

    /**
     * 
     * The time complexity is O(n + m) : n is the size of this Seq and m is the size of specified collection b.
     * 
     * @param b
     * @param leftKeyMapper
     * @param rightKeyMapper
     * @return
     * @see sql join
     */
    public  List> innerJoin(final Collection b, final Function leftKeyMapper, final Function rightKeyMapper) {
        final List> result = new ArrayList<>(N.min(9, size(), b.size()));

        if (N.isNullOrEmpty(coll) || N.isNullOrEmpty(b)) {
            return result;
        }

        final ListMultimap rightKeyMap = ListMultimap.from(b, rightKeyMapper);

        for (T left : coll) {
            final List rights = rightKeyMap.get(leftKeyMapper.apply(left));

            if (N.notNullOrEmpty(rights)) {
                for (U right : rights) {
                    result.add(Pair.of(left, right));
                }
            }
        }

        return result;
    }

    /**
     * 
     * The time complexity is O(n * m) : n is the size of this Seq and m is the size of specified collection b.
     * 
     * @param b
     * @param predicate
     * @return
     * @see  List> fullJoin(final Collection b, final Function leftKeyMapper, final Function rightKeyMapper) {
        final List> result = new ArrayList<>(N.max(9, size(), b.size()));

        if (N.isNullOrEmpty(coll)) {
            for (T left : coll) {
                result.add(Pair.of(left, (U) null));
            }
        } else if (N.isNullOrEmpty(b)) {
            for (U right : b) {
                result.add(Pair.of((T) null, right));
            }
        } else {
            final ListMultimap rightKeyMap = ListMultimap.from(b, rightKeyMapper);
            final Map joinedRights = new IdentityHashMap<>();

            for (T left : coll) {
                final List rights = rightKeyMap.get(leftKeyMapper.apply(left));

                if (N.notNullOrEmpty(rights)) {
                    for (U right : rights) {
                        result.add(Pair.of(left, right));
                        joinedRights.put(right, right);
                    }
                } else {
                    result.add(Pair.of(left, (U) null));
                }
            }

            for (U right : b) {
                if (joinedRights.containsKey(right) == false) {
                    result.add(Pair.of((T) null, right));
                }
            }
        }

        return result;
    }

    /**
     * The time complexity is O(n * m) : n is the size of this Seq and m is the size of specified collection b.
     * 
     * @param b
     * @param predicate
     * @return
     * @see  List> leftJoin(final Collection b, final Function leftKeyMapper, final Function rightKeyMapper) {
        final List> result = new ArrayList<>(size());

        if (N.isNullOrEmpty(coll)) {
            return result;
        } else if (N.isNullOrEmpty(b)) {
            for (T left : coll) {
                result.add(Pair.of(left, (U) null));
            }
        } else {
            final ListMultimap rightKeyMap = ListMultimap.from(b, rightKeyMapper);

            for (T left : coll) {
                final List rights = rightKeyMap.get(leftKeyMapper.apply(left));

                if (N.notNullOrEmpty(rights)) {
                    for (U right : rights) {
                        result.add(Pair.of(left, right));
                    }
                } else {
                    result.add(Pair.of(left, (U) null));
                }
            }
        }

        return result;
    }

    /**
     * The time complexity is O(n * m) : n is the size of this Seq and m is the size of specified collection b.
     * 
     * @param b
     * @param predicate
     * @return
     * @see  List> rightJoin(final Collection b, final Function leftKeyMapper, final Function rightKeyMapper) {
        final List> result = new ArrayList<>(b.size());

        if (N.isNullOrEmpty(b)) {
            return result;
        } else if (N.isNullOrEmpty(coll)) {
            for (U right : b) {
                result.add(Pair.of((T) null, right));
            }
        } else {
            final ListMultimap leftKeyMap = ListMultimap.from(coll, leftKeyMapper);

            for (U right : b) {
                final List lefts = leftKeyMap.get(rightKeyMapper.apply(right));

                if (N.notNullOrEmpty(lefts)) {
                    for (T left : lefts) {
                        result.add(Pair.of(left, right));
                    }
                } else {
                    result.add(Pair.of((T) null, right));
                }
            }
        }

        return result;
    }

    /**
     * The time complexity is O(n * m) : n is the size of this Seq and m is the size of specified collection b.
     * 
     * @param b
     * @param predicate
     * @return
     * @see ();
        }

        final List result = new ArrayList<>(c.size() * n);

        for (int i = 0; i < n; i++) {
            result.addAll(c);
        }

        return result;
    }

    /**
     * Repeats the elements in the specified Collection one by one.
     * 
     * 
     * 
     * Seq.nRepeat(N.asList(1, 2, 3), 2) => [1, 1, 2, 2, 3, 3]
     * 
     * 
     * 
     * @param c
     * @param n
     * @return
     */
    public static  List nRepeat(final Collection c, final int n) {
        if (n < 1) {
            throw new IllegalArgumentException("The specified count must be greater than 0");
        }

        if (N.isNullOrEmpty(c)) {
            return new ArrayList();
        }

        final List result = new ArrayList<>(c.size() * n);

        for (T e : c) {
            for (int i = 0; i < n; i++) {
                result.add(e);
            }
        }

        return result;
    }

    /**
     * 
     * 
     * 
     * Seq.repeatToSize(N.asList(1, 2, 3), 5) => [1, 2, 3, 1, 2]
     * 
     * 
     * 
     * @param c
     * @param size
     * @return
     */
    public static  List repeatToSize(final Collection c, final int size) {
        if (size < 1) {
            throw new IllegalArgumentException("The specified size must be greater than 0");
        } else if (N.isNullOrEmpty(c) && size > 0) {
            throw new IllegalArgumentException("The specified collection can't be null or empty when size > 0");
        }

        if (N.isNullOrEmpty(c)) {
            return new ArrayList();
        }

        final List result = new ArrayList<>(size);

        while (result.size() < size) {
            if (c.size() <= size - result.size()) {
                result.addAll(c);
            } else {
                final Iterator iter = c.iterator();

                for (int i = 0, len = size - result.size(); i < len; i++) {
                    result.add(iter.next());
                }
            }
        }

        return result;
    }

    /**
     * Repeats the elements in the specified Collection one by one till reach the specified size.
     * 
     * 
     * 
     * Seq.nRepeatToSize(N.asList(1, 2, 3), 5) => [1, 1, 2, 2, 3]
     * 
     * 
     * 
     * @param c
     * @param size
     * @return
     */
    public static  List nRepeatToSize(final Collection c, final int size) {
        if (size < 1) {
            throw new IllegalArgumentException("The specified size must be greater than 0");
        } else if (N.isNullOrEmpty(c) && size > 0) {
            throw new IllegalArgumentException("The specified collection can't be null or empty when size > 0");
        }

        if (N.isNullOrEmpty(c)) {
            return new ArrayList();
        }

        final int n = size / c.size();
        int mod = size % c.size();

        final List result = new ArrayList<>(size);

        for (T e : c) {
            for (int i = 0, len = mod-- > 0 ? n + 1 : n; i < len; i++) {
                result.add(e);
            }

            if (result.size() == size) {
                break;
            }
        }

        return result;
    }

    public static  void reverse(final Collection c) {
        if (N.isNullOrEmpty(c) && c.size() < 2) {
            return;
        }

        if (c instanceof List) {
            N.reverse((List) c);
        } else {
            final Object[] tmp = c.toArray();
            N.reverse(tmp);
            c.clear();
            c.addAll((List) Arrays.asList(tmp));
        }
    }

    public static  void rotate(final Collection c, final int distance) {
        if (N.isNullOrEmpty(c) && c.size() < 2) {
            return;
        }

        if (c instanceof List) {
            N.rotate((List) c, distance);
        } else {
            final Object[] tmp = c.toArray();
            N.rotate(tmp, distance);
            c.clear();
            c.addAll((List) Arrays.asList(tmp));
        }
    }

    public static  void shuffle(final Collection c) {
        if (N.isNullOrEmpty(c) && c.size() < 2) {
            return;
        }

        if (c instanceof List) {
            N.shuffle((List) c);
        } else {
            final Object[] tmp = c.toArray();
            N.shuffle(tmp);
            c.clear();
            c.addAll((List) Arrays.asList(tmp));
        }
    }

    public static  void shuffle(final Collection c, final Random rnd) {
        if (N.isNullOrEmpty(c) && c.size() < 2) {
            return;
        }

        if (c instanceof List) {
            N.shuffle((List) c, rnd);
        } else {
            final Object[] tmp = c.toArray();
            N.shuffle(tmp, rnd);
            c.clear();
            c.addAll((List) Arrays.asList(tmp));
        }
    }

    //    public ListBuilder __() {
    //        return Builder.of(this);
    //    }
    //
    //    public ListBuilder __(Consumer> func) {
    //        return Builder.of(this).__(func);
    //    }

    public static boolean disjoint(final Object[] a, final Object[] b) {
        if (N.isNullOrEmpty(a) || N.isNullOrEmpty(b)) {
            return true;
        }

        return a.length >= b.length ? disjoint(Arrays.asList(a), N.asSet(b)) : disjoint(N.asSet(a), Arrays.asList(b));
    }

    /**
     * Returns {@code true} if the two specified arrays have no elements in common.
     * 
     * @param a
     * @param b
     * @return {@code true} if the two specified arrays have no elements in common.
     * @see Collections#disjoint(Collection, Collection)
     */
    public static boolean disjoint(final Collection c1, final Collection c2) {
        if (N.isNullOrEmpty(c1) || N.isNullOrEmpty(c2)) {
            return true;
        }

        if (c1 instanceof Set || (c2 instanceof Set == false && c1.size() > c2.size())) {
            for (Object e : c2) {
                if (c1.contains(e)) {
                    return false;
                }
            }
        } else {
            for (Object e : c1) {
                if (c2.contains(e)) {
                    return false;
                }
            }
        }

        return true;
    }

    public static  List concat(final T[] a, final T[] b) {
        if (N.isNullOrEmpty(a)) {
            if (N.isNullOrEmpty(b)) {
                return new ArrayList<>();
            } else {
                final List res = new ArrayList<>(b.length);
                res.addAll(N.asList(b));
                return res;
            }
        } else {
            final List res = new ArrayList<>(a.length + (b == null ? 0 : b.length));
            res.addAll(N.asList(a));

            if (N.notNullOrEmpty(b)) {
                res.addAll(N.asList(b));
            }
            return res;
        }
    }

    public static  List concat(final T[]... a) {
        if (N.isNullOrEmpty(a)) {
            return new ArrayList<>();
        }

        int count = 0;

        for (T[] e : a) {
            if (N.notNullOrEmpty(e)) {
                count += e.length;
            }
        }

        final List result = new ArrayList<>(count);

        for (T[] e : a) {
            if (N.notNullOrEmpty(e)) {
                if (a.length < 9) {
                    for (T t : e) {
                        result.add(t);
                    }
                } else {
                    result.addAll(Arrays.asList(e));
                }
            }
        }

        return result;
    }

    public static  List concat(final Collection a, final Collection b) {
        return N.concat(a, b);
    }

    @SafeVarargs
    public static  List concat(final Collection... a) {
        if (N.isNullOrEmpty(a)) {
            return new ArrayList<>();
        }

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

    public static  List concat(final Collection> c) {
        if (N.isNullOrEmpty(c)) {
            return new ArrayList<>();
        }

        int count = 0;

        for (Collection e : c) {
            if (N.notNullOrEmpty(e)) {
                count += e.size();
            }
        }

        final List result = new ArrayList<>(count);

        for (Collection e : c) {
            if (N.notNullOrEmpty(e)) {
                result.addAll(e);
            }
        }

        return result;
    }

    public static  ImmutableIterator concat(final Iterator a, final Iterator b) {
        return Iterators.concat(a, b);
    }

    @SafeVarargs
    public static  ImmutableIterator concat(final Iterator... a) {
        return Iterators.concat(a);
    }

    @SafeVarargs
    public static  ImmutableIterator iterate(final T[]... a) {
        return Iterators.concat(a);
    }

    @SafeVarargs
    public static  ImmutableIterator iterate(final Collection... a) {
        return Iterators.concat(a);
    }

    public static  ImmutableIterator iterate(final Collection> c) {
        if (N.isNullOrEmpty(c)) {
            return ImmutableIterator.empty();
        }

        final List> list = new ArrayList<>(c.size());

        for (Collection e : c) {
            if (N.notNullOrEmpty(e)) {
                list.add(e.iterator());
            }
        }

        return Iterators.concat(list);
    }

    public static  List merge(final T[] a, final T[] b, final BiFunction nextSelector) {
        if (N.isNullOrEmpty(a)) {
            return N.isNullOrEmpty(b) ? new ArrayList() : N.asList(b);
        } else if (N.isNullOrEmpty(b)) {
            return N.asList(a);
        }

        final List result = new ArrayList<>(a.length + b.length);
        final int lenA = a.length;
        final int lenB = b.length;
        int cursorA = 0;
        int cursorB = 0;

        while (cursorA < lenA || cursorB < lenB) {
            if (cursorA < lenA) {
                if (cursorB < lenB) {
                    if (nextSelector.apply(a[cursorA], b[cursorB]) == Nth.FIRST) {
                        result.add(a[cursorA++]);
                    } else {
                        result.add(b[cursorB++]);
                    }
                } else {
                    result.add(a[cursorA++]);
                }
            } else {
                result.add(b[cursorB++]);
            }
        }

        return result;
    }

    public static  List merge(final Collection a, final Collection b,
            final BiFunction nextSelector) {
        if (N.isNullOrEmpty(a)) {
            return N.isNullOrEmpty(b) ? new ArrayList() : new ArrayList(b);
        } else if (N.isNullOrEmpty(b)) {
            return new ArrayList(a);
        }

        final List result = new ArrayList<>(a.size() + b.size());
        final Iterator iterA = a.iterator();
        final Iterator iterB = b.iterator();

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

        while (hasNextA || hasNextB || iterA.hasNext() || iterB.hasNext()) {
            if (hasNextA) {
                if (iterB.hasNext()) {
                    if (nextSelector.apply(nextA, (nextB = iterB.next())) == Nth.FIRST) {
                        hasNextA = false;
                        hasNextB = true;
                        result.add(nextA);
                    } else {
                        result.add(nextB);
                    }
                } else {
                    hasNextA = false;
                    result.add(nextA);
                }
            } else if (hasNextB) {
                if (iterA.hasNext()) {
                    if (nextSelector.apply((nextA = iterA.next()), nextB) == Nth.FIRST) {
                        result.add(nextA);
                    } else {
                        hasNextA = true;
                        hasNextB = false;
                        result.add(nextB);
                    }
                } else {
                    hasNextB = false;
                    result.add(nextB);
                }
            } else if (iterA.hasNext()) {
                if (iterB.hasNext()) {
                    if (nextSelector.apply((nextA = iterA.next()), (nextB = iterB.next())) == Nth.FIRST) {
                        hasNextB = true;
                        result.add(nextA);
                    } else {
                        hasNextA = true;
                        result.add(nextB);
                    }
                } else {
                    result.add(iterA.next());
                }
            } else {
                result.add(iterB.next());
            }
        }

        return result;
    }

    public static  ImmutableIterator merge(final Iterator a, final Iterator b,
            final BiFunction nextSelector) {

        return new ImmutableIterator() {
            private final Iterator iterA = a == null ? ImmutableIterator.EMPTY : a;
            private final Iterator iterB = b == null ? ImmutableIterator.EMPTY : b;
            private T nextA = null;
            private T nextB = null;
            private boolean hasNextA = false;
            private boolean hasNextB = false;

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

            @Override
            public T next() {
                if (hasNextA) {
                    if (iterB.hasNext()) {
                        if (nextSelector.apply(nextA, (nextB = iterB.next())) == Nth.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) == Nth.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())) == Nth.FIRST) {
                            hasNextB = true;
                            return nextA;
                        } else {
                            hasNextA = true;
                            return nextB;
                        }
                    } else {
                        return iterA.next();
                    }
                } else {
                    return iterB.next();
                }
            }
        };
    }

    public static  List zip(final A[] a, final B[] b, final BiFunction zipFunction) {
        if (N.isNullOrEmpty(a) || N.isNullOrEmpty(b)) {
            return new ArrayList<>();
        }

        return zip(Arrays.asList(a), Arrays.asList(b), zipFunction);
    }

    public static  List zip(final Collection a, final Collection b, final BiFunction zipFunction) {
        if (N.isNullOrEmpty(a) || N.isNullOrEmpty(b)) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>(N.min(a.size(), b.size()));

        final Iterator iterA = a.iterator();
        final Iterator iterB = b.iterator();

        if (a.size() <= b.size()) {
            while (iterA.hasNext()) {
                result.add(zipFunction.apply(iterA.next(), iterB.next()));
            }
        } else {
            while (iterB.hasNext()) {
                result.add(zipFunction.apply(iterA.next(), iterB.next()));
            }
        }

        return result;
    }

    public static  ImmutableIterator zip(final Iterator a, final Iterator b, final BiFunction zipFunction) {
        return new ImmutableIterator() {
            private final Iterator iterA = a == null ? ImmutableIterator.EMPTY : a;
            private final Iterator iterB = b == null ? ImmutableIterator.EMPTY : b;

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

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

    public static  List zip(final A[] a, final B[] b, final C[] c, final TriFunction zipFunction) {
        if (N.isNullOrEmpty(a) || N.isNullOrEmpty(b) || N.isNullOrEmpty(c)) {
            return new ArrayList<>();
        }

        return zip(Arrays.asList(a), Arrays.asList(b), Arrays.asList(c), zipFunction);
    }

    public static  List zip(final Collection a, final Collection b, final Collection c,
            final TriFunction zipFunction) {
        if (N.isNullOrEmpty(a) || N.isNullOrEmpty(b) || N.isNullOrEmpty(c)) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>(N.min(a.size(), b.size(), c.size()));

        final Iterator iterA = a.iterator();
        final Iterator iterB = b.iterator();
        final Iterator iterC = c.iterator();

        while (iterA.hasNext() && iterB.hasNext() && iterC.hasNext()) {
            result.add(zipFunction.apply(iterA.next(), iterB.next(), iterC.next()));
        }

        return result;
    }

    public static  ImmutableIterator zip(final Iterator a, final Iterator b, final Iterator c,
            final TriFunction zipFunction) {
        return new ImmutableIterator() {
            private final Iterator iterA = a == null ? ImmutableIterator.EMPTY : a;
            private final Iterator iterB = b == null ? ImmutableIterator.EMPTY : b;
            private final Iterator iterC = c == null ? ImmutableIterator.EMPTY : c;

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

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

    public static  List zip(final A[] a, final B[] b, final A valueForNoneA, final B valueForNoneB,
            final BiFunction zipFunction) {
        return zip(N.isNullOrEmpty(a) ? N.EMPTY_LIST : Arrays.asList(a), N.isNullOrEmpty(b) ? N.EMPTY_LIST : Arrays.asList(b), valueForNoneA, valueForNoneB,
                zipFunction);
    }

    public static  List zip(final Collection a, final Collection b, final A valueForNoneA, final B valueForNoneB,
            final BiFunction zipFunction) {
        final int aLen = a == null ? 0 : a.size();
        final int bLen = b == null ? 0 : b.size();

        final List result = new ArrayList<>(N.max(aLen, bLen));

        final Iterator iterA = a == null ? ImmutableIterator.EMPTY : a.iterator();
        final Iterator iterB = b == null ? ImmutableIterator.EMPTY : b.iterator();

        if (aLen > bLen) {
            while (iterA.hasNext()) {
                result.add(zipFunction.apply(iterA.next(), iterB.hasNext() ? iterB.next() : valueForNoneB));
            }
        } else {
            while (iterB.hasNext()) {
                result.add(zipFunction.apply(iterA.hasNext() ? iterA.next() : valueForNoneA, iterB.next()));
            }
        }

        return result;
    }

    public static  ImmutableIterator zip(final Iterator a, final Iterator b, final A valueForNoneA, final B valueForNoneB,
            final BiFunction zipFunction) {
        return new ImmutableIterator() {
            private final Iterator iterA = a == null ? ImmutableIterator.EMPTY : a;
            private final Iterator iterB = b == null ? ImmutableIterator.EMPTY : b;

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

            @Override
            public R next() {
                return zipFunction.apply(iterA.hasNext() ? iterA.next() : valueForNoneA, iterB.hasNext() ? iterB.next() : valueForNoneB);
            }
        };
    }

    public static  List zip(final A[] a, final B[] b, final C[] c, final A valueForNoneA, final B valueForNoneB, final C valueForNoneC,
            final TriFunction zipFunction) {
        return zip(N.isNullOrEmpty(a) ? N.EMPTY_LIST : Arrays.asList(a), N.isNullOrEmpty(b) ? N.EMPTY_LIST : Arrays.asList(b),
                N.isNullOrEmpty(c) ? N.EMPTY_LIST : Arrays.asList(c), valueForNoneA, valueForNoneB, valueForNoneC, zipFunction);
    }

    public static  List zip(final Collection a, final Collection b, final Collection c, final A valueForNoneA, final B valueForNoneB,
            final C valueForNoneC, final TriFunction zipFunction) {
        final int aLen = a == null ? 0 : a.size();
        final int bLen = b == null ? 0 : b.size();
        final int cLen = c == null ? 0 : c.size();

        final List result = new ArrayList<>(N.max(aLen, bLen, cLen));

        final Iterator iterA = a == null ? ImmutableIterator.EMPTY : a.iterator();
        final Iterator iterB = b == null ? ImmutableIterator.EMPTY : b.iterator();
        final Iterator iterC = c == null ? ImmutableIterator.EMPTY : c.iterator();

        while (iterA.hasNext() || iterB.hasNext() || iterC.hasNext()) {
            result.add(zipFunction.apply(iterA.hasNext() ? iterA.next() : valueForNoneA, iterB.hasNext() ? iterB.next() : valueForNoneB,
                    iterC.hasNext() ? iterC.next() : valueForNoneC));
        }

        return result;
    }

    public static  ImmutableIterator zip(final Iterator a, final Iterator b, final Iterator c, final A valueForNoneA,
            final B valueForNoneB, final C valueForNoneC, final TriFunction zipFunction) {
        return new ImmutableIterator() {
            private final Iterator iterA = a == null ? ImmutableIterator.EMPTY : a;
            private final Iterator iterB = b == null ? ImmutableIterator.EMPTY : b;
            private final Iterator iterC = c == null ? ImmutableIterator.EMPTY : c;

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

            @Override
            public R next() {
                return zipFunction.apply(iterA.hasNext() ? iterA.next() : valueForNoneA, iterB.hasNext() ? iterB.next() : valueForNoneB,
                        iterC.hasNext() ? iterC.next() : valueForNoneC);
            }
        };
    }

    /**
     * 
     * @param c
     * @param unzip the second parameter is an output parameter.
     * @return
     */
    public static  Pair, List> unzip(final Collection c, final BiConsumer> unzip) {
        final int len = c == null ? 0 : c.size();

        final List l = new ArrayList(len);
        final List r = new ArrayList(len);
        final Pair p = new Pair<>();

        if (N.notNullOrEmpty(c)) {
            for (T e : c) {
                unzip.accept(e, p);

                l.add(p.left);
                r.add(p.right);
            }
        }

        return Pair.of(l, r);
    }

    /**
     * 
     * @param supplier
     * @param c
     * @param unzip the second parameter is an output parameter.
     * @return
     */
    public static , RC extends Collection> Pair unzip(final IntFunction> supplier,
            final Collection c, final BiConsumer> unzip) {
        final int len = c == null ? 0 : c.size();

        final LC l = (LC) supplier.apply(len);
        final RC r = (RC) supplier.apply(len);
        final Pair p = new Pair<>();

        if (N.notNullOrEmpty(c)) {
            for (T e : c) {
                unzip.accept(e, p);

                l.add(p.left);
                r.add(p.right);
            }
        }

        return Pair.of(l, r);
    }

    /**
     * 
     * @param iter
     * @param unzip the second parameter is an output parameter.
     * @return
     */
    public static  Pair, List> unzip(final Iterator iter, final BiConsumer> unzip) {
        final List l = new ArrayList();
        final List r = new ArrayList();
        final Pair p = new Pair<>();

        if (iter != null) {
            while (iter.hasNext()) {
                unzip.accept(iter.next(), p);

                l.add(p.left);
                r.add(p.right);
            }
        }

        return Pair.of(l, r);
    }

    /**
     * 
     * @param supplier
     * @param iter
     * @param unzip the second parameter is an output parameter.
     * @return
     */
    public static , RC extends Collection> Pair unzip(final Supplier> supplier,
            final Iterator iter, final BiConsumer> unzip) {
        final LC l = (LC) supplier.get();
        final RC r = (RC) supplier.get();

        final Pair p = new Pair<>();

        if (iter != null) {
            while (iter.hasNext()) {
                unzip.accept(iter.next(), p);

                l.add(p.left);
                r.add(p.right);
            }
        }

        return Pair.of(l, r);
    }

    /**
     * 
     * @param c
     * @param unzip the second parameter is an output parameter.
     * @return
     */
    public static  Triple, List, List> unzip3(final Collection c, final BiConsumer> unzip) {
        final int len = c == null ? 0 : c.size();

        final List l = new ArrayList(len);
        final List m = new ArrayList(len);
        final List r = new ArrayList(len);
        final Triple t = new Triple<>();

        if (N.notNullOrEmpty(c)) {
            for (T e : c) {
                unzip.accept(e, t);

                l.add(t.left);
                m.add(t.middle);
                r.add(t.right);
            }
        }

        return Triple.of(l, m, r);
    }

    /**
     * 
     * @param supplier
     * @param c
     * @param unzip the second parameter is an output parameter.
     * @return
     */
    public static , MC extends Collection, RC extends Collection> Triple unzip3(
            final IntFunction> supplier, final Collection c, final BiConsumer> unzip) {
        final int len = c == null ? 0 : c.size();

        final LC l = (LC) supplier.apply(len);
        final MC m = (MC) supplier.apply(len);
        final RC r = (RC) supplier.apply(len);
        final Triple t = new Triple<>();

        if (N.notNullOrEmpty(c)) {
            for (T e : c) {
                unzip.accept(e, t);

                l.add(t.left);
                m.add(t.middle);
                r.add(t.right);
            }
        }

        return Triple.of(l, m, r);
    }

    /**
     * 
     * @param iter
     * @param unzip the second parameter is an output parameter.
     * @return
     */
    public static  Triple, List, List> unzip3(final Iterator iter, final BiConsumer> unzip) {
        final List l = new ArrayList();
        final List m = new ArrayList();
        final List r = new ArrayList();
        final Triple t = new Triple<>();

        if (iter != null) {
            while (iter.hasNext()) {
                unzip.accept(iter.next(), t);

                l.add(t.left);
                m.add(t.middle);
                r.add(t.right);
            }
        }

        return Triple.of(l, m, r);
    }

    /**
     * 
     * @param supplier
     * @param iter
     * @param unzip the second parameter is an output parameter.
     * @return
     */
    public static , MC extends Collection, RC extends Collection> Triple unzip3(
            final Supplier> supplier, final Iterator iter, final BiConsumer> unzip) {
        final LC l = (LC) supplier.get();
        final MC m = (MC) supplier.get();
        final RC r = (RC) supplier.get();
        final Triple t = new Triple<>();

        if (iter != null) {
            while (iter.hasNext()) {
                unzip.accept(iter.next(), t);

                l.add(t.left);
                m.add(t.middle);
                r.add(t.right);
            }
        }

        return Triple.of(l, m, r);
    }

    /**
     * Note: copy from Google Guava under Apache License v2.
     * 

     * 
     * Returns the set of all possible subsets of {@code set}. For example,
     * {@code powerSet(ImmutableSet.of(1, 2))} returns the set {@code {{},
     * {1}, {2}, {1, 2}}}.
     *
     * 
Elements appear in these subsets in the same iteration order as they
     * appeared in the input set. The order in which these subsets appear in the
     * outer set is undefined. Note that the power set of the empty set is not the
     * empty set, but a one-element set containing the empty set.
     *
     * 
The returned set and its constituent sets use {@code equals} to decide
     * whether two elements are identical, even if the input set uses a different
     * concept of equivalence.
     *
     * 
Performance notes: while the power set of a set with size {@code
     * n} is of size {@code 2^n}, its memory usage is only {@code O(n)}. When the
     * power set is constructed, the input set is merely copied. Only as the
     * power set is iterated are the individual subsets created, and these subsets
     * themselves occupy only a small constant amount of memory.
     *
     * @param set the set of elements to construct a power set from
     * @return the power set, as an immutable set of immutable sets
     * @throws IllegalArgumentException if {@code set} has more than 30 unique
     *     elements (causing the power set size to exceed the {@code int} range)
     * @throws NullPointerException if {@code set} is or contains {@code null}
     * @see Power set article at
     *      Wikipedia
     * @since 4.0
     */
    public static  Set> powerSet(Set set) {
        return new PowerSet<>(set);
    }

    private static final class PowerSet extends AbstractSet> {
        final ImmutableMap inputSet;

        PowerSet(Set input) {
            this.inputSet = indexMap(input);
            N.checkArgument(inputSet.size() <= 30, "Too many elements to create power set: %s > 30", inputSet.size());
        }

        @Override
        public int size() {
            return 1 << inputSet.size();
        }

        @Override
        public boolean isEmpty() {
            return false;
        }

        @Override
        public Iterator> iterator() {
            return new Iterator>() {
                private final int size = size();
                private int position;

                @Override
                public boolean hasNext() {
                    return position < size;
                }

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

                    return new SubSet<>(inputSet, position++);
                }

                @Override
                public void remove() {
                    throw new UnsupportedOperationException();
                }
            };
        }

        @Override
        public boolean contains(Object obj) {
            if (obj instanceof Set) {
                Set set = (Set) obj;
                return inputSet.keySet().containsAll(set);
            }
            return false;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof PowerSet) {
                PowerSet that = (PowerSet) obj;
                return inputSet.equals(that.inputSet);
            }
            return super.equals(obj);
        }

        @Override
        public int hashCode() {
            /*
             * The sum of the sums of the hash codes in each subset is just the sum of
             * each input element's hash code times the number of sets that element
             * appears in. Each element appears in exactly half of the 2^n sets, so:
             */
            return inputSet.keySet().hashCode() << (inputSet.size() - 1);
        }

        @Override
        public String toString() {
            return "powerSet(" + inputSet + ")";
        }

        /**
         * Returns a map from the ith element of list to i.
         */
        private static  ImmutableMap indexMap(Collection c) {
            final Map map = new LinkedHashMap<>();

            int i = 0;

            for (E e : c) {
                map.put(e, i++);
            }

            return ImmutableMap.of(map);
        }
    }

    private static final class SubSet extends AbstractSet {
        private final ImmutableMap inputSet;
        private final ImmutableList elements;
        private final int mask;

        SubSet(ImmutableMap inputSet, int mask) {
            this.inputSet = inputSet;
            this.elements = ImmutableList.of((E[]) inputSet.keySet().toArray());
            this.mask = mask;
        }

        @Override
        public Iterator iterator() {
            return new Iterator() {
                int remainingSetBits = mask;

                @Override
                public boolean hasNext() {
                    return remainingSetBits != 0;
                }

                @Override
                public E next() {
                    int index = Integer.numberOfTrailingZeros(remainingSetBits);
                    if (index == 32) {
                        throw new NoSuchElementException();
                    }
                    remainingSetBits &= ~(1 << index);
                    return elements.get(index);
                }

                @Override
                public void remove() {
                    throw new UnsupportedOperationException();
                }
            };
        }

        @Override
        public int size() {
            return Integer.bitCount(mask);
        }

        @Override
        public boolean contains(Object o) {
            Integer index = inputSet.get(o);
            return index != null && (mask & (1 << index)) != 0;
        }
    }

    /**
     * Note: copy from Google Guava under Apache License v2.
     * 

     * 
     * Returns a {@link Collection} of all the permutations of the specified
     * {@link Collection}.
     *
     * 
Notes: This is an implementation of the Plain Changes algorithm
     * for permutations generation, described in Knuth's "The Art of Computer
     * Programming", Volume 4, Chapter 7, Section 7.2.1.2.
     *
     * 
If the input list contains equal elements, some of the generated
     * permutations will be equal.
     *
     * 
An empty collection has only one permutation, which is an empty list.
     *
     * @param elements the original collection whose elements have to be permuted.
     * @return an immutable {@link Collection} containing all the different
     *     permutations of the original collection.
     * @throws NullPointerException if the specified collection is null or has any
     *     null elements.
     * @since 12.0
     */
    public static  Collection> permutations(Collection elements) {
        return new PermutationCollection(elements);
    }

    private static final class PermutationCollection extends AbstractCollection> {
        final List inputList;

        PermutationCollection(Collection input) {
            this.inputList = new ArrayList<>(input);
        }

        @Override
        public int size() {
            return Math2.factorial(inputList.size());
        }

        @Override
        public boolean isEmpty() {
            return false;
        }

        @Override
        public Iterator> iterator() {
            return PermutationIterator.of(inputList);
        }

        @Override
        public boolean contains(Object obj) {
            if (obj instanceof Collection) {
                return isPermutations(inputList, (Collection) obj);
            }

            return false;
        }

        @Override
        public String toString() {
            return "permutations(" + inputList + ")";
        }
    }

    /**
     * Note: copy from Google Guava under Apache License v2.
     * 

     * 
     * Returns a {@link Collection} of all the permutations of the specified
     * {@link Iterable}.
     *
     * 
Notes: This is an implementation of the algorithm for
     * Lexicographical Permutations Generation, described in Knuth's "The Art of
     * Computer Programming", Volume 4, Chapter 7, Section 7.2.1.2. The
     * iteration order follows the lexicographical order. This means that
     * the first permutation will be in ascending order, and the last will be in
     * descending order.
     *
     * 
Duplicate elements are considered equal. For example, the list [1, 1]
     * will have only one permutation, instead of two. This is why the elements
     * have to implement {@link Comparable}.
     *
     * 
An empty iterable has only one permutation, which is an empty list.
     *
     * 
This method is equivalent to
     * {@code Collections2.orderedPermutations(list, Ordering.natural())}.
     *
     * @param elements the original iterable whose elements have to be permuted.
     * @return an immutable {@link Collection} containing all the different
     *     permutations of the original iterable.
     * @throws NullPointerException if the specified iterable is null or has any
     *     null elements.
     * @since 12.0
     */
    public static > Collection> orderedPermutations(Collection elements) {
        return orderedPermutations(elements, Comparators.OBJ_COMPARATOR);
    }

    /**
     * Note: copy from Google Guava under Apache License v2.
     * 

     * 
     * Returns a {@link Collection} of all the permutations of the specified
     * {@link Iterable} using the specified {@link Comparator} for establishing
     * the lexicographical ordering.
     *
     * 
Examples: 
   {@code
     *
     *   for (List perm : orderedPermutations(asList("b", "c", "a"))) {
     *     println(perm);
     *   }
     *   // -> ["a", "b", "c"]
     *   // -> ["a", "c", "b"]
     *   // -> ["b", "a", "c"]
     *   // -> ["b", "c", "a"]
     *   // -> ["c", "a", "b"]
     *   // -> ["c", "b", "a"]
     *
     *   for (List perm : orderedPermutations(asList(1, 2, 2, 1))) {
     *     println(perm);
     *   }
     *   // -> [1, 1, 2, 2]
     *   // -> [1, 2, 1, 2]
     *   // -> [1, 2, 2, 1]
     *   // -> [2, 1, 1, 2]
     *   // -> [2, 1, 2, 1]
     *   // -> [2, 2, 1, 1]}
     *
     * 
Notes: This is an implementation of the algorithm for
     * Lexicographical Permutations Generation, described in Knuth's "The Art of
     * Computer Programming", Volume 4, Chapter 7, Section 7.2.1.2. The
     * iteration order follows the lexicographical order. This means that
     * the first permutation will be in ascending order, and the last will be in
     * descending order.
     *
     * 
Elements that compare equal are considered equal and no new permutations
     * are created by swapping them.
     *
     * 
An empty iterable has only one permutation, which is an empty list.
     *
     * @param elements the original iterable whose elements have to be permuted.
     * @param comparator a comparator for the iterable's elements.
     * @return an immutable {@link Collection} containing all the different
     *     permutations of the original iterable.
     * @throws NullPointerException If the specified iterable is null, has any
     *     null elements, or if the specified comparator is null.
     * @since 12.0
     */
    public static  Collection> orderedPermutations(Collection elements, Comparator comparator) {
        return new OrderedPermutationCollection(elements, comparator);
    }

    private static final class OrderedPermutationCollection extends AbstractCollection> {
        final List inputList;
        final Comparator comparator;
        final int size;

        OrderedPermutationCollection(Collection input, Comparator comparator) {
            this.inputList = new ArrayList(input);
            N.sort(inputList, comparator);
            this.comparator = comparator;
            this.size = calculateSize(inputList, comparator);
        }

        @Override
        public int size() {
            return size;
        }

        @Override
        public boolean isEmpty() {
            return false;
        }

        @Override
        public Iterator> iterator() {
            return PermutationIterator.ordered(inputList, comparator);
        }

        @Override
        public boolean contains(Object obj) {
            if (obj instanceof Collection) {
                return isPermutations(inputList, (Collection) obj);
            }
            return false;
        }

        @Override
        public String toString() {
            return "orderedPermutationCollection(" + inputList + ")";
        }

        /**
         * The number of permutations with repeated elements is calculated as
         * follows:
         * 

         * 
For an empty list, it is 1 (base case).
         * 
When r numbers are added to a list of n-r elements, the number of
         * permutations is increased by a factor of (n choose r).
         * 
         */
        private static  int calculateSize(List sortedInputList, Comparator comparator) {
            long permutations = 1;
            int n = 1;
            int r = 1;
            while (n < sortedInputList.size()) {
                int comparison = comparator.compare(sortedInputList.get(n - 1), sortedInputList.get(n));

                if (comparison < 0) {
                    // We move to the next non-repeated element.
                    permutations *= Math2.binomial(n, r);
                    r = 0;
                    if (!isPositiveInt(permutations)) {
                        return Integer.MAX_VALUE;
                    }
                }

                n++;
                r++;
            }

            permutations *= Math2.binomial(n, r);

            if (!isPositiveInt(permutations)) {
                return Integer.MAX_VALUE;
            }

            return (int) permutations;
        }

        private static boolean isPositiveInt(long n) {
            return n >= 0 && n <= Integer.MAX_VALUE;
        }
    }

    /**
     * Returns {@code true} if the second list is a permutation of the first.
     */
    private static boolean isPermutations(Collection a, Collection b) {
        if (a.size() != b.size()) {
            return false;
        }

        return N.difference(a, b).size() == 0;
    }

    /**
     * Note: copy from Google Guava under Apache License v2.
     * 

     * 
     * Returns every possible list that can be formed by choosing one element
     * from each of the given lists in order; the "n-ary
     * Cartesian
     * product" of the lists. For example: 
   {@code
     *
     *   Lists.cartesianProduct(ImmutableList.of(
     *       ImmutableList.of(1, 2),
     *       ImmutableList.of("A", "B", "C")))}
     *
     * 
returns a list containing six lists in the following order:
     *
     * 

     * 
{@code ImmutableList.of(1, "A")}
     * 
{@code ImmutableList.of(1, "B")}
     * 
{@code ImmutableList.of(1, "C")}
     * 
{@code ImmutableList.of(2, "A")}
     * 
{@code ImmutableList.of(2, "B")}
     * 
{@code ImmutableList.of(2, "C")}
     * 
     *
     * 
The result is guaranteed to be in the "traditional", lexicographical
     * order for Cartesian products that you would get from nesting for loops:
     * 
   {@code
     *
     *   for (B b0 : lists.get(0)) {
     *     for (B b1 : lists.get(1)) {
     *       ...
     *       ImmutableList tuple = ImmutableList.of(b0, b1, ...);
     *       // operate on tuple
     *     }
     *   }}

     *
     * 
Note that if any input list is empty, the Cartesian product will also be
     * empty. If no lists at all are provided (an empty list), the resulting
     * Cartesian product has one element, an empty list (counter-intuitive, but
     * mathematically consistent).
     *
     * 
Performance notes: while the cartesian product of lists of size
     * {@code m, n, p} is a list of size {@code m x n x p}, its actual memory
     * consumption is much smaller. When the cartesian product is constructed, the
     * input lists are merely copied. Only as the resulting list is iterated are
     * the individual lists created, and these are not retained after iteration.
     *
     * @param cs the lists to choose elements from, in the order that
     *     the elements chosen from those lists should appear in the resulting
     *     lists
     * @param  any common base class shared by all axes (often just {@link
     *     Object})
     * @return the Cartesian product, as an immutable list containing immutable
     *     lists
     * @throws IllegalArgumentException if the size of the cartesian product would
     *     be greater than {@link Integer#MAX_VALUE}
     * @throws NullPointerException if {@code lists}, any one of the
     *     {@code lists}, or any element of a provided list is null
     * @since 19.0
     */
    @SafeVarargs
    public static  List> cartesianProduct(final Collection... cs) {
        return cartesianProduct(Arrays.asList(cs));
    }

    /**
     * Note: copy from Google Guava under Apache License v2.
     * 

     * 
     * Returns every possible list that can be formed by choosing one element
     * from each of the given lists in order; the "n-ary
     * Cartesian
     * product" of the lists. For example: 
   {@code
     *
     *   Lists.cartesianProduct(ImmutableList.of(
     *       ImmutableList.of(1, 2),
     *       ImmutableList.of("A", "B", "C")))}
     *
     * 
returns a list containing six lists in the following order:
     *
     * 

     * 
{@code ImmutableList.of(1, "A")}
     * 
{@code ImmutableList.of(1, "B")}
     * 
{@code ImmutableList.of(1, "C")}
     * 
{@code ImmutableList.of(2, "A")}
     * 
{@code ImmutableList.of(2, "B")}
     * 
{@code ImmutableList.of(2, "C")}
     * 
     *
     * 
The result is guaranteed to be in the "traditional", lexicographical
     * order for Cartesian products that you would get from nesting for loops:
     * 
   {@code
     *
     *   for (B b0 : lists.get(0)) {
     *     for (B b1 : lists.get(1)) {
     *       ...
     *       ImmutableList tuple = ImmutableList.of(b0, b1, ...);
     *       // operate on tuple
     *     }
     *   }}

     *
     * 
Note that if any input list is empty, the Cartesian product will also be
     * empty. If no lists at all are provided (an empty list), the resulting
     * Cartesian product has one element, an empty list (counter-intuitive, but
     * mathematically consistent).
     *
     * 
Performance notes: while the cartesian product of lists of size
     * {@code m, n, p} is a list of size {@code m x n x p}, its actual memory
     * consumption is much smaller. When the cartesian product is constructed, the
     * input lists are merely copied. Only as the resulting list is iterated are
     * the individual lists created, and these are not retained after iteration.
     *
     * @param cs the lists to choose elements from, in the order that
     *     the elements chosen from those lists should appear in the resulting
     *     lists
     * @param  any common base class shared by all axes (often just {@link
     *     Object})
     * @return the Cartesian product, as an immutable list containing immutable
     *     lists
     * @throws IllegalArgumentException if the size of the cartesian product would
     *     be greater than {@link Integer#MAX_VALUE}
     * @throws NullPointerException if {@code lists}, any one of the {@code lists},
     *     or any element of a provided list is null
     * @since 19.0
     */
    public static  List> cartesianProduct(final Collection> cs) {
        return new CartesianList<>(cs);
    }

    private static final class CartesianList extends AbstractList> implements RandomAccess {
        private final transient Object[][] axes;
        private final transient int[] axesSizeProduct;

        CartesianList(final Collection> cs) {
            final Iterator> iter = cs.iterator();
            this.axes = new Object[cs.size()][];

            for (int i = 0, len = this.axes.length; i < len; i++) {
                this.axes[i] = iter.next().toArray();
            }

            this.axesSizeProduct = new int[axes.length + 1];
            axesSizeProduct[axes.length] = 1;

            try {
                for (int i = axes.length - 1; i >= 0; i--) {
                    axesSizeProduct[i] = Math2.multiplyExact(axesSizeProduct[i + 1], axes[i].length);
                }
            } catch (ArithmeticException e) {
                throw new IllegalArgumentException("Cartesian product too large; must have size at most Integer.MAX_VALUE");
            }
        }

        @Override
        public List get(final int index) {
            N.checkArgument(index < size(), "Invalid index %s. It must be less than the size %s", index, size());

            final List result = new ArrayList<>(axes.length);

            for (int k = 0, len = axes.length; k < len; k++) {
                result.add((E) axes[k][getAxisIndexForProductIndex(index, k)]);
            }

            return result;
        }

        @Override
        public int size() {
            return axesSizeProduct[0];
        }

        @Override
        public boolean contains(Object obj) {
            if (!(obj instanceof Collection)) {
                return false;
            }

            final Collection c = (Collection) obj;

            if (c.size() != axes.length) {
                return false;
            }

            int idx = 0;
            for (Object e : c) {
                boolean found = false;

                for (Object p : axes[idx++]) {
                    if (N.equals(e, p)) {
                        found = true;
                        break;
                    }
                }

                if (found == false) {
                    return false;
                }
            }

            return true;
        }

        private int getAxisIndexForProductIndex(int index, int axis) {
            return (index / axesSizeProduct[axis + 1]) % axes[axis].length;
        }
    }
}