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

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

Go to download

A general programming library in Java/Android. It's easy to learn and simple to use with concise and powerful APIs.

There is a newer version: 5.2.4
Show newest version
/*
 * Copyright (c) 2015, Haiyang Li.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.landawn.abacus.util;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.nio.charset.Charset;
import java.security.SecureRandom;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.SQLException;
import java.util.AbstractMap;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.RandomAccess;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;

import com.landawn.abacus.annotation.Beta;
import com.landawn.abacus.annotation.Immutable;
import com.landawn.abacus.annotation.Internal;
import com.landawn.abacus.annotation.NullSafe;
import com.landawn.abacus.exception.TooManyElementsException;
import com.landawn.abacus.exception.UncheckedSQLException;
import com.landawn.abacus.parser.ParserUtil;
import com.landawn.abacus.parser.ParserUtil.BeanInfo;
import com.landawn.abacus.parser.ParserUtil.PropInfo;
import com.landawn.abacus.type.Type;
import com.landawn.abacus.type.TypeFactory;
import com.landawn.abacus.util.Fn.IntFunctions;
import com.landawn.abacus.util.Fn.Suppliers;
import com.landawn.abacus.util.u.Nullable;
import com.landawn.abacus.util.u.Optional;
import com.landawn.abacus.util.u.OptionalInt;
import com.landawn.abacus.util.function.ToFloatFunction;

/**
 * 

 * Note: This class includes codes copied from Apache Commons Lang, Google Guava and other open source projects under the Apache License 2.0.
 * The methods copied from other libraries/frameworks/projects may be modified in this class.
 * 

 * Class N is a general java utility class. It provides the most daily used operations for Object/primitive types/String/Array/Collection/Map/Bean...:
 *
 * When to throw exception? It's designed to avoid throwing any unnecessary
 * exception if the contract defined by method is not broken. for example, if
 * user tries to reverse a null or empty String. the input String will be
 * returned. But exception will be thrown if trying to repeat/swap a null or
 * empty string or operate Array/Collection by adding/removing... 

 *
 * @author Haiyang Li
 *
 * @version $Revision: 0.8 $ 07/03/10
 *
 * @see com.landawn.abacus.util.Array
 * @see com.landawn.abacus.util.Iterables
 * @see com.landawn.abacus.util.Iterators
 * @see com.landawn.abacus.util.Maps
 * @see com.landawn.abacus.util.Strings
 * @see com.landawn.abacus.util.IOUtil
 */
@SuppressWarnings("java:S1192")
class CommonUtil {
    // ... it has to be big enough to make it's safety to add element to
    // ArrayBlockingQueue.
    @SuppressWarnings("deprecation")
    static final int POOL_SIZE = InternalUtil.POOL_SIZE;

    /**
     * An empty immutable {@code Boolean} array.
     */
    static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = {};
    /**
     * An empty immutable {@code Character} array.
     */
    static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = {};
    /**
     * An empty immutable {@code Byte} array.
     */
    static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = {};
    /**
     * An empty immutable {@code Short} array.
     */
    static final Short[] EMPTY_SHORT_OBJECT_ARRAY = {};
    /**
     * An empty immutable {@code Integer} array.
     */
    static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = {};
    /**
     * An empty immutable {@code Long} array.
     */
    static final Long[] EMPTY_LONG_OBJECT_ARRAY = {};
    /**
     * An empty immutable {@code Float} array.
     */
    static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = {};
    /**
     * An empty immutable {@code Double} array.
     */
    static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = {};
    /**
     * An empty immutable {@code Class} array.
     */
    static final Class[] EMPTY_CLASS_ARRAY = new Class[0];

    static final String TRUE = Boolean.TRUE.toString().intern();

    static final char[] TRUE_CHAR_ARRAY = TRUE.toCharArray();

    static final String FALSE = Boolean.FALSE.toString().intern();

    static final char[] FALSE_CHAR_ARRAY = FALSE.toCharArray();

    //    /**
    //     * String with value {@code "null"}.
    //     * @deprecated replaced by {@code Strings.NULL_STRING}
    //     * @see Strings#NULL_STRING
    //     */
    //    @Deprecated
    //    public static final String NULL_STRING = "null".intern();
    //
    //    /**
    //     * @deprecated replaced by {@code Strings.NULL_CHAR_ARRAY}
    //     * @see Strings#NULL_CHAR_ARRAY
    //     */
    //    @Deprecated
    //    public static final char[] NULL_CHAR_ARRAY = NULL_STRING.toCharArray();

    static final char CHAR_ZERO = WD.CHAR_ZERO;

    /**
     * The Constant CHAR_LF.
     *
     * @see JLF:
     *      Escape Sequences for Character and String Literals
     * @since 2.2
     */
    static final char CHAR_LF = WD.CHAR_LF;

    /**
     * The Constant CHAR_CR.
     *
     * @see JLF:
     *      Escape Sequences for Character and String Literals
     * @since 2.2
     */
    static final char CHAR_CR = WD.CHAR_CR;

    static final int BINARYSEARCH_THRESHOLD = 64;

    // ...
    /**
     * The index value when an element is not found in a list or array:
     * {@code -1}. This value is returned by methods in this class and can also
     * be used in comparisons with values returned by various method from
     * {@link java.util.List} .
     */
    public static final int INDEX_NOT_FOUND = -1;

    // ...
    public static final String EMPTY_STRING = "".intern();

    /**
     * An empty immutable {@code boolean} array.
     */
    public static final boolean[] EMPTY_BOOLEAN_ARRAY = {};
    /**
     * An empty immutable {@code char} array.
     */
    public static final char[] EMPTY_CHAR_ARRAY = {};
    /**
     * An empty immutable {@code byte} array.
     */
    public static final byte[] EMPTY_BYTE_ARRAY = {};
    /**
     * An empty immutable {@code short} array.
     */
    public static final short[] EMPTY_SHORT_ARRAY = {};
    /**
     * An empty immutable {@code int} array.
     */
    public static final int[] EMPTY_INT_ARRAY = {};
    /**
     * An empty immutable {@code long} array.
     */
    public static final long[] EMPTY_LONG_ARRAY = {};
    /**
     * An empty immutable {@code float} array.
     */
    public static final float[] EMPTY_FLOAT_ARRAY = {};
    /**
     * An empty immutable {@code double} array.
     */
    public static final double[] EMPTY_DOUBLE_ARRAY = {};
    /**
     * An empty immutable {@code Boolean} array.
     */
    public static final Boolean[] EMPTY_BOOLEAN_OBJ_ARRAY = {};
    /**
     * An empty immutable {@code Character} array.
     */
    public static final Character[] EMPTY_CHAR_OBJ_ARRAY = {};
    /**
     * An empty immutable {@code Byte} array.
     */
    public static final Byte[] EMPTY_BYTE_OBJ_ARRAY = {};
    /**
     * An empty immutable {@code Short} array.
     */
    public static final Short[] EMPTY_SHORT_OBJ_ARRAY = {};

    /**
     * An empty immutable {@code Integer} array.
     */
    public static final Integer[] EMPTY_INT_OBJ_ARRAY = {};
    /**
     * An empty immutable {@code Long} array.
     */
    public static final Long[] EMPTY_LONG_OBJ_ARRAY = {};
    /**
     * An empty immutable {@code Float} array.
     */
    public static final Float[] EMPTY_FLOAT_OBJ_ARRAY = {};
    /**
     * An empty immutable {@code Double} array.
     */
    public static final Double[] EMPTY_DOUBLE_OBJ_ARRAY = {};
    /**
     * An empty immutable {@code String} array.
     */
    public static final String[] EMPTY_STRING_ARRAY = {};
    /**
     * An empty immutable {@code Date} array.
     */
    public static final java.util.Date[] EMPTY_DATE_ARRAY = {};
    /**
     * An empty immutable {@code Calendar} array.
     */
    public static final Calendar[] EMPTY_CALENDAR_ARRAY = {};
    /**
     * An empty immutable {@code Object} array.
     */
    public static final Object[] EMPTY_OBJECT_ARRAY = {};

    @SuppressWarnings("rawtypes")
    static final List EMPTY_LIST = Collections.emptyList();

    @SuppressWarnings("rawtypes")
    static final Set EMPTY_SET = Collections.emptySet();

    @SuppressWarnings("rawtypes")
    static final SortedSet EMPTY_SORTED_SET = Collections.emptySortedSet();

    @SuppressWarnings("rawtypes")
    static final NavigableSet EMPTY_NAVIGABLE_SET = Collections.emptyNavigableSet();

    @SuppressWarnings("rawtypes")
    static final Map EMPTY_MAP = Collections.emptyMap();

    @SuppressWarnings("rawtypes")
    static final SortedMap EMPTY_SORTED_MAP = Collections.emptySortedMap();

    @SuppressWarnings("rawtypes")
    static final NavigableMap EMPTY_NAVIGABLE_MAP = Collections.emptyNavigableMap();

    @SuppressWarnings("rawtypes")
    static final Iterator EMPTY_ITERATOR = Collections.emptyIterator();

    @SuppressWarnings("rawtypes")
    static final ListIterator EMPTY_LIST_ITERATOR = Collections.emptyListIterator();

    // ...
    static final Object NULL_MASK = new NullMask();

    static final String BACKSLASH_ASTERISK = "*";

    // ...
    static final int REVERSE_THRESHOLD = 18;

    static final int FILL_THRESHOLD = 25;

    static final int REPLACEALL_THRESHOLD = 11;

    // ...
    static final Random RAND = new SecureRandom();

    @SuppressWarnings("rawtypes")
    static final Comparator NULL_MIN_COMPARATOR = Comparators.nullsFirst();

    @SuppressWarnings("rawtypes")
    static final Comparator NULL_MAX_COMPARATOR = Comparators.nullsLast();

    @SuppressWarnings("rawtypes")
    static final Comparator NATURAL_ORDER = Comparators.naturalOrder();

    // ...
    static final Map, Object> CLASS_EMPTY_ARRAY = new ConcurrentHashMap<>();

    static {
        CLASS_EMPTY_ARRAY.put(boolean.class, EMPTY_BOOLEAN_ARRAY);
        CLASS_EMPTY_ARRAY.put(Boolean.class, EMPTY_BOOLEAN_OBJECT_ARRAY);

        CLASS_EMPTY_ARRAY.put(char.class, EMPTY_CHAR_ARRAY);
        CLASS_EMPTY_ARRAY.put(Character.class, EMPTY_CHARACTER_OBJECT_ARRAY);

        CLASS_EMPTY_ARRAY.put(byte.class, EMPTY_BYTE_ARRAY);
        CLASS_EMPTY_ARRAY.put(Byte.class, EMPTY_BYTE_OBJECT_ARRAY);

        CLASS_EMPTY_ARRAY.put(short.class, EMPTY_SHORT_ARRAY);
        CLASS_EMPTY_ARRAY.put(Short.class, EMPTY_SHORT_OBJECT_ARRAY);

        CLASS_EMPTY_ARRAY.put(int.class, EMPTY_INT_ARRAY);
        CLASS_EMPTY_ARRAY.put(Integer.class, EMPTY_INTEGER_OBJECT_ARRAY);

        CLASS_EMPTY_ARRAY.put(long.class, EMPTY_LONG_ARRAY);
        CLASS_EMPTY_ARRAY.put(Long.class, EMPTY_LONG_OBJECT_ARRAY);

        CLASS_EMPTY_ARRAY.put(float.class, EMPTY_FLOAT_ARRAY);
        CLASS_EMPTY_ARRAY.put(Float.class, EMPTY_FLOAT_OBJECT_ARRAY);

        CLASS_EMPTY_ARRAY.put(double.class, EMPTY_DOUBLE_ARRAY);
        CLASS_EMPTY_ARRAY.put(Double.class, EMPTY_DOUBLE_OBJECT_ARRAY);

        CLASS_EMPTY_ARRAY.put(String.class, EMPTY_STRING_ARRAY);
        CLASS_EMPTY_ARRAY.put(Object.class, EMPTY_OBJECT_ARRAY);
    }

    // ...
    static final Map, Integer> CLASS_TYPE_ENUM = new HashMap<>();

    static {
        CLASS_TYPE_ENUM.put(boolean.class, 1);
        CLASS_TYPE_ENUM.put(char.class, 2);
        CLASS_TYPE_ENUM.put(byte.class, 3);
        CLASS_TYPE_ENUM.put(short.class, 4);
        CLASS_TYPE_ENUM.put(int.class, 5);
        CLASS_TYPE_ENUM.put(long.class, 6);
        CLASS_TYPE_ENUM.put(float.class, 7);
        CLASS_TYPE_ENUM.put(double.class, 8);
        CLASS_TYPE_ENUM.put(String.class, 9);
        CLASS_TYPE_ENUM.put(boolean[].class, 11);
        CLASS_TYPE_ENUM.put(char[].class, 12);
        CLASS_TYPE_ENUM.put(byte[].class, 13);
        CLASS_TYPE_ENUM.put(short[].class, 14);
        CLASS_TYPE_ENUM.put(int[].class, 15);
        CLASS_TYPE_ENUM.put(long[].class, 16);
        CLASS_TYPE_ENUM.put(float[].class, 17);
        CLASS_TYPE_ENUM.put(double[].class, 18);
        CLASS_TYPE_ENUM.put(String[].class, 19);

        CLASS_TYPE_ENUM.put(Boolean.class, 21);
        CLASS_TYPE_ENUM.put(Character.class, 22);
        CLASS_TYPE_ENUM.put(Byte.class, 23);
        CLASS_TYPE_ENUM.put(Short.class, 24);
        CLASS_TYPE_ENUM.put(Integer.class, 25);
        CLASS_TYPE_ENUM.put(Long.class, 26);
        CLASS_TYPE_ENUM.put(Float.class, 27);
        CLASS_TYPE_ENUM.put(Double.class, 28);
    }

    // ...
    static final BiMap, Class> PRIMITIVE_2_WRAPPER = new BiMap<>();

    static {
        PRIMITIVE_2_WRAPPER.put(boolean.class, Boolean.class);
        PRIMITIVE_2_WRAPPER.put(char.class, Character.class);
        PRIMITIVE_2_WRAPPER.put(byte.class, Byte.class);
        PRIMITIVE_2_WRAPPER.put(short.class, Short.class);
        PRIMITIVE_2_WRAPPER.put(int.class, Integer.class);
        PRIMITIVE_2_WRAPPER.put(long.class, Long.class);
        PRIMITIVE_2_WRAPPER.put(float.class, Float.class);
        PRIMITIVE_2_WRAPPER.put(double.class, Double.class);

        PRIMITIVE_2_WRAPPER.put(boolean[].class, Boolean[].class);
        PRIMITIVE_2_WRAPPER.put(char[].class, Character[].class);
        PRIMITIVE_2_WRAPPER.put(byte[].class, Byte[].class);
        PRIMITIVE_2_WRAPPER.put(short[].class, Short[].class);
        PRIMITIVE_2_WRAPPER.put(int[].class, Integer[].class);
        PRIMITIVE_2_WRAPPER.put(long[].class, Long[].class);
        PRIMITIVE_2_WRAPPER.put(float[].class, Float[].class);
        PRIMITIVE_2_WRAPPER.put(double[].class, Double[].class);
    }

    // ...
    private static final Map>, ImmutableList>> enumListPool = new ObjectPool<>(POOL_SIZE);

    private static final Map>, ImmutableSet>> enumSetPool = new ObjectPool<>(POOL_SIZE);

    private static final Map>, ImmutableBiMap, String>> enumMapPool = new ObjectPool<>(POOL_SIZE);

    private static final Map> nameTypePool = new ObjectPool<>(POOL_SIZE);

    private static final Map, Type> clsTypePool = new ObjectPool<>(POOL_SIZE);

    static final String[] charStringCache = new String[128];

    static final int intStringCacheLow = -1001;

    static final int intStringCacheHigh = 10001;

    static final String[] intStringCache = new String[intStringCacheHigh - intStringCacheLow];

    static final Map stringIntCache = new HashMap<>((int) (intStringCache.length * 1.5));

    static {
        for (int i = 0, j = intStringCacheLow, len = intStringCache.length; i < len; i++, j++) {
            intStringCache[i] = Integer.toString(j);
            stringIntCache.put(intStringCache[i], j);
        }

        for (int i = 0; i < charStringCache.length; i++) {
            charStringCache[i] = String.valueOf((char) i);
        }
    }

    private static final int MIN_SIZE_FOR_COPY_ALL = 9;

    CommonUtil() {
        // Utility class.
    }

    /**
     *
     * @param 
     * @param typeName
     * @return
     * @throws IllegalArgumentException if the specified typeName is null.
     */
    @SuppressWarnings("unchecked")
    public static  Type typeOf(final String typeName) throws IllegalArgumentException {
        N.checkArgNotNull(typeName, "typeName");

        Type type = nameTypePool.get(typeName);

        if (type == null) {
            type = TypeFactory.getType(typeName);

            nameTypePool.put(typeName, type);
        }

        return (Type) type;
    }

    /**
     *
     * @param 
     * @param cls
     * @return
     * @throws IllegalArgumentException if the specified {@code Class} is null.
     */
    @SuppressWarnings("unchecked")
    public static  Type typeOf(final Class cls) throws IllegalArgumentException {
        N.checkArgNotNull(cls, "cls");

        Type type = clsTypePool.get(cls);

        if (type == null) {
            type = TypeFactory.getType(cls);
            clsTypePool.put(cls, type);
        }

        return (Type) type;
    }

    /**
     *
     *
     * @param 
     * @param str
     * @param targetClass
     * @return
     */
    @SuppressWarnings("unchecked")
    public static  T valueOf(final String str, final Class targetClass) {
        return (str == null) ? defaultValueOf(targetClass) : (T) typeOf(targetClass).valueOf(str);
    }

    /**
     * Default value of.
     *
     * @param 
     * @param cls
     * @return
     */
    @SuppressWarnings("unchecked")
    public static  T defaultValueOf(final Class cls) {
        return (T) typeOf(cls).defaultValue();
    }

    /**
     * Default if null.
     *
     * @param b
     * @return
     */
    public static boolean defaultIfNull(Boolean b) {
        if (b == null) {
            return false;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @param defaultForNull
     * @return
     */
    public static boolean defaultIfNull(Boolean b, boolean defaultForNull) {
        if (b == null) {
            return defaultForNull;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param c
     * @return
     */
    public static char defaultIfNull(Character c) {
        if (c == null) {
            return CHAR_ZERO;
        }

        return c;
    }

    /**
     * Default if null.
     *
     * @param c
     * @param defaultForNull
     * @return
     */
    public static char defaultIfNull(Character c, char defaultForNull) {
        if (c == null) {
            return defaultForNull;
        }

        return c;
    }

    /**
     * Default if null.
     *
     * @param b
     * @return
     */
    public static byte defaultIfNull(Byte b) {
        if (b == null) {
            return (byte) 0;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @param defaultForNull
     * @return
     */
    public static byte defaultIfNull(Byte b, byte defaultForNull) {
        if (b == null) {
            return defaultForNull;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @return
     */
    public static short defaultIfNull(Short b) {
        if (b == null) {
            return (short) 0;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @param defaultForNull
     * @return
     */
    public static short defaultIfNull(Short b, short defaultForNull) {
        if (b == null) {
            return defaultForNull;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @return
     */
    public static int defaultIfNull(Integer b) {
        if (b == null) {
            return 0;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @param defaultForNull
     * @return
     */
    public static int defaultIfNull(Integer b, int defaultForNull) {
        if (b == null) {
            return defaultForNull;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @return
     */
    public static long defaultIfNull(Long b) {
        if (b == null) {
            return 0;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @param defaultForNull
     * @return
     */
    public static long defaultIfNull(Long b, long defaultForNull) {
        if (b == null) {
            return defaultForNull;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @return
     */
    public static float defaultIfNull(Float b) {
        if (b == null) {
            return 0;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @param defaultForNull
     * @return
     */
    public static float defaultIfNull(Float b, float defaultForNull) {
        if (b == null) {
            return defaultForNull;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @return
     */
    public static double defaultIfNull(Double b) {
        if (b == null) {
            return 0;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param b
     * @param defaultForNull
     * @return
     */
    public static double defaultIfNull(Double b, double defaultForNull) {
        if (b == null) {
            return defaultForNull;
        }

        return b;
    }

    /**
     * Default if null.
     *
     * @param 
     * @param obj
     * @param defaultForNull
     * @return
     */
    public static  T defaultIfNull(final T obj, final T defaultForNull) {
        return obj == null ? defaultForNull : obj;
    }

    /**
     * Default if null.
     *
     * @param 
     * @param obj
     * @param supplierForDefault
     * @return
     */
    public static  T defaultIfNull(final T obj, final Supplier supplierForDefault) {
        if (obj == null) {
            return supplierForDefault.get();
        }

        return obj;
    }

    /**
     *
     *
     * @param 
     * @param str
     * @param defaultStr
     * @return
     */
    public static  T defaultIfNullOrEmpty(final T str, final T defaultStr) {
        return N.isNullOrEmpty(str) ? defaultStr : str;
    }

    /**
     * 
Returns either the passed in CharSequence, or if the CharSequence is
     * whitespace, empty ("") or {@code null}, the value of {@code defaultStr}.

     *
     * 
Whitespace is defined by {@link Character#isWhitespace(char)}.

     *
     * @param 
     * @param str
     * @param defaultStr
     * @return
     */
    public static  T defaultIfBlank(final T str, final T defaultStr) {
        return N.isBlank(str) ? defaultStr : str;
    }

    /**
     *
     * @param val
     * @return
     */
    public static String stringOf(final boolean val) {
        return String.valueOf(val);
    }

    /**
     *
     * @param val
     * @return
     */
    public static String stringOf(final char val) {
        if (val < 128) {
            return charStringCache[val];
        }

        return String.valueOf(val);
    }

    /**
     *
     * @param val
     * @return
     */
    public static String stringOf(final byte val) {
        if (val > intStringCacheLow && val < intStringCacheHigh) {
            return intStringCache[val - intStringCacheLow];
        }

        return String.valueOf(val);
    }

    /**
     *
     * @param val
     * @return
     */
    public static String stringOf(final short val) {
        if (val > intStringCacheLow && val < intStringCacheHigh) {
            return intStringCache[val - intStringCacheLow];
        }

        return String.valueOf(val);
    }

    /**
     *
     * @param val
     * @return
     */
    public static String stringOf(final int val) {
        if (val > intStringCacheLow && val < intStringCacheHigh) {
            return intStringCache[val - intStringCacheLow];
        }

        return String.valueOf(val);
    }

    /**
     *
     * @param val
     * @return
     */
    public static String stringOf(final long val) {
        if (val > intStringCacheLow && val < intStringCacheHigh) {
            return intStringCache[(int) (val - intStringCacheLow)];
        }

        return String.valueOf(val);
    }

    /**
     *
     * @param val
     * @return
     */
    public static String stringOf(final float val) {
        return String.valueOf(val);
    }

    /**
     *
     * @param val
     * @return
     */
    public static String stringOf(final double val) {
        return String.valueOf(val);
    }

    /**
     *
     * @param obj
     * @return null if the specified object is null.
     */
    public static String stringOf(final Object obj) {
        return (obj == null) ? null : typeOf(obj.getClass()).stringOf(obj);
    }

    /**
     * Enum list of.
     *
     * @param 
     * @param enumClass
     * @return
     */
    @SuppressWarnings("deprecation")
    public static > ImmutableList enumListOf(final Class enumClass) {
        ImmutableList enumList = (ImmutableList) enumListPool.get(enumClass);

        if (enumList == null) {
            enumList = ImmutableList.wrap(asList(enumClass.getEnumConstants()));

            enumListPool.put(enumClass, enumList);
        }

        return enumList;
    }

    /**
     * Enum set of.
     *
     * @param 
     * @param enumClass
     * @return
     */
    @SuppressWarnings("deprecation")
    public static > ImmutableSet enumSetOf(final Class enumClass) {
        ImmutableSet enumSet = (ImmutableSet) enumSetPool.get(enumClass);

        if (enumSet == null) {
            enumSet = ImmutableSet.wrap(EnumSet.allOf(enumClass));

            enumSetPool.put(enumClass, enumSet);
        }

        return enumSet;
    }

    /**
     * Enum map of.
     *
     * @param 
     * @param enumClass
     * @return
     */
    @SuppressWarnings("deprecation")
    public static > ImmutableBiMap enumMapOf(final Class enumClass) {
        ImmutableBiMap enumMap = (ImmutableBiMap) enumMapPool.get(enumClass);

        if (enumMap == null) {
            final EnumMap keyMap = new EnumMap<>(enumClass);
            final Map valueMap = new HashMap<>();

            for (final E e : enumClass.getEnumConstants()) {
                keyMap.put(e, e.name());
                valueMap.put(e.name(), e);
            }

            enumMap = ImmutableBiMap.wrap(new BiMap<>(keyMap, valueMap));

            enumMapPool.put(enumClass, enumMap);
        }

        return enumMap;
    }

    /**
     *
     * @param 
     * @param cls
     * @return T
     * @see Suppliers#ofCollection(Class)
     * @see Suppliers#registerForCollection(Class, com.landawn.abacus.util.function.Supplier)
     * @see Suppliers#ofMap(Class)
     * @see Suppliers#registerForMap(Class, com.landawn.abacus.util.function.Supplier)
     * @see IntFunctions#ofCollection(Class)
     * @see IntFunctions#registerForCollection(Class, com.landawn.abacus.util.function.IntFunction)
     * @see IntFunctions#ofMap(Class)
     * @see IntFunctions#registerForMap(Class, com.landawn.abacus.util.function.IntFunction)
     */
    @SuppressWarnings("rawtypes")
    public static  T newInstance(final Class cls) {
        if (Modifier.isAbstract(cls.getModifiers())) {
            if (Collection.class.isAssignableFrom(cls)) {
                return (T) Suppliers.ofCollection((Class) cls).get();
            } else if (Map.class.isAssignableFrom(cls)) {
                return (T) Suppliers.ofMap((Class) cls).get();
            } else {
                throw new IllegalArgumentException("Can't create instance for abstract class: " + cls);
            }
        }

        if (!Modifier.isStatic(cls.getModifiers()) && ClassUtil.isAnonymousOrMemeberClass(cls)) {
            try {
                // http://stackoverflow.com/questions/2097982/is-it-possible-to-create-an-instance-of-nested-class-using-java-reflection

                final List> toInstantiate = new ArrayList<>();
                Class parent = cls.getEnclosingClass();

                do {
                    toInstantiate.add(parent);
                    parent = parent.getEnclosingClass();
                } while (parent != null && !Modifier.isStatic(parent.getModifiers()) && ClassUtil.isAnonymousOrMemeberClass(parent));

                if (parent != null) {
                    toInstantiate.add(parent);
                }

                reverse(toInstantiate);

                Object instance = null;
                for (Class current : toInstantiate) {
                    instance = instance == null ? invoke(ClassUtil.getDeclaredConstructor(current))
                            : invoke(ClassUtil.getDeclaredConstructor(current, instance.getClass()), instance);
                }

                return invoke(ClassUtil.getDeclaredConstructor(cls, instance.getClass()), instance);
            } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                throw ExceptionUtil.toRuntimeException(e);
            }
        } else {
            try {
                final Constructor constructor = ClassUtil.getDeclaredConstructor(cls);

                if (constructor == null) {
                    throw new IllegalArgumentException("No default constructor found in class: " + ClassUtil.getCanonicalClassName(cls));
                }

                return invoke(constructor);
            } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                throw ExceptionUtil.toRuntimeException(e);
            }
        }
    }

    /**
     *
     * @param 
     * @param c
     * @param args
     * @return
     * @throws InstantiationException the instantiation exception
     * @throws IllegalAccessException the illegal access exception
     * @throws IllegalArgumentException the illegal argument exception
     * @throws InvocationTargetException the invocation target exception
     */
    @SuppressWarnings({ "unchecked", "deprecation" })
    static  T invoke(final Constructor c, final Object... args)
            throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        if (!c.isAccessible()) {
            ClassUtil.setAccessibleQuietly(c, true);
        }

        return c.newInstance(args);
    }

    /**
     * New proxy instance.
     *
     * @param 
     * @param interfaceClass
     * @param h
     * @return
     */
    public static  T newProxyInstance(final Class interfaceClass, final InvocationHandler h) {
        return newProxyInstance(asArray(interfaceClass), h);
    }

    /**
     * Refer to {@code java.lang.reflect}
     *
     * @param 
     * @param interfaceClasses
     * @param h
     * @return
     */
    public static  T newProxyInstance(final Class[] interfaceClasses, final InvocationHandler h) {
        return (T) Proxy.newProxyInstance(CommonUtil.class.getClassLoader(), interfaceClasses, h);
    }

    /**
     *
     * @param 
     * @param targetClass
     * @return
     * @see Suppliers#ofCollection(Class)
     * @see Suppliers#registerForCollection(Class, com.landawn.abacus.util.function.Supplier)
     */
    @SuppressWarnings("rawtypes")
    public static  Collection newCollection(final Class targetClass) {
        return Suppliers. ofCollection(targetClass).get();
    }

    /**
     *
     * @param 
     * @param targetClass
     * @param size
     * @return
     * @see IntFunctions#ofCollection(Class)
     * @see IntFunctions#registerForCollection(Class, com.landawn.abacus.util.function.IntFunction)
     */
    @SuppressWarnings("rawtypes")
    public static  Collection newCollection(final Class targetClass, final int size) {
        return IntFunctions. ofCollection(targetClass).apply(size);
    }

    /**
     *
     * @param 
     * @param 
     * @param targetClass
     * @return
     * @see Suppliers#ofMap(Class)
     * @see Suppliers#registerForMap(Class, com.landawn.abacus.util.function.Supplier)
     */
    @SuppressWarnings("rawtypes")
    public static  Map newMap(final Class targetClass) {
        return Suppliers. ofMap(targetClass).get();
    }

    /**
     *
     * @param 
     * @param 
     * @param targetClass
     * @param size
     * @return
     * @see IntFunctions#ofMap(Class)
     * @see IntFunctions#registerForMap(Class, com.landawn.abacus.util.function.IntFunction)
     */
    @SuppressWarnings("rawtypes")
    public static  Map newMap(final Class targetClass, final int size) {
        return IntFunctions. ofMap(targetClass).apply(size);
    }

    /**
     *
     * @param 
     * @param componentType
     * @param length
     * @return T[]
     */
    @SuppressWarnings("unchecked")
    public static  T newArray(final Class componentType, final int length) {
        return (T) Array.newInstance(componentType, length);
    }

    /**
     *
     * @param 
     * @param cls
     * @return
     */
    @SuppressWarnings("unchecked")
    public static  T newBean(final Class cls) {
        return newBean(cls, null);
    }

    /**
     *
     * @param 
     * @param cls
     * @param beanName
     * @return
     */
    public static  T newBean(final Class cls, final String beanName) {
        if (MapEntity.class.isAssignableFrom(cls)) {
            return (T) new MapEntity(beanName);
        }

        return newInstance(cls);
    }

    /**
     * Returns a set backed by the specified map.
     *
     * @param 
     * @param map the backing map
     * @return
     * @see Collections#newSetFromMap(Map)
     */
    public static  Set newSetFromMap(final Map map) {
        return Collections.newSetFromMap(map);
    }

    /**
     * Inits the hash capacity.
     *
     * @param size
     * @return
     * @deprecated warning...
     */
    @Deprecated
    @Internal
    @Beta
    static int initHashCapacity(final int size) {
        checkArgNotNegative(size, "size");

        if (size == 0) {
            return 0;
        }

        int res = size < MAX_HASH_LENGTH ? (int) (size * 1.25) + 1 : MAX_ARRAY_SIZE;

        return res >= 1024 ? res : (res >= 256 ? 256 : res);
    }

    /**
     * New array list.
     *
     * @param 
     * @return
     */
    public static  ArrayList newArrayList() { //NOSONAR
        return new ArrayList<>();
    }

    /**
     * New array list.
     *
     * @param 
     * @param initialCapacity
     * @return
     */
    public static  ArrayList newArrayList(int initialCapacity) { //NOSONAR
        return new ArrayList<>(initialCapacity);
    }

    /**
     * New array list.
     *
     * @param 
     * @param c
     * @return
     */
    public static  ArrayList newArrayList(Collection c) { //NOSONAR
        return isNullOrEmpty(c) ? new ArrayList<>() : new ArrayList<>(c);
    }

    /**
     * New linked list.
     *
     * @param 
     * @return
     */
    public static  LinkedList newLinkedList() { //NOSONAR
        return new LinkedList<>();
    }

    /**
     * New linked list.
     *
     * @param 
     * @param c
     * @return
     */
    public static  LinkedList newLinkedList(Collection c) { //NOSONAR
        return isNullOrEmpty(c) ? new LinkedList<>() : new LinkedList<>(c);
    }

    /**
     * New hash set.
     *
     * @param 
     * @return
     */
    public static  Set newHashSet() {
        return new HashSet<>();
    }

    /**
     * New hash set.
     *
     * @param 
     * @param initialCapacity
     * @return
     */
    public static  Set newHashSet(int initialCapacity) {
        return new HashSet<>(N.initHashCapacity(initialCapacity));
    }

    /**
     * New hash set.
     *
     * @param 
     * @param c
     * @return
     */
    public static  Set newHashSet(Collection c) {
        return isNullOrEmpty(c) ? new HashSet<>() : new HashSet<>(c);
    }

    /**
     * New linked hash set.
     *
     * @param 
     * @return
     */
    public static  Set newLinkedHashSet() {
        return new LinkedHashSet<>();
    }

    /**
     * New linked hash set.
     *
     * @param 
     * @param initialCapacity
     * @return
     */
    public static  Set newLinkedHashSet(int initialCapacity) {
        return new LinkedHashSet<>(N.initHashCapacity(initialCapacity));
    }

    /**
     * New linked hash set.
     *
     * @param 
     * @param c
     * @return
     */
    public static  Set newLinkedHashSet(Collection c) {
        return isNullOrEmpty(c) ? new LinkedHashSet<>() : new LinkedHashSet<>(c);
    }

    /**
     * New tree set.
     *
     * @param 
     * @return
     */
    public static > TreeSet newTreeSet() { //NOSONAR
        return new TreeSet<>();
    }

    /**
     * New tree set.
     *
     * @param 
     * @param comparator
     * @return
     */
    public static  TreeSet newTreeSet(Comparator comparator) { //NOSONAR
        return new TreeSet<>(comparator);
    }

    /**
     * New tree set.
     *
     * @param 
     * @param c
     * @return
     */
    public static > TreeSet newTreeSet(Collection c) { //NOSONAR
        return isNullOrEmpty(c) ? new TreeSet<>() : new TreeSet<>(c);
    }

    /**
     * New tree set.
     *
     * @param 
     * @param c
     * @return
     */
    public static  TreeSet newTreeSet(SortedSet c) { //NOSONAR
        return isNullOrEmpty(c) ? new TreeSet<>() : new TreeSet<>(c);
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Multiset newMultiset() {
        return new Multiset<>();
    }

    /**
     *
     * @param 
     * @param initialCapacity
     * @return
     */
    public static  Multiset newMultiset(final int initialCapacity) {
        return new Multiset<>(initialCapacity);
    }

    /**
     *
     * @param 
     * @param valueMapType
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Multiset newMultiset(final Class valueMapType) {
        return new Multiset<>(valueMapType);
    }

    /**
     *
     * @param 
     * @param mapSupplier
     * @return
     */
    public static  Multiset newMultiset(final Supplier> mapSupplier) {
        return new Multiset<>(mapSupplier);
    }

    /**
     *
     * @param 
     * @param c
     * @return
     */
    public static  Multiset newMultiset(final Collection c) {
        return new Multiset<>(c);
    }

    /**
     *
     * @param 
     * @return
     */
    public static  LongMultiset newLongMultiset() {
        return new LongMultiset<>();
    }

    /**
     *
     * @param 
     * @param initialCapacity
     * @return
     */
    public static  LongMultiset newLongMultiset(final int initialCapacity) {
        return new LongMultiset<>(initialCapacity);
    }

    /**
     *
     * @param 
     * @param valueMapType
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  LongMultiset newLongMultiset(final Class valueMapType) {
        return new LongMultiset<>(valueMapType);
    }

    /**
     *
     * @param 
     * @param mapSupplier
     * @return
     */
    public static  LongMultiset newLongMultiset(final Supplier> mapSupplier) {
        return new LongMultiset<>(mapSupplier);
    }

    /**
     *
     * @param 
     * @param c
     * @return
     */
    public static  LongMultiset newLongMultiset(final Collection c) {
        return new LongMultiset<>(c);
    }

    /**
     * New array deque.
     *
     * @param 
     * @return
     */
    public static  ArrayDeque newArrayDeque() { //NOSONAR
        return new ArrayDeque<>();
    }

    /**
     * Constructs an empty array deque with an initial capacity sufficient to hold the specified number of elements.
     *
     * @param 
     * @param numElements lower bound on initial capacity of the deque.
     * @return
     */
    public static  ArrayDeque newArrayDeque(int numElements) { //NOSONAR
        return new ArrayDeque<>(numElements);
    }

    /**
     * Constructs a deque containing the elements of the specified collection, in the order they are returned by the collection's iterator.
     *
     * @param 
     * @param c
     * @return
     */
    public static  ArrayDeque newArrayDeque(Collection c) { //NOSONAR
        return new ArrayDeque<>(c);
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param key
     * @param value
     * @return
     */
    public static  Map.Entry newEntry(K key, V value) {
        return new AbstractMap.SimpleEntry<>(key, value);
    }

    /**
     * New immutable entry.
     *
     * @param  the key type
     * @param  the value type
     * @param key
     * @param value
     * @return
     */
    public static  ImmutableEntry newImmutableEntry(K key, V value) {
        return new ImmutableEntry<>(key, value);
    }

    /**
     * New hash map.
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    public static  Map newHashMap() {
        return new HashMap<>();
    }

    /**
     * New hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param initialCapacity
     * @return
     */
    public static  Map newHashMap(int initialCapacity) {
        return new HashMap<>(N.initHashCapacity(initialCapacity));
    }

    /**
     * New hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param m
     * @return
     */
    public static  Map newHashMap(Map m) {
        return isNullOrEmpty(m) ? new HashMap<>() : new HashMap<>(m);
    }

    /**
     * New hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param 
     * @param c
     * @param keyMapper
     * @return
     * @throws E the e
     */
    public static  Map newHashMap(final Collection c,
            final Throwables.Function keyMapper) throws E {
        checkArgNotNull(keyMapper);

        if (isNullOrEmpty(c)) {
            return new HashMap<>();
        }

        final Map result = N.newHashMap(c.size());

        for (V v : c) {
            result.put(keyMapper.apply(v), v);
        }

        return result;
    }

    /**
     * New linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    public static  Map newLinkedHashMap() {
        return new LinkedHashMap<>();
    }

    /**
     * New linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param initialCapacity
     * @return
     */
    public static  Map newLinkedHashMap(int initialCapacity) {
        return new LinkedHashMap<>(N.initHashCapacity(initialCapacity));
    }

    /**
     * New linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param m
     * @return
     */
    public static  Map newLinkedHashMap(Map m) {
        return isNullOrEmpty(m) ? new LinkedHashMap<>() : new LinkedHashMap<>(m);
    }

    /**
     * New linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param 
     * @param c
     * @param keyMapper
     * @return
     * @throws E the e
     */
    public static  Map newLinkedHashMap(final Collection c,
            final Throwables.Function keyMapper) throws E {
        checkArgNotNull(keyMapper);

        if (isNullOrEmpty(c)) {
            return N.newLinkedHashMap();
        }

        final Map result = N.newLinkedHashMap(c.size());

        for (V v : c) {
            result.put(keyMapper.apply(v), v);
        }

        return result;
    }

    /**
     * New tree map.
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    public static , V> TreeMap newTreeMap() { //NOSONAR
        return new TreeMap<>();
    }

    /**
     * New tree map.
     *
     * @param 
     * @param  the key type
     * @param  the value type
     * @param comparator
     * @return
     */
    public static  TreeMap newTreeMap(Comparator comparator) { //NOSONAR
        return new TreeMap<>(comparator);
    }

    /**
     * New tree map.
     *
     * @param  the key type
     * @param  the value type
     * @param m
     * @return
     */
    public static , V> TreeMap newTreeMap(Map m) { //NOSONAR
        return isNullOrEmpty(m) ? new TreeMap<>() : new TreeMap<>(m);
    }

    /**
     * New tree map.
     *
     * @param  the key type
     * @param  the value type
     * @param m
     * @return
     */
    public static  TreeMap newTreeMap(SortedMap m) { //NOSONAR
        return isNullOrEmpty(m) ? new TreeMap<>() : new TreeMap<>(m);
    }

    /**
     * New identity hash map.
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    public static  IdentityHashMap newIdentityHashMap() { //NOSONAR
        return new IdentityHashMap<>();
    }

    /**
     * New identity hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param initialCapacity
     * @return
     */
    public static  IdentityHashMap newIdentityHashMap(int initialCapacity) { //NOSONAR
        return new IdentityHashMap<>(N.initHashCapacity(initialCapacity));
    }

    /**
     * New identity hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param m
     * @return
     */
    public static  IdentityHashMap newIdentityHashMap(Map m) { //NOSONAR
        return isNullOrEmpty(m) ? new IdentityHashMap<>() : new IdentityHashMap<>(m);
    }

    /**
     * New concurrent hash map.
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    public static  ConcurrentHashMap newConcurrentHashMap() { //NOSONAR
        return new ConcurrentHashMap<>();
    }

    /**
     * New concurrent hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param initialCapacity
     * @return
     */
    public static  ConcurrentHashMap newConcurrentHashMap(int initialCapacity) { //NOSONAR
        return new ConcurrentHashMap<>(N.initHashCapacity(initialCapacity));
    }

    /**
     * New concurrent hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param m
     * @return
     */
    public static  ConcurrentHashMap newConcurrentHashMap(Map m) { //NOSONAR
        return isNullOrEmpty(m) ? new ConcurrentHashMap<>() : new ConcurrentHashMap<>(m);
    }

    /**
     * New bi map.
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    public static  BiMap newBiMap() {
        return new BiMap<>();
    }

    /**
     * New bi map.
     *
     * @param  the key type
     * @param  the value type
     * @param initialCapacity
     * @return
     */
    public static  BiMap newBiMap(int initialCapacity) {
        return new BiMap<>(initialCapacity);
    }

    /**
     * New bi map.
     *
     * @param  the key type
     * @param  the value type
     * @param initialCapacity
     * @param loadFactor
     * @return
     */
    public static  BiMap newBiMap(int initialCapacity, float loadFactor) {
        return new BiMap<>(initialCapacity, loadFactor);
    }

    /**
     * New bi map.
     *
     * @param  the key type
     * @param  the value type
     * @param keyMapType
     * @param valueMapType
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  BiMap newBiMap(final Class keyMapType, final Class valueMapType) {
        return new BiMap<>(keyMapType, valueMapType);
    }

    /**
     * New bi map.
     *
     * @param  the key type
     * @param  the value type
     * @param keyMapSupplier
     * @param valueMapSupplier
     * @return
     */
    public static  BiMap newBiMap(final Supplier> keyMapSupplier, final Supplier> valueMapSupplier) {
        return new BiMap<>(keyMapSupplier, valueMapSupplier);
    }

    /**
     *
     * @param  the key type
     * @param 
     * @param  the value type
     * @param mapSupplier
     * @param valueSupplier
     * @return
     */
    public static > Multimap newMultimap(final Supplier> mapSupplier,
            final Supplier valueSupplier) {
        return new Multimap<>(mapSupplier, valueSupplier);
    }

    /**
     * New list multimap.
     *
     * @param  the key type
     * @param 
     * @return
     */
    public static  ListMultimap newListMultimap() {
        return new ListMultimap<>();
    }

    /**
     * New list multimap.
     *
     * @param  the key type
     * @param 
     * @param initialCapacity
     * @return
     */
    public static  ListMultimap newListMultimap(final int initialCapacity) {
        return new ListMultimap<>(initialCapacity);
    }

    /**
     * New list multimap.
     *
     * @param  the key type
     * @param 
     * @param m
     * @return
     */
    public static  ListMultimap newListMultimap(final Map m) {
        final ListMultimap multiMap = newListMultimap(N.size(m));

        multiMap.putAll(m);

        return multiMap;
    }

    /**
     * New list multimap.
     *
     * @param  the key type
     * @param 
     * @param mapType
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  ListMultimap newListMultimap(final Class mapType) {
        return new ListMultimap<>(mapType, ArrayList.class);
    }

    /**
     * New list multimap.
     *
     * @param  the key type
     * @param 
     * @param mapType
     * @param valueType
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  ListMultimap newListMultimap(final Class mapType, final Class valueType) {
        return new ListMultimap<>(mapType, valueType);
    }

    /**
     * New list multimap.
     *
     * @param  the key type
     * @param 
     * @param mapSupplier
     * @param valueSupplier
     * @return
     */
    public static  ListMultimap newListMultimap(final Supplier>> mapSupplier,
            final Supplier> valueSupplier) {
        return new ListMultimap<>(mapSupplier, valueSupplier);
    }

    /**
     * Return a {@code ListMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value.
     *
     * @param  the key type
     * @param 
     * @return
     */
    public static  ListMultimap newLinkedListMultimap() {
        return new ListMultimap<>(LinkedHashMap.class, ArrayList.class);
    }

    /**
     * Return a {@code ListMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value.
     *
     * @param  the key type
     * @param 
     * @param initialCapacity
     * @return
     */
    public static  ListMultimap newLinkedListMultimap(final int initialCapacity) {
        return new ListMultimap<>(N.> newLinkedHashMap(initialCapacity), ArrayList.class);
    }

    /**
     * Return a {@code ListMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value.
     *
     * @param  the key type
     * @param 
     * @param m
     * @return
     */
    public static  ListMultimap newLinkedListMultimap(final Map m) {
        final ListMultimap multiMap = new ListMultimap<>(N.> newLinkedHashMap(N.size(m)), ArrayList.class);

        multiMap.putAll(m);

        return multiMap;
    }

    /**
     * Return a {@code ListMultimap} backed by {@code SortedMap}. {@code 'Sorted'} is about the map, not the value.
     *
     * @param  the key type
     * @param 
     * @return
     */
    public static , E> ListMultimap newSortedListMultimap() {
        return new ListMultimap<>(new TreeMap<>(), ArrayList.class);
    }

    /**
     * Return a {@code ListMultimap} backed by {@code SortedMap}. {@code 'Sorted'} is about the map, not the value.
     *
     * @param  the key type
     * @param 
     * @param m
     * @return
     */
    public static , E> ListMultimap newSortedListMultimap(final Map m) {
        final ListMultimap multiMap = new ListMultimap<>(new TreeMap<>(), ArrayList.class);

        multiMap.putAll(m);

        return multiMap;
    }

    /**
     * New set multimap.
     *
     * @param  the key type
     * @param 
     * @return
     */
    public static  SetMultimap newSetMultimap() {
        return new SetMultimap<>();
    }

    /**
     * New set multimap.
     *
     * @param  the key type
     * @param 
     * @param initialCapacity
     * @return
     */
    public static  SetMultimap newSetMultimap(final int initialCapacity) {
        return new SetMultimap<>(initialCapacity);
    }

    /**
     * New set multimap.
     *
     * @param  the key type
     * @param 
     * @param m
     * @return
     */
    public static  SetMultimap newSetMultimap(final Map m) {
        final SetMultimap multiMap = newSetMultimap(N.size(m));

        multiMap.putAll(m);

        return multiMap;
    }

    /**
     * New set multimap.
     *
     * @param  the key type
     * @param 
     * @param mapType
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  SetMultimap newSetMultimap(final Class mapType) {
        return new SetMultimap<>(mapType, HashSet.class);
    }

    /**
     * New set multimap.
     *
     * @param  the key type
     * @param 
     * @param mapType
     * @param valueType
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  SetMultimap newSetMultimap(final Class mapType, final Class valueType) {
        return new SetMultimap<>(mapType, valueType);
    }

    /**
     * New set multimap.
     *
     * @param  the key type
     * @param 
     * @param mapSupplier
     * @param valueSupplier
     * @return
     */
    public static  SetMultimap newSetMultimap(final Supplier>> mapSupplier,
            final Supplier> valueSupplier) {
        return new SetMultimap<>(mapSupplier, valueSupplier);
    }

    /**
     * Return a {@code SetMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value.
     *
     * @param  the key type
     * @param 
     * @return
     */
    public static  SetMultimap newLinkedSetMultimap() {
        return new SetMultimap<>(LinkedHashMap.class, HashSet.class);
    }

    /**
     * Return a {@code SetMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value.
     *
     * @param  the key type
     * @param 
     * @param initialCapacity
     * @return
     */
    public static  SetMultimap newLinkedSetMultimap(final int initialCapacity) {
        return new SetMultimap<>(N.> newLinkedHashMap(initialCapacity), HashSet.class);
    }

    /**
     * Return a {@code SetMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value.
     *
     * @param  the key type
     * @param 
     * @param m
     * @return
     */
    public static  SetMultimap newLinkedSetMultimap(final Map m) {
        final SetMultimap multiMap = new SetMultimap<>(N.> newLinkedHashMap(N.size(m)), HashSet.class);

        multiMap.putAll(m);

        return multiMap;
    }

    /**
     * Return a {@code SetMultimap} backed by {@code SortedMap}. {@code 'Sorted'} is about the map, not the value.
     *
     *
     * @param  the key type
     * @param 
     * @return
     */
    public static , E> SetMultimap newSortedSetMultimap() {
        return new SetMultimap<>(new TreeMap<>(), HashSet.class);
    }

    /**
     * Return a {@code SetMultimap} backed by {@code SortedMap}. {@code 'Sorted'} is about the map, not the value.
     *
     * @param  the key type
     * @param 
     * @param m
     * @return
     */
    public static , E> SetMultimap newSortedSetMultimap(final Map m) {
        final SetMultimap multiMap = new SetMultimap<>(new TreeMap<>(), HashSet.class);

        multiMap.putAll(m);

        return multiMap;
    }

    static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    static final int MAX_HASH_LENGTH = (int) (MAX_ARRAY_SIZE / 1.25) - 1;

    /**
     * New empty data set.
     *
     * @return
     */
    public static DataSet newEmptyDataSet() {
        return new RowDataSet(new ArrayList<>(), new ArrayList<>());
    }

    /**
     * New empty data set.
     *
     * @param columnNames
     * @return
     */
    public static DataSet newEmptyDataSet(final Collection columnNames) {
        if (isNullOrEmpty(columnNames)) {
            return newEmptyDataSet();
        }

        final List> columnList = new ArrayList<>(columnNames.size());

        for (int i = 0, size = columnNames.size(); i < size; i++) {
            columnList.add(new ArrayList<>(0));
        }

        return new RowDataSet(new ArrayList<>(columnNames), columnList);
    }

    /**
     * Convert the specified Map to a two columns DataSet: one column is for keys and one column is for values.
     *
     * @param keyColumnName
     * @param valueColumnName
     * @param m
     * @return
     */
    public static DataSet newDataSet(final String keyColumnName, final String valueColumnName, final Map m) {
        final List keyColumn = new ArrayList<>(m.size());
        final List valueColumn = new ArrayList<>(m.size());

        for (Map.Entry entry : m.entrySet()) {
            keyColumn.add(entry.getKey());
            valueColumn.add(entry.getValue());
        }

        final List columnNameList = asList(keyColumnName, valueColumnName);
        final List> columnList = asList(keyColumn, valueColumn);

        return newDataSet(columnNameList, columnList);
    }

    /**
     * The first row will be used as column names if its type is array or list,
     * or obtain the column names from first row if its type is bean or map.
     *
     * @param rowList list of row which can be: Map/Bean/Array/List
     * @return
     */
    public static DataSet newDataSet(final Collection rowList) {
        return newDataSet(null, rowList);
    }

    /**
     * If the specified {@code columnNames} is null or empty, the first row will be used as column names if its type is array or list,
     * or obtain the column names from first row if its type is bean or map.
     *
     * @param columnNames
     * @param rowList
     * @return
     */
    public static DataSet newDataSet(Collection columnNames, Collection rowList) {
        if (isNullOrEmpty(columnNames) && isNullOrEmpty(rowList)) {
            // throw new IllegalArgumentException("Column name list and row list can not be both null or empty");
            return newEmptyDataSet();
        } else if (isNullOrEmpty(rowList)) {
            return newEmptyDataSet(columnNames);
        }

        int startRowIndex = 0;

        if (isNullOrEmpty(columnNames)) {
            final Object firstNonNullRow = N.firstNonNull(rowList).orElse(null);

            if (firstNonNullRow == null) {
                return newEmptyDataSet();
            }

            final Class cls = firstNonNullRow.getClass();
            final Type type = typeOf(cls);

            if (type.isMap()) {
                columnNames = new ArrayList<>(((Map) firstNonNullRow).keySet());
            } else if (type.isBean()) {
                columnNames = new ArrayList<>(ClassUtil.getPropNameList(cls));
            } else if (type.isArray()) {
                final Object[] a = (Object[]) firstNonNullRow;
                columnNames = new ArrayList<>(a.length);

                for (Object e : a) {
                    columnNames.add(N.stringOf(e));
                }

                startRowIndex = 1;
            } else if (type.isCollection()) {
                final Collection c = (Collection) firstNonNullRow;
                columnNames = new ArrayList<>(c.size());

                for (Object e : c) {
                    columnNames.add(N.stringOf(e));
                }

                startRowIndex = 1;
            } else {
                throw new IllegalArgumentException("Unsupported header type: " + type.name() + " when specified 'columnNames' is null or empty");
            }

            if (isNullOrEmpty(columnNames)) {
                throw new IllegalArgumentException("Column name list can not be obtained from row list because it's empty or null");
            }
        }

        final int rowCount = rowList.size() - startRowIndex;
        final int columnCount = columnNames.size();
        final List columnNameList = new ArrayList<>(columnNames);
        final List> columnList = new ArrayList<>(columnCount);

        for (int i = 0; i < columnCount; i++) {
            columnList.add(new ArrayList<>(rowCount));
        }

        Type type = null;

        for (Object row : rowList) {
            if (startRowIndex-- > 0) {
                // skip
                continue;
            }

            if (row == null) {
                for (int i = 0; i < columnCount; i++) {
                    columnList.get(i).add(null);
                }

                continue;
            }

            final Class cls = row.getClass();
            type = typeOf(cls);

            if (type.isMap()) {
                Map props = (Map) row;

                for (int i = 0; i < columnCount; i++) {
                    columnList.get(i).add(props.get(columnNameList.get(i)));
                }
            } else if (type.isBean()) {
                final BeanInfo beanInfo = ParserUtil.getBeanInfo(cls);
                PropInfo propInfo = null;

                for (int i = 0; i < columnCount; i++) {
                    propInfo = beanInfo.getPropInfo(columnNameList.get(i));

                    if (propInfo == null) {
                        columnList.get(i).add(null);
                    } else {
                        columnList.get(i).add(propInfo.getPropValue(row));
                    }
                }
            } else if (type.isArray()) {
                if (type.isPrimitiveArray()) {
                    for (int i = 0; i < columnCount; i++) {
                        columnList.get(i).add(Array.get(row, i));
                    }
                } else {
                    Object[] array = (Object[]) row;

                    for (int i = 0; i < columnCount; i++) {
                        columnList.get(i).add(array[i]);
                    }
                }
            } else if (type.isCollection()) {
                final Iterator it = ((Collection) row).iterator();

                for (int i = 0; i < columnCount; i++) {
                    columnList.get(i).add(it.next());
                }
            } else {
                throw new IllegalArgumentException(
                        "Unsupported row type: " + ClassUtil.getCanonicalClassName(row.getClass()) + ". Only array, collection, map and bean are supported");
            }
        }

        return new RowDataSet(columnNameList, columnList);
    }

    /**
     *
     *
     * @param columnNames
     * @param rowList
     * @return
     */
    public static DataSet newDataSet(Collection columnNames, final Object[][] rowList) {
        if (isNullOrEmpty(columnNames) && isNullOrEmpty(rowList)) {
            // throw new IllegalArgumentException("Column name list and row list can not be both null or empty");
            return newEmptyDataSet();
        } else if (isNullOrEmpty(rowList)) {
            return newEmptyDataSet(columnNames);
        }

        N.checkArgument(N.size(columnNames) == N.len(rowList[0]), "length of 'columnNames' is not equals to length of 'rowList[0]'");

        return newDataSet(columnNames, N.asList(rowList));
    }

    /**
     * New data set.
     *
     * @param 
     * @param map keys are column names, values are columns
     * @return
     */
    public static > DataSet newDataSet(final Map map) {
        if (isNullOrEmpty(map)) {
            return newEmptyDataSet();
        }

        int maxColumnLen = 0;

        for (C v : map.values()) {
            maxColumnLen = N.max(maxColumnLen, size(v));
        }

        final List columnNameList = new ArrayList<>(map.keySet());
        final List> columnList = new ArrayList<>(columnNameList.size());
        List column = null;

        for (C v : map.values()) {
            column = new ArrayList<>(maxColumnLen);

            if (notNullOrEmpty(v)) {
                column.addAll(v);
            }

            if (column.size() < maxColumnLen) {
                fill(column, column.size(), maxColumnLen, null);
            }

            columnList.add(column);
        }

        return new RowDataSet(columnNameList, columnList);
    }

    /**
     *
     *
     * @param a
     * @param b
     * @return
     */
    public static DataSet merge(final DataSet a, final DataSet b) {
        N.checkArgNotNull(a);
        N.checkArgNotNull(b);

        return a.merge(b);
    }

    /**
     *
     *
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static DataSet merge(final DataSet a, final DataSet b, final DataSet c) {
        N.checkArgNotNull(a);
        N.checkArgNotNull(b);
        N.checkArgNotNull(c);

        return merge(N.asList(a, b, c));
    }

    /**
     *
     *
     * @param dss
     * @return
     */
    public static DataSet merge(final Collection dss) {
        if (N.isNullOrEmpty(dss)) {
            return N.newEmptyDataSet();
        } else if (dss.size() == 1) {
            return N.newEmptyDataSet().merge(dss.iterator().next());
        } else if (dss.size() == 2) {
            final Iterator iter = dss.iterator();
            return iter.next().merge(iter.next());
        } else {
            final Set columnNameSet = N.newLinkedHashSet();
            final Properties props = new Properties<>();
            int totalSize = 0;

            for (DataSet ds : dss) {
                columnNameSet.addAll(ds.columnNameList());
                totalSize += ds.size();

                if (N.notNullOrEmpty(ds.properties())) {
                    props.putAll(ds.properties());
                }
            }

            final int newColumnCount = columnNameSet.size();
            final List newColumnNameList = new ArrayList<>(columnNameSet);
            final List> newColumnList = new ArrayList<>(newColumnCount);

            for (int i = 0; i < newColumnCount; i++) {
                newColumnList.add(new ArrayList<>(totalSize));
            }

            for (DataSet ds : dss) {
                if (ds.size() == 0) {
                    continue;
                }

                List column = null;

                for (int i = 0; i < newColumnCount; i++) {
                    column = newColumnList.get(i);

                    if (ds.containsColumn(newColumnNameList.get(i))) {
                        column.addAll(ds.getColumn(newColumnNameList.get(i)));
                    } else {
                        N.fill(column, column.size(), column.size() + ds.size(), null);
                    }
                }
            }

            return new RowDataSet(newColumnNameList, newColumnList, props);
        }
    }

    /**
     * Returns an empty array if the specified collection is null or empty.
     *
     * @param c
     * @return
     */
    @SuppressWarnings("unchecked")
    public static Object[] toArray(final Collection c) {
        if (isNullOrEmpty(c)) {
            return EMPTY_OBJECT_ARRAY;
        }

        return c.toArray(new Object[c.size()]);
    }

    /**
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static Object[] toArray(final Collection c, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, size(c));

        if (isNullOrEmpty(c)) {
            return EMPTY_OBJECT_ARRAY;
        } else if (fromIndex == 0 || toIndex == c.size()) {
            return c.toArray(new Object[c.size()]);
        } else if (c instanceof List) {
            return ((List) c).subList(fromIndex, toIndex).toArray(new Object[toIndex - fromIndex]);
        } else {
            final Object[] res = new Object[toIndex - fromIndex];
            final Iterator iter = c.iterator();
            int idx = 0;

            while (idx < fromIndex && iter.hasNext()) {
                iter.next();
                idx++;
            }

            while (idx < toIndex && iter.hasNext()) {
                res[idx - fromIndex] = iter.next();
                idx++;
            }

            return res;
        }
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @param a
     * @return
     * @throws IllegalArgumentException if the specified {@code Array} is null.
     */
    public static  A[] toArray(final Collection c, final A[] a) throws IllegalArgumentException {
        checkArgNotNull(a);

        if (isNullOrEmpty(c)) {
            return a;
        }

        return c.toArray(a);
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param a
     * @return
     * @throws IllegalArgumentException if the specified {@code Array} is null.
     */
    public static  A[] toArray(final Collection c, final int fromIndex, final int toIndex, final A[] a)
            throws IllegalArgumentException {
        checkFromToIndex(fromIndex, toIndex, size(c));
        checkArgNotNull(a);

        if (isNullOrEmpty(c)) {
            return a;
        } else if (fromIndex == 0 || toIndex == c.size()) {
            return c.toArray(a);
        } else if (c instanceof List) {
            return ((List) c).subList(fromIndex, toIndex).toArray(a);
        } else {
            final A[] res = a.length >= toIndex - fromIndex ? a : (A[]) newArray(a.getClass().getComponentType(), toIndex - fromIndex);
            final Iterator iter = c.iterator();
            int idx = 0;

            while (idx < fromIndex && iter.hasNext()) {
                iter.next();
                idx++;
            }

            while (idx < toIndex && iter.hasNext()) {
                res[idx - fromIndex] = iter.next();
                idx++;
            }

            return res;
        }
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @param arraySupplier
     * @return
     */
    public static  A[] toArray(final Collection c, final IntFunction arraySupplier) {
        checkArgNotNull(arraySupplier);

        if (isNullOrEmpty(c)) {
            return arraySupplier.apply(0);
        }

        return toArray(c, arraySupplier);
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param arraySupplier
     * @return
     */
    public static  A[] toArray(final Collection c, final int fromIndex, final int toIndex, final IntFunction arraySupplier) {
        checkArgNotNull(arraySupplier);
        checkFromToIndex(fromIndex, toIndex, size(c));

        if (isNullOrEmpty(c)) {
            return arraySupplier.apply(0);
        } else if (fromIndex == 0 || toIndex == c.size()) {
            return c.toArray(arraySupplier.apply(c.size()));
        } else if (c instanceof List) {
            return ((List) c).subList(fromIndex, toIndex).toArray(arraySupplier.apply(toIndex - fromIndex));
        } else {
            final A[] res = arraySupplier.apply(toIndex - fromIndex);
            final Iterator iter = c.iterator();
            int idx = 0;

            while (idx < fromIndex && iter.hasNext()) {
                iter.next();
                idx++;
            }

            while (idx < toIndex && iter.hasNext()) {
                res[idx - fromIndex] = iter.next();
                idx++;
            }

            return res;
        }
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param c
     * @param targetClass
     * @return
     * @throws IllegalArgumentException if the specified {@code Class} is null.
     */
    public static  A[] toArray(final Collection c, final Class targetClass) throws IllegalArgumentException {
        checkArgNotNull(targetClass);

        if (isNullOrEmpty(c)) {
            return newArray(targetClass.getComponentType(), 0);
        }

        return c.toArray((A[]) newArray(targetClass.getComponentType(), c.size()));
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param targetClass
     * @return
     * @throws IllegalArgumentException if the specified {@code Class} is null.
     */
    public static  A[] toArray(final Collection c, final int fromIndex, final int toIndex, final Class targetClass)
            throws IllegalArgumentException {
        checkArgNotNull(targetClass);
        checkFromToIndex(fromIndex, toIndex, size(c));

        final A[] res = newArray(targetClass.getComponentType(), toIndex - fromIndex);

        if (isNullOrEmpty(c)) {
            return res;
        } else if (fromIndex == 0 || toIndex == c.size()) {
            return c.toArray(res);
        } else if (c instanceof List) {
            return ((List) c).subList(fromIndex, toIndex).toArray(res);
        } else {
            final Iterator iter = c.iterator();
            int idx = 0;

            while (idx < fromIndex && iter.hasNext()) {
                iter.next();
                idx++;
            }

            while (idx < toIndex && iter.hasNext()) {
                res[idx - fromIndex] = iter.next();
                idx++;
            }

            return res;
        }
    }

    /**
     * To boolean array.
     *
     * @param c
     * @return
     */
    public static boolean[] toBooleanArray(final Collection c) {
        return toBooleanArray(c, false);
    }

    /**
     * To boolean array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static boolean[] toBooleanArray(final Collection c, final int fromIndex, final int toIndex) {
        return toBooleanArray(c, fromIndex, toIndex, false);
    }

    /**
     * To boolean array.
     *
     * @param c
     * @param defaultForNull
     * @return
     */
    public static boolean[] toBooleanArray(final Collection c, final boolean defaultForNull) {
        return toBooleanArray(c, 0, size(c), defaultForNull);
    }

    /**
     * To boolean array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param defaultForNull
     * @return
     */
    public static boolean[] toBooleanArray(final Collection c, final int fromIndex, final int toIndex, final boolean defaultForNull) {
        checkFromToIndex(fromIndex, toIndex, size(c));

        if (fromIndex == toIndex) {
            return EMPTY_BOOLEAN_ARRAY;
        }

        final int len = toIndex - fromIndex;
        boolean[] result = new boolean[len];

        if (c instanceof List && c instanceof RandomAccess) {
            final List list = (List) c;
            Boolean val = null;

            for (int i = 0; i < len; i++) {
                if ((val = list.get(i + fromIndex)) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val;
                }
            }
        } else {
            final Iterator iter = c.iterator();

            if (fromIndex > 0) {
                int offset = 0;

                while (offset++ < fromIndex) {
                    iter.next();
                }
            }

            Boolean val = null;

            for (int i = 0; i < len; i++) {
                if ((val = iter.next()) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val;
                }
            }
        }

        return result;
    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static boolean[] toBooleanArray(final byte[] a) {
        if (a == null) {
            return null;
        } else if (a.length == 0) {
            return EMPTY_BOOLEAN_ARRAY;
        } else {
            final int len = a.length;
            final boolean[] result = new boolean[len];

            for (int i = 0; i < len; i++) {
                result[i] = a[i] > Numbers.BYTE_ZERO;
            }

            return result;
        }
    }

    /**
     * To char array.
     *
     * @param c
     * @return
     */
    public static char[] toCharArray(final Collection c) {
        return toCharArray(c, (char) 0);
    }

    /**
     * To char array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static char[] toCharArray(final Collection c, final int fromIndex, final int toIndex) {
        return toCharArray(c, fromIndex, toIndex, (char) 0);
    }

    /**
     * To char array.
     *
     * @param c
     * @param defaultForNull
     * @return
     */
    public static char[] toCharArray(final Collection c, final char defaultForNull) {
        return toCharArray(c, 0, size(c), defaultForNull);
    }

    /**
     * To char array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param defaultForNull
     * @return
     */
    public static char[] toCharArray(final Collection c, final int fromIndex, final int toIndex, final char defaultForNull) {
        checkFromToIndex(fromIndex, toIndex, size(c));

        if (fromIndex == toIndex) {
            return EMPTY_CHAR_ARRAY;
        }

        final int len = toIndex - fromIndex;
        char[] result = new char[len];

        if (c instanceof List && c instanceof RandomAccess) {
            final List list = (List) c;
            Character val = null;

            for (int i = 0; i < len; i++) {
                if ((val = list.get(i + fromIndex)) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val;
                }
            }
        } else {
            final Iterator iter = c.iterator();

            if (fromIndex > 0) {
                int offset = 0;

                while (offset++ < fromIndex) {
                    iter.next();
                }
            }

            Character val = null;

            for (int i = 0; i < len; i++) {
                if ((val = iter.next()) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val;
                }
            }
        }

        return result;
    }

    /**
     * To byte array.
     *
     * @param c
     * @return
     */
    public static byte[] toByteArray(final Collection c) {
        return toByteArray(c, (byte) 0);
    }

    /**
     * To byte array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static byte[] toByteArray(final Collection c, final int fromIndex, final int toIndex) {
        return toByteArray(c, fromIndex, toIndex, (byte) 0);
    }

    /**
     * To byte array.
     *
     * @param c
     * @param defaultForNull
     * @return
     */
    public static byte[] toByteArray(final Collection c, final byte defaultForNull) {
        return toByteArray(c, 0, size(c), defaultForNull);
    }

    /**
     * To byte array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param defaultForNull
     * @return
     */
    public static byte[] toByteArray(final Collection c, final int fromIndex, final int toIndex, final byte defaultForNull) {
        checkFromToIndex(fromIndex, toIndex, size(c));

        if (fromIndex == toIndex) {
            return EMPTY_BYTE_ARRAY;
        }

        final int len = toIndex - fromIndex;
        byte[] result = new byte[len];

        if (c instanceof List && c instanceof RandomAccess) {
            final List list = (List) c;
            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = list.get(i + fromIndex)) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val.byteValue();
                }
            }
        } else {
            final Iterator iter = c.iterator();

            if (fromIndex > 0) {
                int offset = 0;

                while (offset++ < fromIndex) {
                    iter.next();
                }
            }

            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = iter.next()) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val.byteValue();
                }
            }
        }

        return result;
    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static byte[] toByteArray(final boolean[] a) {
        if (a == null) {
            return null;
        } else if (a.length == 0) {
            return EMPTY_BYTE_ARRAY;
        } else {
            final int len = a.length;
            final byte[] result = new byte[len];

            for (int i = 0; i < len; i++) {
                result[i] = a[i] ? Numbers.BYTE_ONE : Numbers.BYTE_ZERO;
            }

            return result;
        }
    }

    /**
     * To short array.
     *
     * @param c
     * @return
     */
    public static short[] toShortArray(final Collection c) {
        return toShortArray(c, (short) 0);
    }

    /**
     * To short array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static short[] toShortArray(final Collection c, final int fromIndex, final int toIndex) {
        return toShortArray(c, fromIndex, toIndex, (short) 0);
    }

    /**
     * To short array.
     *
     * @param c
     * @param defaultForNull
     * @return
     */
    public static short[] toShortArray(final Collection c, final short defaultForNull) {
        return toShortArray(c, 0, size(c), defaultForNull);
    }

    /**
     * To short array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param defaultForNull
     * @return
     */
    public static short[] toShortArray(final Collection c, final int fromIndex, final int toIndex, final short defaultForNull) {
        checkFromToIndex(fromIndex, toIndex, size(c));

        if (fromIndex == toIndex) {
            return EMPTY_SHORT_ARRAY;
        }

        final int len = toIndex - fromIndex;
        short[] result = new short[len];

        if (c instanceof List && c instanceof RandomAccess) {
            final List list = (List) c;
            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = list.get(i + fromIndex)) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val.shortValue();
                }
            }
        } else {
            final Iterator iter = c.iterator();

            if (fromIndex > 0) {
                int offset = 0;

                while (offset++ < fromIndex) {
                    iter.next();
                }
            }

            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = iter.next()) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val.shortValue();
                }
            }
        }

        return result;
    }

    /**
     * To int array.
     *
     * @param c
     * @return
     */
    public static int[] toIntArray(final Collection c) {
        return toIntArray(c, 0);
    }

    /**
     * To int array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int[] toIntArray(final Collection c, final int fromIndex, final int toIndex) {
        return toIntArray(c, fromIndex, toIndex, 0);
    }

    /**
     * To int array.
     *
     * @param c
     * @param defaultForNull
     * @return
     */
    public static int[] toIntArray(final Collection c, final int defaultForNull) {
        return toIntArray(c, 0, size(c), defaultForNull);
    }

    /**
     * To int array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param defaultForNull
     * @return
     */
    public static int[] toIntArray(final Collection c, final int fromIndex, final int toIndex, final int defaultForNull) {
        checkFromToIndex(fromIndex, toIndex, size(c));

        if (fromIndex == toIndex) {
            return EMPTY_INT_ARRAY;
        }

        final int len = toIndex - fromIndex;
        int[] result = new int[len];

        if (c instanceof List && c instanceof RandomAccess) {
            final List list = (List) c;
            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = list.get(i + fromIndex)) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val.intValue();
                }
            }
        } else {
            final Iterator iter = c.iterator();

            if (fromIndex > 0) {
                int offset = 0;

                while (offset++ < fromIndex) {
                    iter.next();
                }
            }

            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = iter.next()) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val.intValue();
                }
            }
        }

        return result;
    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static int[] toIntArray(final char[] a) {
        if (a == null) {
            return null;
        } else if (a.length == 0) {
            return EMPTY_INT_ARRAY;
        } else {
            final int len = a.length;
            final int[] result = new int[len];

            for (int i = 0; i < len; i++) {
                result[i] = a[i]; //NOSONAR
            }

            return result;
        }
    }

    /**
     * To long array.
     *
     * @param c
     * @return
     */
    public static long[] toLongArray(final Collection c) {
        return toLongArray(c, 0);
    }

    /**
     * To long array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static long[] toLongArray(final Collection c, final int fromIndex, final int toIndex) {
        return toLongArray(c, fromIndex, toIndex, 0);
    }

    /**
     * To long array.
     *
     * @param c
     * @param defaultForNull
     * @return
     */
    public static long[] toLongArray(final Collection c, final long defaultForNull) {
        return toLongArray(c, 0, size(c), defaultForNull);
    }

    /**
     * To long array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param defaultForNull
     * @return
     */
    public static long[] toLongArray(final Collection c, final int fromIndex, final int toIndex, final long defaultForNull) {
        checkFromToIndex(fromIndex, toIndex, size(c));

        if (fromIndex == toIndex) {
            return EMPTY_LONG_ARRAY;
        }

        final int len = toIndex - fromIndex;
        long[] result = new long[len];

        if (c instanceof List && c instanceof RandomAccess) {
            final List list = (List) c;
            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = list.get(i + fromIndex)) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val.longValue();
                }
            }
        } else {
            final Iterator iter = c.iterator();

            if (fromIndex > 0) {
                int offset = 0;

                while (offset++ < fromIndex) {
                    iter.next();
                }
            }

            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = iter.next()) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = val.longValue();
                }
            }
        }

        return result;
    }

    /**
     * To float array.
     *
     * @param c
     * @return
     */
    public static float[] toFloatArray(final Collection c) {
        return toFloatArray(c, 0);
    }

    /**
     * To float array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static float[] toFloatArray(final Collection c, final int fromIndex, final int toIndex) {
        return toFloatArray(c, fromIndex, toIndex, 0);
    }

    /**
     * To float array.
     *
     * @param c
     * @param defaultForNull
     * @return
     */
    public static float[] toFloatArray(final Collection c, final float defaultForNull) {
        return toFloatArray(c, 0, size(c), defaultForNull);
    }

    /**
     * To float array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param defaultForNull
     * @return
     */
    public static float[] toFloatArray(final Collection c, final int fromIndex, final int toIndex, final float defaultForNull) {
        checkFromToIndex(fromIndex, toIndex, size(c));

        if (fromIndex == toIndex) {
            return EMPTY_FLOAT_ARRAY;
        }

        final int len = toIndex - fromIndex;
        float[] result = new float[len];

        if (c instanceof List && c instanceof RandomAccess) {
            final List list = (List) c;
            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = list.get(i + fromIndex)) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = Numbers.toFloat(val);
                }
            }
        } else {
            final Iterator iter = c.iterator();

            if (fromIndex > 0) {
                int offset = 0;

                while (offset++ < fromIndex) {
                    iter.next();
                }
            }

            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = iter.next()) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = Numbers.toFloat(val);
                }
            }
        }

        return result;
    }

    /**
     * To double array.
     *
     * @param c
     * @return
     */
    public static double[] toDoubleArray(final Collection c) {
        return toDoubleArray(c, 0);
    }

    /**
     * To double array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static double[] toDoubleArray(final Collection c, final int fromIndex, final int toIndex) {
        return toDoubleArray(c, fromIndex, toIndex, 0);
    }

    /**
     * To double array.
     *
     * @param c
     * @param defaultForNull
     * @return
     */
    public static double[] toDoubleArray(final Collection c, final double defaultForNull) {
        return toDoubleArray(c, 0, size(c), defaultForNull);
    }

    /**
     * To double array.
     *
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param defaultForNull
     * @return
     */
    public static double[] toDoubleArray(final Collection c, final int fromIndex, final int toIndex, final double defaultForNull) {
        checkFromToIndex(fromIndex, toIndex, size(c));

        if (fromIndex == toIndex) {
            return EMPTY_DOUBLE_ARRAY;
        }

        final int len = toIndex - fromIndex;
        double[] result = new double[len];

        if (c instanceof List && c instanceof RandomAccess) {
            final List list = (List) c;
            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = list.get(i + fromIndex)) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = Numbers.toDouble(val);
                }
            }
        } else {
            final Iterator iter = c.iterator();

            if (fromIndex > 0) {
                int offset = 0;

                while (offset++ < fromIndex) {
                    iter.next();
                }
            }

            Number val = null;

            for (int i = 0; i < len; i++) {
                if ((val = iter.next()) == null) {
                    result[i] = defaultForNull;
                } else {
                    result[i] = Numbers.toDouble(val);
                }
            }
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static List toList(final boolean[] a) {
        return toList(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static List toList(final boolean[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static List toList(final char[] a) {
        return toList(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static List toList(final char[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static List toList(final byte[] a) {
        return toList(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static List toList(final byte[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static List toList(final short[] a) {
        return toList(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static List toList(final short[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static List toList(final int[] a) {
        return toList(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static List toList(final int[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static List toList(final long[] a) {
        return toList(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static List toList(final long[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static List toList(final float[] a) {
        return toList(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static List toList(final float[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static List toList(final double[] a) {
        return toList(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static List toList(final double[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    public static  List toList(final T[] a) {
        if (isNullOrEmpty(a)) {
            return new ArrayList<>();
        }

        return asList(a);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static  List toList(final T[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return new ArrayList<>();
        } else if (fromIndex == 0 && toIndex == a.length) {
            return asList(a);
        }

        final List result = new ArrayList<>(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]); //NOSONAR
        }

        return result;
    }

    /**
     *
     *
     * @param 
     * @param iter
     * @return
     */
    public static  List toList(final Iterator iter) {
        if (iter == null) {
            return new ArrayList<>();
        }

        final List result = new ArrayList<>();

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

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static Set toSet(final boolean[] a) {
        return toSet(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static Set toSet(final boolean[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return newHashSet();
        }

        final Set result = newHashSet(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static Set toSet(final char[] a) {
        return toSet(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static Set toSet(final char[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return newHashSet();
        }

        final Set result = newHashSet(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static Set toSet(final byte[] a) {
        return toSet(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static Set toSet(final byte[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return newHashSet();
        }

        final Set result = newHashSet(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static Set toSet(final short[] a) {
        return toSet(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static Set toSet(final short[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return newHashSet();
        }

        final Set result = newHashSet(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static Set toSet(final int[] a) {
        return toSet(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static Set toSet(final int[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return newHashSet();
        }

        final Set result = newHashSet(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static Set toSet(final long[] a) {
        return toSet(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static Set toSet(final long[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return newHashSet();
        }

        final Set result = newHashSet(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static Set toSet(final float[] a) {
        return toSet(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static Set toSet(final float[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return newHashSet();
        }

        final Set result = newHashSet(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     */
    public static Set toSet(final double[] a) {
        return toSet(a, 0, len(a));
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static Set toSet(final double[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return newHashSet();
        }

        final Set result = newHashSet(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    public static  Set toSet(final T[] a) {
        if (isNullOrEmpty(a)) {
            return newHashSet();
        }

        return asSet(a);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static  Set toSet(final T[] a, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return newHashSet();
        }

        final Set result = newHashSet(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]); //NOSONAR
        }

        return result;
    }

    /**
     *
     *
     * @param 
     * @param iter
     * @return
     */
    public static  Set toSet(final Iterator iter) {
        if (iter == null) {
            return N.newHashSet();
        }

        final Set result = N.newHashSet();

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

        return result;
    }

    /**
     *
     * @param 
     * @param a
     * @param supplier
     * @return
     */
    public static > C toCollection(final boolean[] a, final IntFunction supplier) {
        return toCollection(a, 0, len(a), supplier);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param supplier
     * @return
     */
    public static > C toCollection(final boolean[] a, final int fromIndex, final int toIndex,
            final IntFunction supplier) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return supplier.apply(0);
        }

        final C result = supplier.apply(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param 
     * @param a
     * @param supplier
     * @return
     */
    public static > C toCollection(final char[] a, final IntFunction supplier) {
        return toCollection(a, 0, len(a), supplier);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param supplier
     * @return
     */
    public static > C toCollection(final char[] a, final int fromIndex, final int toIndex,
            final IntFunction supplier) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return supplier.apply(0);
        }

        final C result = supplier.apply(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param 
     * @param a
     * @param supplier
     * @return
     */
    public static > C toCollection(final byte[] a, final IntFunction supplier) {
        return toCollection(a, 0, len(a), supplier);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param supplier
     * @return
     */
    public static > C toCollection(final byte[] a, final int fromIndex, final int toIndex, final IntFunction supplier) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return supplier.apply(0);
        }

        final C result = supplier.apply(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param 
     * @param a
     * @param supplier
     * @return
     */
    public static > C toCollection(final short[] a, final IntFunction supplier) {
        return toCollection(a, 0, len(a), supplier);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param supplier
     * @return
     */
    public static > C toCollection(final short[] a, final int fromIndex, final int toIndex,
            final IntFunction supplier) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return supplier.apply(0);
        }

        final C result = supplier.apply(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param 
     * @param a
     * @param supplier
     * @return
     */
    public static > C toCollection(final int[] a, final IntFunction supplier) {
        return toCollection(a, 0, len(a), supplier);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param supplier
     * @return
     */
    public static > C toCollection(final int[] a, final int fromIndex, final int toIndex,
            final IntFunction supplier) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return supplier.apply(0);
        }

        final C result = supplier.apply(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param 
     * @param a
     * @param supplier
     * @return
     */
    public static > C toCollection(final long[] a, final IntFunction supplier) {
        return toCollection(a, 0, len(a), supplier);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param supplier
     * @return
     */
    public static > C toCollection(final long[] a, final int fromIndex, final int toIndex, final IntFunction supplier) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return supplier.apply(0);
        }

        final C result = supplier.apply(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param 
     * @param a
     * @param supplier
     * @return
     */
    public static > C toCollection(final float[] a, final IntFunction supplier) {
        return toCollection(a, 0, len(a), supplier);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param supplier
     * @return
     */
    public static > C toCollection(final float[] a, final int fromIndex, final int toIndex,
            final IntFunction supplier) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return supplier.apply(0);
        }

        final C result = supplier.apply(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param 
     * @param a
     * @param supplier
     * @return
     */
    public static > C toCollection(final double[] a, final IntFunction supplier) {
        return toCollection(a, 0, len(a), supplier);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param supplier
     * @return
     */
    public static > C toCollection(final double[] a, final int fromIndex, final int toIndex,
            final IntFunction supplier) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return supplier.apply(0);
        }

        final C result = supplier.apply(toIndex - fromIndex);

        for (int i = fromIndex; i < toIndex; i++) {
            result.add(a[i]);
        }

        return result;
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @param supplier
     * @return
     */
    public static > C toCollection(final T[] a, final IntFunction supplier) {
        if (isNullOrEmpty(a)) {
            return supplier.apply(0);
        }

        return toCollection(a, 0, a.length, supplier);
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param supplier
     * @return
     */
    public static > C toCollection(final T[] a, final int fromIndex, final int toIndex, final IntFunction supplier) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (fromIndex == toIndex) {
            return supplier.apply(0);
        } else if (fromIndex == 0 && toIndex == a.length && a.length >= MIN_SIZE_FOR_COPY_ALL) {
            final C result = supplier.apply(a.length);
            result.addAll(Arrays.asList(a));
            return result;
        } else {
            final C result = supplier.apply(toIndex - fromIndex);

            for (int i = fromIndex; i < toIndex; i++) {
                result.add(a[i]); //NOSONAR
            }

            return result;
        }
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param iter
     * @param supplier
     * @return
     */
    public static > C toCollection(final Iterator iter, final Supplier supplier) {
        final C c = supplier.get();

        if (iter == null) {
            return c;
        }

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

        return c;
    }

    /**
     * The input array is returned.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  T[] asArray(final T... a) {
        return a;
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param 
     * @param m
     * @param a
     * @return
     */
    @SuppressWarnings("unchecked")
    static > T newMap(final T m, final Object... a) {
        if (isNullOrEmpty(a)) {
            return m;
        }

        if (a.length == 1) {
            if (a[0] instanceof Map) {
                m.putAll((Map) a[0]);
            } else if (ClassUtil.isBeanClass(a[0].getClass())) {
                Maps.bean2Map((Map) m, a[0]);
            } else {
                throw new IllegalArgumentException(
                        "The parameters must be the pairs of property name and value, or Map, or a bean class with getter/setter methods.");
            }
        } else {
            if (0 != (a.length % 2)) {
                throw new IllegalArgumentException(
                        "The parameters must be the pairs of property name and value, or Map, or a bean class with getter/setter methods.");
            }

            for (int i = 0; i < a.length; i++) {
                m.put((K) a[i], (V) a[++i]);
            }
        }

        return m;
    }

    /**
     *
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @return
     */
    public static  Map asMap(final K k1, final V v1) {
        final Map map = N.newHashMap(1);
        map.put(k1, v1);
        return map;
    }

    /**
     *
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @return
     */
    public static  Map asMap(final K k1, final V v1, final K k2, final V v2) {
        final Map map = N.newHashMap(2);
        map.put(k1, v1);
        map.put(k2, v2);
        return map;
    }

    /**
     *
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param k3
     * @param v3
     * @return
     */
    public static  Map asMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3) {
        final Map map = N.newHashMap(3);
        map.put(k1, v1);
        map.put(k2, v2);
        map.put(k3, v3);
        return map;
    }

    /**
     *
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param k3
     * @param v3
     * @param k4
     * @param v4
     * @return
     */
    public static  Map asMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4) {
        final Map map = N.newHashMap(4);
        map.put(k1, v1);
        map.put(k2, v2);
        map.put(k3, v3);
        map.put(k4, v4);
        return map;
    }

    /**
     *
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param k3
     * @param v3
     * @param k4
     * @param v4
     * @param k5
     * @param v5
     * @return
     */
    public static  Map asMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5,
            final V v5) {
        final Map map = N.newHashMap(5);
        map.put(k1, v1);
        map.put(k2, v2);
        map.put(k3, v3);
        map.put(k4, v4);
        map.put(k5, v5);
        return map;
    }

    /**
     *
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param k3
     * @param v3
     * @param k4
     * @param v4
     * @param k5
     * @param v5
     * @param k6
     * @param v6
     * @return
     */
    public static  Map asMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5, final V v5,
            final K k6, final V v6) {
        final Map map = N.newHashMap(6);
        map.put(k1, v1);
        map.put(k2, v2);
        map.put(k3, v3);
        map.put(k4, v4);
        map.put(k5, v5);
        map.put(k6, v6);
        return map;
    }

    /**
     *
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param k3
     * @param v3
     * @param k4
     * @param v4
     * @param k5
     * @param v5
     * @param k6
     * @param v6
     * @param k7
     * @param v7
     * @return
     */
    public static  Map asMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5, final V v5,
            final K k6, final V v6, final K k7, final V v7) {
        final Map map = N.newHashMap(7);
        map.put(k1, v1);
        map.put(k2, v2);
        map.put(k3, v3);
        map.put(k4, v4);
        map.put(k5, v5);
        map.put(k6, v6);
        map.put(k7, v7);
        return map;
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param a
     * @return
     * @deprecated
     */
    @Deprecated
    @SafeVarargs
    @NullSafe
    public static  Map asMap(final Object... a) {
        if (isNullOrEmpty(a)) {
            return new HashMap<>();
        }

        return newMap(N. newHashMap(a.length / 2), a);
    }

    /**
     * As linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @return
     */
    public static  Map asLinkedHashMap(final K k1, final V v1) {
        final Map map = N.newLinkedHashMap(1);
        map.put(k1, v1);
        return map;
    }

    /**
     * As linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @return
     */
    public static  Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2) {
        final Map map = N.newLinkedHashMap(2);
        map.put(k1, v1);
        map.put(k2, v2);
        return map;
    }

    /**
     * As linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param k3
     * @param v3
     * @return
     */
    public static  Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3) {
        final Map map = N.newLinkedHashMap(3);
        map.put(k1, v1);
        map.put(k2, v2);
        map.put(k3, v3);
        return map;
    }

    /**
     * As linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param k3
     * @param v3
     * @param k4
     * @param v4
     * @return
     */
    public static  Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4) {
        final Map map = N.newLinkedHashMap(4);
        map.put(k1, v1);
        map.put(k2, v2);
        map.put(k3, v3);
        map.put(k4, v4);
        return map;
    }

    /**
     * As linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param k3
     * @param v3
     * @param k4
     * @param v4
     * @param k5
     * @param v5
     * @return
     */
    public static  Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5,
            final V v5) {
        final Map map = N.newLinkedHashMap(5);
        map.put(k1, v1);
        map.put(k2, v2);
        map.put(k3, v3);
        map.put(k4, v4);
        map.put(k5, v5);
        return map;
    }

    /**
     * As linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param k3
     * @param v3
     * @param k4
     * @param v4
     * @param k5
     * @param v5
     * @param k6
     * @param v6
     * @return
     */
    public static  Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5,
            final V v5, final K k6, final V v6) {
        final Map map = N.newLinkedHashMap(6);
        map.put(k1, v1);
        map.put(k2, v2);
        map.put(k3, v3);
        map.put(k4, v4);
        map.put(k5, v5);
        map.put(k6, v6);
        return map;
    }

    /**
     * As linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param k3
     * @param v3
     * @param k4
     * @param v4
     * @param k5
     * @param v5
     * @param k6
     * @param v6
     * @param k7
     * @param v7
     * @return
     */
    public static  Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5,
            final V v5, final K k6, final V v6, final K k7, final V v7) {
        final Map map = N.newLinkedHashMap(7);
        map.put(k1, v1);
        map.put(k2, v2);
        map.put(k3, v3);
        map.put(k4, v4);
        map.put(k5, v5);
        map.put(k6, v6);
        map.put(k7, v7);
        return map;
    }

    /**
     * As linked hash map.
     *
     * @param  the key type
     * @param  the value type
     * @param a
     * @return
     * @deprecated
     */
    @Deprecated
    @SafeVarargs
    public static  Map asLinkedHashMap(final Object... a) {
        if (isNullOrEmpty(a)) {
            return N.newLinkedHashMap();
        }

        return newMap(N. newLinkedHashMap(a.length / 2), a);
    }

    /**
     *
     *
     * @param propName
     * @param propValue
     * @return
     */
    public static Map asProps(final String propName, final Object propValue) {
        final Map props = N.newLinkedHashMap(1);
        props.put(propName, propValue);

        return props;
    }

    /**
     *
     *
     * @param propName1
     * @param propValue1
     * @param propName2
     * @param propValue2
     * @return
     */
    public static Map asProps(final String propName1, final Object propValue1, final String propName2, final Object propValue2) {
        final Map props = N.newLinkedHashMap(2);
        props.put(propName1, propValue1);
        props.put(propName2, propValue2);

        return props;
    }

    /**
     *
     *
     * @param propName1
     * @param propValue1
     * @param propName2
     * @param propValue2
     * @param propName3
     * @param propValue3
     * @return
     */
    public static Map asProps(final String propName1, final Object propValue1, final String propName2, final Object propValue2,
            final String propName3, final Object propValue3) {
        final Map props = N.newLinkedHashMap(3);
        props.put(propName1, propValue1);
        props.put(propName2, propValue2);
        props.put(propName3, propValue3);

        return props;
    }

    /**
     *
     *
     * @param propName1
     * @param propValue1
     * @param propName2
     * @param propValue2
     * @param propName3
     * @param propValue3
     * @param propName4
     * @param propValue4
     * @return
     */
    public static Map asProps(final String propName1, final Object propValue1, final String propName2, final Object propValue2,
            final String propName3, final Object propValue3, final String propName4, final Object propValue4) {
        final Map props = N.newLinkedHashMap(4);
        props.put(propName1, propValue1);
        props.put(propName2, propValue2);
        props.put(propName3, propValue3);
        props.put(propName4, propValue4);

        return props;
    }

    /**
     *
     *
     * @param propName1
     * @param propValue1
     * @param propName2
     * @param propValue2
     * @param propName3
     * @param propValue3
     * @param propName4
     * @param propValue4
     * @param propName5
     * @param propValue5
     * @return
     */
    public static Map asProps(final String propName1, final Object propValue1, final String propName2, final Object propValue2,
            final String propName3, final Object propValue3, final String propName4, final Object propValue4, final String propName5, final Object propValue5) {
        final Map props = N.newLinkedHashMap(5);
        props.put(propName1, propValue1);
        props.put(propName2, propValue2);
        props.put(propName3, propValue3);
        props.put(propName4, propValue4);
        props.put(propName5, propValue5);

        return props;
    }

    /**
     *
     * @param a pairs of property name and value or a Java Bean Object what
     *            allows access to properties using getter and setter methods.
     * @return
     * @deprecated
     */
    @Deprecated
    @SafeVarargs
    public static Map asProps(final Object... a) {
        if (isNullOrEmpty(a)) {
            return N.newLinkedHashMap();
        }

        return newMap(N. newLinkedHashMap(a.length / 2), a);
    }

    /**
     *
     * @param 
     * @param e
     * @return
     */
    public static  List asList(final T e) {
        final List list = new ArrayList<>(1);
        list.add(e);
        return list;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @return
     */
    public static  List asList(final T e1, final T e2) {
        final List list = new ArrayList<>(2);
        list.add(e1);
        list.add(e2);
        return list;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @return
     */
    public static  List asList(final T e1, final T e2, final T e3) {
        final List list = new ArrayList<>(3);
        list.add(e1);
        list.add(e2);
        list.add(e3);
        return list;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @return
     */
    public static  List asList(final T e1, final T e2, final T e3, final T e4) {
        final List list = new ArrayList<>(4);
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        return list;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @return
     */
    public static  List asList(final T e1, final T e2, final T e3, final T e4, final T e5) {
        final List list = new ArrayList<>(5);
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        return list;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @return
     */
    public static  List asList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6) {
        final List list = new ArrayList<>(6);
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        list.add(e6);
        return list;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @param e7
     * @return
     */
    public static  List asList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7) {
        final List list = new ArrayList<>(7);
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        list.add(e6);
        list.add(e7);
        return list;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @param e7
     * @param e8
     * @return
     */
    public static  List asList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7, final T e8) {
        final List list = new ArrayList<>(8);
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        list.add(e6);
        list.add(e7);
        list.add(e8);
        return list;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @param e7
     * @param e8
     * @param e9
     * @return
     */
    public static  List asList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7, final T e8, final T e9) {
        final List list = new ArrayList<>(9);
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        list.add(e6);
        list.add(e7);
        list.add(e8);
        list.add(e9);
        return list;
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    @NullSafe
    public static  List asList(final T... a) {
        if (isNullOrEmpty(a)) {
            return new ArrayList<>();
        }

        final List list = new ArrayList<>(a.length);

        if (a.length < MIN_SIZE_FOR_COPY_ALL) {
            Collections.addAll(list, a);
        } else {
            list.addAll(Arrays.asList(a));
        }

        return list;
    }

    /**
     * As linked list.
     *
     * @param 
     * @param e
     * @return
     */
    public static  LinkedList asLinkedList(final T e) { //NOSONAR
        final LinkedList list = new LinkedList<>();
        list.add(e);
        return list;
    }

    /**
     * As linked list.
     *
     * @param 
     * @param e1
     * @param e2
     * @return
     */
    public static  LinkedList asLinkedList(final T e1, final T e2) { //NOSONAR
        final LinkedList list = new LinkedList<>();
        list.add(e1);
        list.add(e2);
        return list;
    }

    /**
     * As linked list.
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @return
     */
    public static  LinkedList asLinkedList(final T e1, final T e2, final T e3) { //NOSONAR
        final LinkedList list = new LinkedList<>();
        list.add(e1);
        list.add(e2);
        list.add(e3);
        return list;
    }

    /**
     * As linked list.
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @return
     */
    public static  LinkedList asLinkedList(final T e1, final T e2, final T e3, final T e4) { //NOSONAR
        final LinkedList list = new LinkedList<>();
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        return list;
    }

    /**
     * As linked list.
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @return
     */
    public static  LinkedList asLinkedList(final T e1, final T e2, final T e3, final T e4, final T e5) { //NOSONAR
        final LinkedList list = new LinkedList<>();
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        return list;
    }

    /**
     * As linked list.
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @return
     */
    public static  LinkedList asLinkedList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6) { //NOSONAR
        final LinkedList list = new LinkedList<>();
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        list.add(e6);
        return list;
    }

    /**
     * As linked list.
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @param e7
     * @return
     */
    public static  LinkedList asLinkedList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7) { //NOSONAR
        final LinkedList list = new LinkedList<>();
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        list.add(e6);
        list.add(e7);
        return list;
    }

    /**
     * As linked list.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    @NullSafe
    public static  LinkedList asLinkedList(final T... a) { //NOSONAR
        if (isNullOrEmpty(a)) {
            return new LinkedList<>();
        }

        final LinkedList list = new LinkedList<>();

        Collections.addAll(list, a);

        return list;
    }

    /**
     *
     * @param 
     * @param e
     * @return
     */
    public static  Set asSet(final T e) {
        final Set set = newHashSet(1);
        set.add(e);
        return set;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @return
     */
    public static  Set asSet(final T e1, final T e2) {
        final Set set = newHashSet(2);
        set.add(e1);
        set.add(e2);
        return set;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @return
     */
    public static  Set asSet(final T e1, final T e2, final T e3) {
        final Set set = newHashSet(3);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        return set;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @return
     */
    public static  Set asSet(final T e1, final T e2, final T e3, final T e4) {
        final Set set = newHashSet(4);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        return set;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @return
     */
    public static  Set asSet(final T e1, final T e2, final T e3, final T e4, final T e5) {
        final Set set = newHashSet(5);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        return set;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @return
     */
    public static  Set asSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6) {
        final Set set = newHashSet(6);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        set.add(e6);
        return set;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @param e7
     * @return
     */
    public static  Set asSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7) {
        final Set set = newHashSet(7);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        set.add(e6);
        set.add(e7);
        return set;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @param e7
     * @param e8
     * @return
     */
    public static  Set asSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7, final T e8) {
        final Set set = newHashSet(8);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        set.add(e6);
        set.add(e7);
        set.add(e8);
        return set;
    }

    /**
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @param e7
     * @param e8
     * @param e9
     * @return
     */
    public static  Set asSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7, final T e8, final T e9) {
        final Set set = newHashSet(9);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        set.add(e6);
        set.add(e7);
        set.add(e8);
        set.add(e9);
        return set;
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    @NullSafe
    public static  Set asSet(final T... a) {
        if (isNullOrEmpty(a)) {
            return newHashSet();
        }

        final Set set = newHashSet(a.length);

        Collections.addAll(set, a);

        return set;
    }

    /**
     * As linked linked hash set.
     *
     * @param 
     * @param e
     * @return
     */
    public static  Set asLinkedHashSet(final T e) {
        final Set set = newLinkedHashSet(1);
        set.add(e);
        return set;
    }

    /**
     * As linked linked hash set.
     *
     * @param 
     * @param e1
     * @param e2
     * @return
     */
    public static  Set asLinkedHashSet(final T e1, final T e2) {
        final Set set = newLinkedHashSet(2);
        set.add(e1);
        set.add(e2);
        return set;
    }

    /**
     * As linked linked hash set.
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @return
     */
    public static  Set asLinkedHashSet(final T e1, final T e2, final T e3) {
        final Set set = newLinkedHashSet(3);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        return set;
    }

    /**
     * As linked linked hash set.
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @return
     */
    public static  Set asLinkedHashSet(final T e1, final T e2, final T e3, final T e4) {
        final Set set = newLinkedHashSet(4);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        return set;
    }

    /**
     * As linked linked hash set.
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @return
     */
    public static  Set asLinkedHashSet(final T e1, final T e2, final T e3, final T e4, final T e5) {
        final Set set = newLinkedHashSet(5);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        return set;
    }

    /**
     * As linked linked hash set.
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @return
     */
    public static  Set asLinkedHashSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6) {
        final Set set = newLinkedHashSet(6);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        set.add(e6);
        return set;
    }

    /**
     * As linked linked hash set.
     *
     * @param 
     * @param e1
     * @param e2
     * @param e3
     * @param e4
     * @param e5
     * @param e6
     * @param e7
     * @return
     */
    public static  Set asLinkedHashSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7) {
        final Set set = newLinkedHashSet(7);
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        set.add(e6);
        set.add(e7);
        return set;
    }

    /**
     * As linked hash set.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    @NullSafe
    public static  Set asLinkedHashSet(final T... a) {
        if (isNullOrEmpty(a)) {
            return newLinkedHashSet();
        }

        final Set set = newLinkedHashSet(a.length);

        Collections.addAll(set, a);

        return set;
    }

    /**
     * As sorted set.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    @NullSafe
    public static  SortedSet asSortedSet(final T... a) {
        if (isNullOrEmpty(a)) {
            return new TreeSet<>();
        }

        final SortedSet set = new TreeSet<>();

        Collections.addAll(set, a);

        return set;
    }

    /**
     * As navigable set.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  NavigableSet asNavigableSet(final T... a) {
        if (isNullOrEmpty(a)) {
            return new TreeSet<>();
        }

        final NavigableSet set = new TreeSet<>();

        Collections.addAll(set, a);

        return set;
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  Queue asQueue(final T... a) {
        return asArrayDeque(a);
    }

    /**
     * As array blocking queue.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  ArrayBlockingQueue asArrayBlockingQueue(final T... a) {
        if (isNullOrEmpty(a)) {
            return new ArrayBlockingQueue<>(0);
        }

        final ArrayBlockingQueue queue = new ArrayBlockingQueue<>(a.length);

        Collections.addAll(queue, a);

        return queue;
    }

    /**
     * As linked blocking queue.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  LinkedBlockingQueue asLinkedBlockingQueue(final T... a) {
        if (isNullOrEmpty(a)) {
            return new LinkedBlockingQueue<>();
        }

        final LinkedBlockingQueue queue = new LinkedBlockingQueue<>(a.length);

        Collections.addAll(queue, a);

        return queue;
    }

    /**
     * As concurrent linked queue.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  ConcurrentLinkedQueue asConcurrentLinkedQueue(final T... a) { //NOSONAR
        if (isNullOrEmpty(a)) {
            return new ConcurrentLinkedQueue<>();
        }

        final ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue<>();

        Collections.addAll(queue, a);

        return queue;
    }

    /**
     * As delay queue.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  DelayQueue asDelayQueue(final T... a) {
        if (isNullOrEmpty(a)) {
            return new DelayQueue<>();
        }

        final DelayQueue queue = new DelayQueue<>();

        Collections.addAll(queue, a);

        return queue;
    }

    /**
     * As priority queue.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  PriorityQueue asPriorityQueue(final T... a) {
        if (isNullOrEmpty(a)) {
            return new PriorityQueue<>();
        }

        final PriorityQueue queue = new PriorityQueue<>(a.length);

        Collections.addAll(queue, a);

        return queue;
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  Deque asDeque(final T... a) {
        return asArrayDeque(a);
    }

    /**
     * As array deque.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  ArrayDeque asArrayDeque(final T... a) { //NOSONAR
        if (isNullOrEmpty(a)) {
            return new ArrayDeque<>();
        }

        final ArrayDeque arrayDeque = new ArrayDeque<>(a.length);

        Collections.addAll(arrayDeque, a);

        return arrayDeque;
    }

    /**
     * As linked blocking deque.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  LinkedBlockingDeque asLinkedBlockingDeque(final T... a) {
        if (isNullOrEmpty(a)) {
            return new LinkedBlockingDeque<>();
        }

        final LinkedBlockingDeque deque = new LinkedBlockingDeque<>(a.length);

        Collections.addAll(deque, a);

        return deque;
    }

    /**
     * As concurrent linked deque.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  ConcurrentLinkedDeque asConcurrentLinkedDeque(final T... a) { //NOSONAR
        if (isNullOrEmpty(a)) {
            return new ConcurrentLinkedDeque<>();
        }

        final ConcurrentLinkedDeque deque = new ConcurrentLinkedDeque<>();

        Collections.addAll(deque, a);

        return deque;
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  Multiset asMultiset(final T... a) {
        return Multiset.of(a);
    }

    /**
     * Wrap the specified value with a singleton list.
     *
     * @param 
     * @param o
     * @return an immutable list
     * @see java.util.Collections#singletonList(Object)
     */
    @Immutable
    public static  List asSingletonList(final T o) {
        return Collections.singletonList(o);
    }

    /**
     * Wrap the specified value with a singleton set.
     *
     * @param 
     * @param o
     * @return an immutable set
     * @see java.util.Collections#singleton(Object)
     */
    @Immutable
    public static  Set asSingletonSet(final T o) {
        return Collections.singleton(o);
    }

    /**
     * Wrap the specified key/value with a singleton map.
     *
     * @param  the key type
     * @param  the value type
     * @param key
     * @param value
     * @return an immutable Map
     * @see java.util.Collections#singletonMap(Object, Object)
     */
    @Immutable
    public static  Map asSingletonMap(final K key, final V value) {
        return Collections.singletonMap(key, value);
    }

    private static final Map, BiFunction, Object>> converterMap = new ConcurrentHashMap<>();

    /**
     *
     * @param srcClass
     * @param converter
     * @return {@code true} if there is no {@code converter} registered with specified {@code srcClass} yet before this call.
     */
    @SuppressWarnings("rawtypes")
    public static boolean registerConverter(final Class srcClass, final BiFunction, ?> converter) {
        N.checkArgNotNull(srcClass, "srcClass");
        N.checkArgNotNull(converter, "converter");

        if (isBuiltinClass(srcClass)) {
            throw new IllegalArgumentException("Can't register converter with builtin class: " + ClassUtil.getCanonicalClassName(srcClass));
        }

        synchronized (converterMap) {
            if (converterMap.containsKey(srcClass)) {
                return false;
            }

            converterMap.put(srcClass, (BiFunction) converter);

            return true;
        }
    }

    static boolean isBuiltinClass(final Class cls) {
        final Package pkg = cls.getPackage();

        if (pkg == null) {
            if (N.isPrimitiveType(cls) || N.isPrimitiveArrayType(cls)) {
                return true;
            } else if (cls.isArray()) {
                Class componentType = cls.getComponentType();

                while (componentType.isArray()) {
                    componentType = componentType.getComponentType();
                }

                return N.isPrimitiveType(cls) || N.isPrimitiveArrayType(cls);
            }

            return false;
        }

        final String pkgName = pkg.getName();

        return notNullOrEmpty(pkgName) && (pkgName.startsWith("java.") || pkgName.startsWith("com.landawn.abaus."));
    }

    /**
     * Try to convert the specified {@code obj} to the specified
     * {@code targetClass}. Default value of {@code targetClass} is returned if
     * {@code sourceObject} is null. An instance of {@code targetClass} is returned if
     * convert successfully
     *
     * @param 
     * @param obj
     * @param targetClass
     * @return
     */
    public static  T convert(final Object obj, final Class targetClass) {
        if (obj == null) {
            return defaultValueOf(targetClass);
        }

        final Class srcClass = obj.getClass();
        BiFunction, Object> converterFunc = null;

        if ((converterFunc = converterMap.get(srcClass)) != null) {
            return (T) converterFunc.apply(obj, targetClass);
        }

        final Type type = typeOf(targetClass);
        return convert(obj, srcClass, type);
    }

    /**
     *
     * @param 
     * @param obj
     * @param targetType
     * @return
     */
    public static  T convert(final Object obj, final Type targetType) {
        if (obj == null) {
            return targetType.defaultValue();
        }

        final Class srcClass = obj.getClass();
        BiFunction, Object> converterFunc = null;

        if ((converterFunc = converterMap.get(srcClass)) != null) {
            return (T) converterFunc.apply(obj, targetType.clazz());
        }

        return convert(obj, srcClass, targetType);
    }

    @SuppressWarnings({ "rawtypes" })
    private static  T convert(final Object obj, Class srcClass, final Type targetType) {
        if (targetType.clazz().isAssignableFrom(srcClass)) {
            return (T) obj;
        }

        final Type srcType = typeOf(srcClass);

        if (targetType.isBoolean() && srcType.isNumber()) {
            return (T) ((Boolean) (((Number) obj).longValue() > 0));
        }

        if (targetType.isBean()) {
            if (srcType.isBean()) {
                return copy(obj, targetType.clazz());
            } else if (srcType.isMap()) {
                return Maps.map2Bean((Map) obj, targetType.clazz());
            }
        } else if (targetType.isMap()) {
            if (srcType.isBean() && targetType.getParameterTypes()[0].clazz().isAssignableFrom(String.class)
                    && Object.class.equals(targetType.getParameterTypes()[1].clazz())) {
                try {
                    return (T) Maps.bean2Map(N. newMap((Class) targetType.clazz()), obj);
                } catch (Exception e) {
                    // ignore.
                }
            } else if (srcType.isMap() && Object.class.equals(targetType.getParameterTypes()[0].clazz())
                    && Object.class.equals(targetType.getParameterTypes()[1].clazz())) {
                final Map result = N.newMap((Class) targetType.clazz());
                result.putAll((Map) obj);
                return (T) result;
            }
        }

        if (targetType.isCollection() && (srcType.isCollection() && Object.class.equals(targetType.getParameterTypes()[0].clazz()))) {
            final Collection result = N.newCollection((Class) targetType.clazz());
            result.addAll((Collection) obj);
            return (T) result;
        }

        if (targetType.isNumber() && srcType.isNumber()) {
            return (T) Numbers.convert((Number) obj, (Type) targetType);
        } else if ((targetType.clazz().equals(int.class) || targetType.clazz().equals(Integer.class)) && srcType.clazz().equals(Character.class)) {
            return (T) (Integer.valueOf(((Character) obj).charValue())); //NOSONAR
        } else if ((targetType.clazz().equals(char.class) || targetType.clazz().equals(Character.class)) && srcType.clazz().equals(Integer.class)) {
            return (T) (Character.valueOf((char) ((Integer) obj).intValue()));
        } else if (targetType.clazz().equals(byte[].class) && srcType.clazz().equals(Blob.class)) {
            final Blob blob = (Blob) obj;

            try {
                return (T) blob.getBytes(1, (int) blob.length());
            } catch (SQLException e) {
                throw new UncheckedSQLException(e);
            } finally {
                try {
                    blob.free();
                } catch (SQLException e) {
                    throw new UncheckedSQLException(e); //NOSONAR
                }
            }
        } else if (targetType.clazz().equals(char[].class) && srcType.clazz().equals(Clob.class)) {
            final Clob clob = (Clob) obj;

            try {
                return (T) clob.getSubString(1, (int) clob.length()).toCharArray();
            } catch (SQLException e) {
                throw new UncheckedSQLException(e);
            } finally {
                try {
                    clob.free();
                } catch (SQLException e) {
                    throw new UncheckedSQLException(e); //NOSONAR
                }
            }
        } else if (targetType.clazz().equals(String.class) && srcType.clazz().equals(Clob.class)) {
            final Clob clob = (Clob) obj;

            try {
                return (T) clob.getSubString(1, (int) clob.length());
            } catch (SQLException e) {
                throw new UncheckedSQLException(e);
            } finally {
                try {
                    clob.free();
                } catch (SQLException e) {
                    throw new UncheckedSQLException(e); //NOSONAR
                }
            }
        }

        return targetType.valueOf(obj);
    }

    /**
     * Returns a Boolean with a value represented by the specified
     * string. The Boolean returned represents a true value if the
     * string argument is not null and is equal, ignoring case, to
     * the string {@code "true"}.
     *
     * @param str
     *            a string.
     * @return
     */
    public static boolean parseBoolean(final String str) {
        return isNullOrEmpty(str) ? false : Boolean.parseBoolean(str);
    }

    /**
     * Parses the char.
     *
     * @param str
     * @return
     */
    public static char parseChar(final String str) {
        return isNullOrEmpty(str) ? CHAR_ZERO : ((str.length() == 1) ? str.charAt(0) : (char) Integer.parseInt(str));
    }

    /**
     * Returns the value by calling {@code Byte.valueOf(String)} if {@code str}
     * is not {@code null}, otherwise, the default value 0 for {@code byte} is
     * returned.
     *
     * @param str
     * @return
     * @throws NumberFormatException If the string is not a parsable {@code byte}.
     * @see Numbers#toByte(String)
     * @deprecated replaced by {@code Numbers.toByte(String)}
     */
    @Deprecated
    public static byte parseByte(final String str) throws NumberFormatException {
        return Numbers.toByte(str);
    }

    /**
     * Returns the value by calling {@code Short.valueOf(String)} if {@code str}
     * is not {@code null}, otherwise, the default value 0 for {@code short} is
     * returned.
     *
     * @param str
     * @return
     * @throws NumberFormatException If the string is not a parsable {@code short}.
     * @see Numbers#toShort(String)
     * @deprecated replaced by {@code Numbers.toShort(String)}
     */
    @Deprecated
    public static short parseShort(final String str) throws NumberFormatException {
        return Numbers.toShort(str);
    }

    /**
     * Returns the value by calling {@code Integer.valueOf(String)} if
     * {@code str} is not {@code null}, otherwise, the default value 0 for
     * {@code int} is returned.
     *
     * @param str
     * @return
     * @throws NumberFormatException If the string is not a parsable {@code int}.
     * @see Numbers#toInt(String)
     * @deprecated replaced by {@code Numbers.toInt(String)}
     */
    @Deprecated
    public static int parseInt(final String str) throws NumberFormatException {
        return Numbers.toInt(str);
    }

    /**
     * Returns the value by calling {@code Long.valueOf(String)} if {@code str}
     * is not {@code null}, otherwise, the default value 0 for {@code long} is
     * returned.
     *
     * @param str
     * @return
     * @throws NumberFormatException If the string is not a parsable {@code long}.
     * @see Numbers#toLong(String)
     * @deprecated replaced by {@code Numbers.toLong(String)}
     */
    @Deprecated
    public static long parseLong(final String str) throws NumberFormatException {
        return Numbers.toLong(str);
    }

    /**
     * Returns the value by calling {@code Float.valueOf(String)} if {@code str}
     * is not {@code null}, otherwise, the default value 0f for {@code float} is
     * returned.
     *
     * @param str
     * @return
     * @throws NumberFormatException If the string is not a parsable {@code float}.
     * @see Numbers#toFloat(String)
     * @deprecated replaced by {@code Numbers.toFloat(String)}
     */
    @Deprecated
    public static float parseFloat(final String str) throws NumberFormatException {
        return Numbers.toFloat(str);
    }

    /**
     * Returns the value by calling {@code Double.valueOf(String)} if {@code str}
     * is not {@code null}, otherwise, the default value 0d for {@code double} is
     * returned.
     *
     * @param str
     * @return
     * @throws NumberFormatException If the string is not a parsable {@code double}.
     * @see Numbers#toDouble(String)
     * @deprecated replaced by {@code Numbers.toDouble(String)}
     */
    @Deprecated
    public static double parseDouble(final String str) throws NumberFormatException {
        return Numbers.toDouble(str);
    }

    //    // Rarely used. ============================================================================
    //    /**
    //     * Returns whether or not the octet is in the base 64 alphabet.
    //     *
    //     * @param octet
    //     *            The value to test
    //     * @return true if the value is defined in the the base 64 alphabet, false otherwise.
    //     */
    //    public static boolean isBase64(final byte octet) {
    //        return Base64.isBase64(octet);
    //    }
    //
    //    /**
    //     * Tests a given String to see if it contains only valid characters within the Base64 alphabet. Currently the
    //     * method treats whitespace as valid.
    //     *
    //     * @param base64
    //     *            String to test
    //     * @return true if all characters in the String are valid characters in the Base64 alphabet or if
    //     *         the String is empty; false, otherwise
    //     */
    //    public static boolean isBase64(final String base64) {
    //        return Base64.isBase64(base64);
    //    }
    //
    //    /**
    //     * Tests a given byte array to see if it contains only valid characters within the Base64 alphabet. Currently the
    //     * method treats whitespace as valid.
    //     *
    //     * @param arrayOctet
    //     *            byte array to test
    //     * @return true if all bytes are valid characters in the Base64 alphabet or if the byte array is empty;
    //     *         false, otherwise
    //     */
    //    public static boolean isBase64(final byte[] arrayOctet) {
    //        return Base64.isBase64(arrayOctet);
    //    }
    //    // Rarely used. ============================================================================

    /**
     * Base 64 encode.
     *
     * @param binaryData
     * @return
     */
    public static String base64Encode(final byte[] binaryData) {
        if (isNullOrEmpty(binaryData)) {
            return EMPTY_STRING;
        }

        return Base64.encodeBase64String(binaryData);
    }

    /**
     *
     *
     * @param str
     * @return
     */
    public static String base64EncodeString(final String str) {
        if (isNullOrEmpty(str)) {
            return EMPTY_STRING;
        }

        return Base64.encodeBase64String(str.getBytes());
    }

    /**
     *
     *
     * @param str
     * @return
     */
    public static String base64EncodeUtf8String(final String str) {
        if (isNullOrEmpty(str)) {
            return EMPTY_STRING;
        }

        return Base64.encodeBase64String(str.getBytes(Charsets.UTF_8));
    }

    /**
     * Base 64 encode chunked.
     *
     * @param binaryData
     * @return
     */
    public static String base64EncodeChunked(final byte[] binaryData) {
        if (isNullOrEmpty(binaryData)) {
            return EMPTY_STRING;
        }

        return new String(Base64.encodeBase64Chunked(binaryData), Charsets.US_ASCII);
    }

    /**
     * Base 64 decode.
     *
     * @param base64String
     * @return
     */
    public static byte[] base64Decode(final String base64String) {
        if (isNullOrEmpty(base64String)) {
            return EMPTY_BYTE_ARRAY;
        }

        return Base64.decodeBase64(base64String);
    }

    /**
     * Base 64 decode to string.
     *
     * @param base64String
     * @return
     */
    public static String base64DecodeToString(final String base64String) {
        if (isNullOrEmpty(base64String)) {
            return EMPTY_STRING;
        }

        return new String(base64Decode(base64String));
    }

    /**
     *
     *
     * @param base64String
     * @return
     */
    public static String base64DecodeToUtf8String(final String base64String) {
        if (isNullOrEmpty(base64String)) {
            return EMPTY_STRING;
        }

        return new String(base64Decode(base64String), Charsets.UTF_8);
    }

    /**
     * Base 64 url encode.
     *
     * @param binaryData
     * @return
     */
    public static String base64UrlEncode(final byte[] binaryData) {
        if (isNullOrEmpty(binaryData)) {
            return EMPTY_STRING;
        }

        return Base64.encodeBase64URLSafeString(binaryData);
    }

    /**
     * Base 64 url decode.
     *
     * @param base64String
     * @return
     */
    public static byte[] base64UrlDecode(final String base64String) {
        if (isNullOrEmpty(base64String)) {
            return EMPTY_BYTE_ARRAY;
        }

        return Base64.decodeBase64URL(base64String);
    }

    /**
     * Base 64 url decode to string.
     *
     * @param base64String
     * @return
     */
    public static String base64UrlDecodeToString(final String base64String) {
        if (isNullOrEmpty(base64String)) {
            return EMPTY_STRING;
        }

        return new String(Base64.decodeBase64URL(base64String));
    }

    /**
     *
     *
     * @param base64String
     * @return
     */
    public static String base64UrlDecodeToUtf8String(final String base64String) {
        if (isNullOrEmpty(base64String)) {
            return EMPTY_STRING;
        }

        return new String(Base64.decodeBase64URL(base64String), Charsets.UTF_8);
    }

    /**
     *
     * @param parameters
     * @return
     */
    public static String urlEncode(final Object parameters) {
        if (parameters == null) {
            return EMPTY_STRING;
        }

        return URLEncodedUtil.encode(parameters);
    }

    /**
     *
     * @param parameters
     * @param charset
     * @return
     */
    public static String urlEncode(final Object parameters, final Charset charset) {
        if (parameters == null) {
            return EMPTY_STRING;
        }

        return URLEncodedUtil.encode(parameters, charset);
    }

    /**
     *
     * @param urlQuery
     * @return
     */
    public static Map urlDecode(final String urlQuery) {
        if (isNullOrEmpty(urlQuery)) {
            return N.newLinkedHashMap();
        }

        return URLEncodedUtil.decode(urlQuery);
    }

    /**
     *
     * @param urlQuery
     * @param charset
     * @return
     */
    public static Map urlDecode(final String urlQuery, final Charset charset) {
        if (isNullOrEmpty(urlQuery)) {
            return N.newLinkedHashMap();
        }

        return URLEncodedUtil.decode(urlQuery, charset);
    }

    /**
     *
     *
     * @param 
     * @param urlQuery
     * @param targetClass
     * @return
     */
    public static  T urlDecode(final String urlQuery, final Class targetClass) {
        if (isNullOrEmpty(urlQuery)) {
            return newInstance(targetClass);
        }

        return URLEncodedUtil.decode(urlQuery, targetClass);
    }

    /**
     *
     *
     * @param 
     * @param urlQuery
     * @param charset
     * @param targetClass
     * @return
     */
    public static  T urlDecode(final String urlQuery, final Charset charset, final Class targetClass) {
        if (isNullOrEmpty(urlQuery)) {
            return newInstance(targetClass);
        }

        return URLEncodedUtil.decode(urlQuery, charset, targetClass);
    }

    /**
     * Returns the UUID without '-'.
     *
     * @return
     * @see UUID#randomUUID().
     */
    public static String guid() {
        return uuid().replace("-", "");
    }

    /**
     * Returns an UUID.
     *
     * @return
     * @see UUID#randomUUID().
     */
    public static String uuid() {
        return UUID.randomUUID().toString();
    }

    /**
     * Checks if is bean.
     *
     * @param cls
     * @return true, if is bean
     * @see ClassUtil#isBeanClass(Class)
     * @deprecated replaced by {@code ClassUtil.isBeanClass(Class)}
     */
    @Deprecated
    public static boolean isBeanClass(final Class cls) {
        return ClassUtil.isBeanClass(cls);
    }

    private static final Set> notKryoCompatible = newHashSet();

    /**
     *
     * @param 
     * @param obj a Java object which must be serializable and deserializable through {@code Kryo} or {@code JSON}.
     * @return {@code null} if {@code bean} is {@code null}
     */
    @SuppressWarnings("unchecked")
    public static  T clone(final T obj) {
        if (obj == null) {
            return null;
        }

        return (T) clone(obj, obj.getClass());
    }

    /**
     * Deeply copy by: obj -> serialize -> kryo/Json -> deserialize -> new object.
     *
     * @param 
     * @param obj a Java object which must be serializable and deserialiable through {@code Kryo} or {@code JSON}.
     * @param targetClass
     * @return a new instance of {@code targetClass} even if {@code bean} is {@code null}.
     * @throws IllegalArgumentException if {@code targetClass} is {@code null}.
     */
    @SuppressWarnings("unchecked")
    public static  T clone(final Object obj, final Class targetClass) throws IllegalArgumentException {
        N.checkArgNotNull(targetClass, "targetClass");

        if (obj == null) {
            if (ClassUtil.isBeanClass(targetClass)) {
                return copy(obj, targetClass);
            } else {
                return newInstance(targetClass);
            }
        }

        final Class srcCls = obj.getClass();
        Object copy = null;

        if (Utils.kryoParser != null && targetClass.equals(obj.getClass()) && !notKryoCompatible.contains(srcCls)) {
            try {
                copy = Utils.kryoParser.clone(obj);
            } catch (Exception e) {
                notKryoCompatible.add(srcCls);

                // ignore.
            }
        }

        if (copy == null) {
            String xml = Utils.abacusXMLParser.serialize(obj, Utils.xscForClone);
            copy = Utils.abacusXMLParser.deserialize(targetClass, xml);
        }

        return (T) copy;
    }

    /**
     * Returns a new created instance of the same class and set with same
     * properties retrieved by 'getXXX' method in the specified {@code bean}.
     *
     * @param 
     * @param bean a Java Object what allows access to properties using getter
     *            and setter methods.
     * @return {@code null} if {@code bean} is {@code null}
     */
    @SuppressWarnings("unchecked")
    public static  T copy(final T bean) {
        if (bean == null) {
            return null;
        }

        return copy(bean, (Class) bean.getClass());
    }

    /**
     *
     * @param 
     * @param bean
     * @param selectPropNames
     * @return {@code null} if {@code bean} is {@code null}
     */
    public static  T copy(final T bean, final Collection selectPropNames) {
        if (bean == null) {
            return null;
        }

        return copy(bean, selectPropNames, (Class) bean.getClass());
    }

    /**
     *
     *
     * @param 
     * @param bean
     * @param targetClass
     * @return a new instance of {@code targetClass} even if {@code bean} is {@code null}.
     * @throws IllegalArgumentException if {@code targetClass} is {@code null}.
     */
    public static  T copy(final Object bean, final Class targetClass) throws IllegalArgumentException {
        return copy(bean, null, targetClass);
    }

    /**
     * Returns a new created instance of the specified {@code cls} and set with
     * same properties retrieved by 'getXXX' method in the specified
     * {@code bean}.
     *
     * @param 
     * @param bean a Java Object what allows access to properties using getter
     *            and setter methods.
     * @param selectPropNames
     * @param targetClass a Java Object what allows access to properties using getter
     *            and setter methods.
     * @return a new instance of {@code targetClass} even if {@code bean} is {@code null}.
     * @throws IllegalArgumentException if {@code targetClass} is {@code null}.
     */
    @SuppressWarnings({ "unchecked" })
    public static  T copy(final Object bean, final Collection selectPropNames, final Class targetClass)
            throws IllegalArgumentException {
        N.checkArgNotNull(targetClass, "targetClass");

        if (bean != null) {
            final Class srcCls = bean.getClass();

            if (selectPropNames == null && Utils.kryoParser != null && targetClass.equals(srcCls) && !notKryoCompatible.contains(srcCls)) {
                try {
                    final T copy = (T) Utils.kryoParser.copy(bean);

                    if (copy != null) {
                        return copy;
                    }
                } catch (Exception e) {
                    notKryoCompatible.add(srcCls);

                    // ignore
                }
            }
        }

        final BeanInfo targetBeanInfo = ParserUtil.getBeanInfo(targetClass);
        Object result = targetBeanInfo.createBeanResult();

        if (bean != null) {
            merge(bean, result, selectPropNames, targetBeanInfo);
        }

        result = targetBeanInfo.finishBeanResult(result);

        return (T) result;
    }

    /**
     *
     *
     * @param 
     * @param bean
     * @param ignoreUnmatchedProperty
     * @param ignoredPropNames
     * @param targetClass
     * @return a new instance of {@code targetClass} even if {@code bean} is {@code null}.
     * @throws IllegalArgumentException if {@code targetClass} is {@code null}.
     */
    @SuppressWarnings({ "unchecked" })
    public static  T copy(final Object bean, final boolean ignoreUnmatchedProperty, final Set ignoredPropNames, final Class targetClass)
            throws IllegalArgumentException {
        N.checkArgNotNull(targetClass, "targetClass");

        if (bean != null) {
            final Class srcCls = bean.getClass();

            if (ignoredPropNames == null && Utils.kryoParser != null && targetClass.equals(srcCls) && !notKryoCompatible.contains(srcCls)) {
                try {
                    final T copy = (T) Utils.kryoParser.copy(bean);

                    if (copy != null) {
                        return copy;
                    }
                } catch (Exception e) {
                    notKryoCompatible.add(srcCls);

                    // ignore
                }
            }
        }

        final BeanInfo targetBeanInfo = ParserUtil.getBeanInfo(targetClass);
        Object result = targetBeanInfo.createBeanResult();

        if (bean != null) {
            merge(bean, result, ignoreUnmatchedProperty, ignoredPropNames, targetBeanInfo);
        }

        result = targetBeanInfo.finishBeanResult(result);

        return (T) result;
    }

    /**
     *
     *
     * @param 
     * @param sourceBean
     * @param targetBean
     * @return {@code targetBean}
     * @throws IllegalArgumentException if {@code targetBean} is {@code null}.
     */
    public static  T merge(final Object sourceBean, final T targetBean) throws IllegalArgumentException {
        return merge(sourceBean, targetBean, (Collection) null);
    }

    /**
     * Set all the signed properties(including all primitive type properties) in
     * the specified {@code sourceBean} to the specified {@code targetBean}.
     *
     * @param 
     * @param sourceBean a Java Object what allows access to properties using getter
     *            and setter methods.
     * @param targetBean a Java Object what allows access to properties using getter
     *            and setter methods.
     * @param selectPropNames
     * @return {@code targetBean}
     * @throws IllegalArgumentException if {@code targetBean} is {@code null}.
     */
    public static  T merge(final Object sourceBean, final T targetBean, final Collection selectPropNames) throws IllegalArgumentException {
        N.checkArgNotNull(targetBean, "targetBean");

        return merge(sourceBean, targetBean, selectPropNames, ParserUtil.getBeanInfo(targetBean.getClass()));
    }

    @SuppressWarnings("deprecation")
    private static  T merge(final Object sourceBean, final T targetBean, final Collection selectPropNames, final BeanInfo targetBeanInfo)
            throws IllegalArgumentException {
        N.checkArgNotNull(targetBean, "targetBean");

        if (sourceBean == null) {
            return targetBean;
        }

        final BeanInfo srcBeanInfo = ParserUtil.getBeanInfo(sourceBean.getClass());
        final boolean ignoreUnmatchedProperty = selectPropNames == null;

        if (selectPropNames == null) {
            Object propValue = null;

            for (PropInfo propInfo : srcBeanInfo.propInfoList) {
                propValue = propInfo.getPropValue(sourceBean);

                if (InternalUtil.notNullOrDefault(propValue)) {
                    targetBeanInfo.setPropValue(targetBean, propInfo, propValue, ignoreUnmatchedProperty);
                }
            }
        } else {
            PropInfo propInfo = null;
            Object propValue = null;

            for (String propName : selectPropNames) {
                propInfo = srcBeanInfo.getPropInfo(propName);
                propValue = propInfo.getPropValue(sourceBean);

                targetBeanInfo.setPropValue(targetBean, propInfo, propValue, ignoreUnmatchedProperty);
            }
        }

        return targetBean;
    }

    /**
     * Set all the signed properties(including all primitive type properties) in
     * the specified {@code sourceBean} to the specified {@code targetBean}.
     *
     * @param 
     * @param sourceBean a Java Object what allows access to properties using getter
     *            and setter methods.
     * @param targetBean a Java Object what allows access to properties using getter
     *            and setter methods.
     * @param filter
     * @return {@code targetBean}
     * @throws IllegalArgumentException if {@code targetBean} is {@code null}.
     */
    public static  T merge(final Object sourceBean, final T targetBean, final BiPredicate filter) throws IllegalArgumentException {
        N.checkArgNotNull(targetBean, "targetBean");

        if (sourceBean == null) {
            return targetBean;
        }

        final BeanInfo srcBeanInfo = ParserUtil.getBeanInfo(sourceBean.getClass());
        final BeanInfo targetBeanInfo = ParserUtil.getBeanInfo(targetBean.getClass());
        final BiPredicate objFilter = (BiPredicate) filter;

        Object propValue = null;

        for (PropInfo propInfo : srcBeanInfo.propInfoList) {
            propValue = propInfo.getPropValue(sourceBean);

            if (objFilter.test(propInfo.name, propValue)) {
                targetBeanInfo.setPropValue(targetBean, propInfo, propValue, false);
            }
        }

        return targetBean;
    }

    /**
     *
     *
     * @param 
     * @param sourceBean
     * @param targetBean
     * @param ignoreUnmatchedProperty
     * @param ignoredPropNames
     * @return {@code targetBean}
     * @throws IllegalArgumentException if {@code targetBean} is {@code null}.
     */
    public static  T merge(final Object sourceBean, final T targetBean, final boolean ignoreUnmatchedProperty, final Set ignoredPropNames)
            throws IllegalArgumentException {
        N.checkArgNotNull(targetBean, "targetBean");

        if (sourceBean == null) {
            return targetBean;
        }

        return merge(sourceBean, targetBean, ignoreUnmatchedProperty, ignoredPropNames, ParserUtil.getBeanInfo(targetBean.getClass()));
    }

    @SuppressWarnings("deprecation")
    private static  T merge(final Object sourceBean, final T targetBean, final boolean ignoreUnmatchedProperty, final Set ignoredPropNames,
            final BeanInfo targetBeanInfo) throws IllegalArgumentException {
        N.checkArgNotNull(targetBean, "targetBean");

        if (sourceBean == null) {
            return targetBean;
        }

        final BeanInfo srcBeanInfo = ParserUtil.getBeanInfo(sourceBean.getClass());

        Object propValue = null;

        for (PropInfo propInfo : srcBeanInfo.propInfoList) {
            if (ignoredPropNames == null || !ignoredPropNames.contains(propInfo.name)) {
                propValue = propInfo.getPropValue(sourceBean);

                if (InternalUtil.notNullOrDefault(propValue)) {
                    targetBeanInfo.setPropValue(targetBean, propInfo, propValue, ignoreUnmatchedProperty);
                }
            }
        }

        return targetBean;
    }

    /**
     *
     *
     * @param 
     * @param sourceBean
     * @param targetBean
     * @param mergeFunc the first parameter is source property value, the second parameter is target property value.
     * @return {@code targetBean}
     * @throws IllegalArgumentException if {@code targetBean} is {@code null}.
     */
    public static  T merge(final Object sourceBean, final T targetBean, final BinaryOperator mergeFunc) throws IllegalArgumentException {
        return merge(sourceBean, targetBean, (Collection) null, mergeFunc);
    }

    /**
     * Set all the signed properties(including all primitive type properties) in
     * the specified {@code sourceBean} to the specified {@code targetBean}.
     *
     * @param 
     * @param sourceBean a Java Object what allows access to properties using getter
     *            and setter methods.
     * @param targetBean a Java Object what allows access to properties using getter
     *            and setter methods.
     * @param selectPropNames
     * @param mergeFunc the first parameter is source property value, the second parameter is target property value.
     * @return {@code targetBean}
     * @throws IllegalArgumentException if {@code targetBean} is {@code null}.
     */
    public static  T merge(final Object sourceBean, final T targetBean, final Collection selectPropNames, final BinaryOperator mergeFunc)
            throws IllegalArgumentException {
        N.checkArgNotNull(targetBean, "targetBean");

        if (sourceBean == null) {
            return targetBean;
        }

        final BeanInfo srcBeanInfo = ParserUtil.getBeanInfo(sourceBean.getClass());
        final BeanInfo targetBeanInfo = ParserUtil.getBeanInfo(targetBean.getClass());
        final BinaryOperator objMergeFunc = (BinaryOperator) mergeFunc;
        final boolean ignoreUnmatchedProperty = selectPropNames == null;

        if (selectPropNames == null) {
            PropInfo targetPropInfo = null;
            Object propValue = null;

            for (PropInfo propInfo : srcBeanInfo.propInfoList) {
                targetPropInfo = targetBeanInfo.getPropInfo(propInfo);

                if (targetPropInfo == null) {
                    //    if (!ignoreUnmatchedProperty) {
                    //        throw new IllegalArgumentException(
                    //                "No property found by name: " + propInfo.name + " in target bean class: " + targetBean.getClass());
                    //    }
                } else {
                    propValue = propInfo.getPropValue(sourceBean);
                    targetPropInfo.setPropValue(targetBean, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetBean)));
                }
            }
        } else {
            PropInfo targetPropInfo = null;
            PropInfo propInfo = null;
            Object propValue = null;

            for (String propName : selectPropNames) {
                propInfo = srcBeanInfo.getPropInfo(propName);
                targetPropInfo = targetBeanInfo.getPropInfo(propInfo);

                if (targetPropInfo == null) {
                    if (!ignoreUnmatchedProperty) { //NOSONAR
                        throw new IllegalArgumentException("No property found by name: " + propName + " in target bean class: " + targetBean.getClass()); //NOSONAR
                    }
                } else {
                    propValue = srcBeanInfo.getPropValue(sourceBean, propName);
                    targetPropInfo.setPropValue(targetBean, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetBean)));
                }
            }
        }

        return targetBean;
    }

    /**
     * Set all the signed properties(including all primitive type properties) in
     * the specified {@code sourceBean} to the specified {@code targetBean}.
     *
     * @param 
     * @param sourceBean a Java Object what allows access to properties using getter
     *            and setter methods.
     * @param targetBean a Java Object what allows access to properties using getter
     *            and setter methods.
     * @param filter
     * @param mergeFunc the first parameter is source property value, the second parameter is target property value.
     * @return {@code targetBean}
     * @throws IllegalArgumentException if {@code targetBean} is {@code null}.
     */
    public static  T merge(final Object sourceBean, final T targetBean, final BiPredicate filter, final BinaryOperator mergeFunc)
            throws IllegalArgumentException {
        N.checkArgNotNull(targetBean, "targetBean");

        if (sourceBean == null) {
            return targetBean;
        }

        final BeanInfo srcBeanInfo = ParserUtil.getBeanInfo(sourceBean.getClass());
        final BeanInfo targetBeanInfo = ParserUtil.getBeanInfo(targetBean.getClass());
        final BiPredicate objFilter = (BiPredicate) filter;
        final BinaryOperator objMergeFunc = (BinaryOperator) mergeFunc;

        Object propValue = null;
        PropInfo targetPropInfo = null;

        for (PropInfo propInfo : srcBeanInfo.propInfoList) {
            propValue = propInfo.getPropValue(sourceBean);

            if (objFilter.test(propInfo.name, propValue)) {
                targetPropInfo = targetBeanInfo.getPropInfo(propInfo);

                if (targetPropInfo == null) {
                    throw new IllegalArgumentException("No property found by name: " + propInfo.name + " in target bean class: " + targetBean.getClass());
                }

                targetPropInfo.setPropValue(targetBean, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetBean)));
            }
        }

        return targetBean;
    }

    /**
     *
     *
     * @param 
     * @param sourceBean
     * @param targetBean
     * @param ignoreUnmatchedProperty
     * @param ignoredPropNames
     * @param mergeFunc the first parameter is source property value, the second parameter is target property value.
     * @return {@code targetBean}
     * @throws IllegalArgumentException if {@code targetBean} is {@code null}.
     */
    public static  T merge(final Object sourceBean, final T targetBean, final boolean ignoreUnmatchedProperty, final Set ignoredPropNames,
            final BinaryOperator mergeFunc) throws IllegalArgumentException {
        N.checkArgNotNull(targetBean, "targetBean");

        if (sourceBean == null) {
            return targetBean;
        }

        final BeanInfo srcBeanInfo = ParserUtil.getBeanInfo(sourceBean.getClass());
        final BeanInfo targetBeanInfo = ParserUtil.getBeanInfo(targetBean.getClass());
        final BinaryOperator objMergeFunc = (BinaryOperator) mergeFunc;

        PropInfo targetPropInfo = null;
        Object propValue = null;

        for (PropInfo propInfo : srcBeanInfo.propInfoList) {
            if (ignoredPropNames == null || !ignoredPropNames.contains(propInfo.name)) {
                targetPropInfo = targetBeanInfo.getPropInfo(propInfo);

                if (targetPropInfo == null) {
                    if (!ignoreUnmatchedProperty) {
                        throw new IllegalArgumentException("No property found by name: " + propInfo.name + " in target bean class: " + targetBean.getClass());
                    }
                } else {
                    propValue = propInfo.getPropValue(sourceBean);
                    targetPropInfo.setPropValue(targetBean, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetBean)));
                }
            }
        }

        return targetBean;
    }

    /**
     *
     * @param bean
     * @param propNames
     */
    @SafeVarargs
    public static void erase(final Object bean, final String... propNames) {
        if (bean == null || isNullOrEmpty(propNames)) {
            return;
        }

        final BeanInfo beanInfo = ParserUtil.getBeanInfo(bean.getClass());

        for (String propName : propNames) {
            beanInfo.setPropValue(bean, propName, null);
        }
    }

    /**
     *
     * @param bean
     * @param propNames
     */
    public static void erase(final Object bean, final Collection propNames) {
        if (bean == null || isNullOrEmpty(propNames)) {
            return;
        }

        final BeanInfo beanInfo = ParserUtil.getBeanInfo(bean.getClass());

        for (String propName : propNames) {
            beanInfo.setPropValue(bean, propName, null);
        }
    }

    /**
     *
     * @param bean
     */
    public static void eraseAll(final Object bean) {
        if (bean == null) {
            return;
        }

        final Class cls = bean.getClass();
        final BeanInfo beanInfo = ParserUtil.getBeanInfo(cls);

        for (PropInfo propInfo : beanInfo.propInfoList) {
            propInfo.setPropValue(bean, null);
        }
    }

    /**
     * Returns an empty immutable {@code List}.
     *
     * @param 
     * @return
     * @see Collections#emptyList()
     */
    @Immutable
    public static  List emptyList() {
        return EMPTY_LIST;
    }

    /**
     * Returns an empty immutable {@code Set}.
     *
     * @param 
     * @return
     * @see Collections#emptySet()
     */
    @Immutable
    public static  Set emptySet() {
        return EMPTY_SET;
    }

    /**
     * Returns an empty immutable {@code SortedSet}.
     *
     * @param 
     * @return
     * @see Collections#emptySortedSet()
     */
    @Immutable
    public static  SortedSet emptySortedSet() {
        return EMPTY_SORTED_SET;
    }

    /**
     * Returns an empty immutable {@code NavigableSet}.
     *
     * @param 
     * @return
     * @see Collections#emptyNavigableSet()
     */
    @Immutable
    public static  NavigableSet emptyNavigableSet() {
        return EMPTY_NAVIGABLE_SET;
    }

    /**
     * Returns an empty immutable {@code Map}.
     *
     * @param  the key type
     * @param  the value type
     * @return
     * @see Collections#emptyMap()
     */
    @Immutable
    public static  Map emptyMap() {
        return EMPTY_MAP;
    }

    /**
     * Returns an empty immutable {@code SortedMap}.
     *
     * @param  the key type
     * @param  the value type
     * @return
     * @see Collections#emptySortedMap()
     */
    @Immutable
    public static  SortedMap emptySortedMap() {
        return EMPTY_SORTED_MAP;
    }

    /**
     * Returns an empty immutable {@code NavigableMap}.
     *
     * @param  the key type
     * @param  the value type
     * @return
     * @see Collections#emptyNavigableMap()
     */
    @Immutable
    public static  NavigableMap emptyNavigableMap() {
        return EMPTY_NAVIGABLE_MAP;
    }

    /**
     * Returns an empty immutable {@code Iterator}.
     *
     * @param 
     * @return
     * @see Collections#emptyIterator()
     */
    public static  Iterator emptyIterator() {
        return EMPTY_ITERATOR;
    }

    /**
     * Returns an empty immutable {@code ListIterator}.
     *
     * @param 
     * @return
     * @see Collections#emptyListIterator()
     */
    @Immutable
    public static  ListIterator emptyListIterator() {
        return EMPTY_LIST_ITERATOR;
    }

    private static final ByteArrayInputStream EMPTY_INPUT_STREAM = new ByteArrayInputStream(EMPTY_BYTE_ARRAY);

    /**
     * Returns an empty immutable {@code InputStream}.
     *
     * @return
     */
    @Immutable
    public static InputStream emptyInputStream() {
        return EMPTY_INPUT_STREAM;
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static  boolean anyNull(final A a, final B b) {
        return a == null || b == null;
    }

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static  boolean anyNull(final A a, final B b, final C c) {
        return a == null || b == null || c == null;
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  boolean anyNull(final T... a) {
        if (isNullOrEmpty(a)) {
            return false;
        }

        for (T e : a) {
            if (e == null) {
                return true;
            }
        }

        return false;
    }

    /**
     *
     *
     * @param c
     * @return
     */
    public static boolean anyNull(final Collection c) {
        if (isNullOrEmpty(c)) {
            return false;
        }

        for (Object e : c) {
            if (e == null) {
                return true;
            }
        }

        return false;
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static  boolean allNull(final A a, final B b) {
        return a == null && b == null;
    }

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static  boolean allNull(final A a, final B b, final C c) {
        return a == null && b == null && c == null;
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  boolean allNull(final T... a) {
        if (isNullOrEmpty(a)) {
            return true;
        }

        for (T e : a) {
            if (e != null) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param c
     * @return
     */
    public static boolean allNull(final Collection c) {
        if (isNullOrEmpty(c)) {
            return true;
        }

        for (Object e : c) {
            if (e != null) {
                return false;
            }
        }

        return true;
    }

    /**
     * check if any null or empty.
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean anyNullOrEmpty(final CharSequence a, final CharSequence b) {
        return a == null || a.length() == 0 || b == null || b.length() == 0;
    }

    /**
     * check if any null or empty.
     *
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static boolean anyNullOrEmpty(final CharSequence a, final CharSequence b, final CharSequence c) {
        return a == null || a.length() == 0 || b == null || b.length() == 0 || c == null || c.length() == 0;
    }

    /**
     * check if any null or empty.
     *
     * @param css
     * @return
     */
    @SafeVarargs
    public static boolean anyNullOrEmpty(final CharSequence... css) {
        if (isNullOrEmpty(css)) {
            return false;
        }

        for (CharSequence cs : css) {
            if (cs == null || cs.length() == 0) {
                return true;
            }
        }

        return false;
    }

    /**
     * check if any null or empty.
     *
     * @param css
     * @return
     */
    public static boolean anyNullOrEmpty(final Collection css) {
        if (isNullOrEmpty(css)) {
            return false;
        }

        for (CharSequence cs : css) {
            if (cs == null || cs.length() == 0) {
                return true;
            }
        }

        return false;
    }

    /**
     * Any blank.
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean anyBlank(final CharSequence a, final CharSequence b) {
        return isBlank(a) || isBlank(b);
    }

    /**
     * Any blank.
     *
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static boolean anyBlank(final CharSequence a, final CharSequence b, final CharSequence c) {
        return isBlank(a) || isBlank(b) || isBlank(c);
    }

    /**
     * Any blank.
     *
     * @param css
     * @return
     */
    @SafeVarargs
    public static boolean anyBlank(final CharSequence... css) {
        if (isNullOrEmpty(css)) {
            return false;
        }

        for (CharSequence cs : css) {
            if (isBlank(cs)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Any blank.
     *
     * @param css
     * @return
     */
    public static boolean anyBlank(final Collection css) {
        if (isNullOrEmpty(css)) {
            return false;
        }

        for (CharSequence cs : css) {
            if (isBlank(cs)) {
                return true;
            }
        }

        return false;
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static  boolean anyNullOrEmpty(final A[] a, final B[] b) {
        return a == null || a.length == 0 || b == null || b.length == 0;
    }

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static  boolean anyNullOrEmpty(final A[] a, final B[] b, final C[] c) {
        return a == null || a.length == 0 || b == null || b.length == 0 || c == null || c.length == 0;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean anyNullOrEmpty(final Collection a, final Collection b) {
        return a == null || a.size() == 0 || b == null || b.size() == 0;
    }

    /**
     *
     *
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static boolean anyNullOrEmpty(final Collection a, final Collection b, final Collection c) {
        return a == null || a.size() == 0 || b == null || b.size() == 0 || c == null || c.size() == 0;
    }

    /**
     * All null or empty.
     *
     * @param cs1
     * @param cs2
     * @return
     */
    public static boolean allNullOrEmpty(final CharSequence cs1, final CharSequence cs2) {
        return isNullOrEmpty(cs1) && isNullOrEmpty(cs2);
    }

    /**
     * All null or empty.
     *
     * @param cs1
     * @param cs2
     * @param cs3
     * @return
     */
    public static boolean allNullOrEmpty(final CharSequence cs1, final CharSequence cs2, final CharSequence cs3) {
        return isNullOrEmpty(cs1) && isNullOrEmpty(cs2) && isNullOrEmpty(cs3);
    }

    /**
     * All null or empty.
     *
     * @param css
     * @return
     */
    @SafeVarargs
    public static boolean allNullOrEmpty(final CharSequence... css) {
        if (isNullOrEmpty(css)) {
            return true;
        }

        for (CharSequence cs : css) {
            if (!isNullOrEmpty(cs)) {
                return false;
            }
        }

        return true;
    }

    /**
     * All null or empty.
     *
     * @param css
     * @return
     */
    public static boolean allNullOrEmpty(final Collection css) {
        if (isNullOrEmpty(css)) {
            return true;
        }

        for (CharSequence cs : css) {
            if (!isNullOrEmpty(cs)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Any blank.
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean allBlank(final CharSequence a, final CharSequence b) {
        return isBlank(a) && isBlank(b);
    }

    /**
     * Check if all elements are blank.
     *
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static boolean allBlank(final CharSequence a, final CharSequence b, final CharSequence c) {
        return isBlank(a) && isBlank(b) && isBlank(c);
    }

    /**
     * Check if all elements are blank.
     *
     * @param css
     * @return
     */
    @SafeVarargs
    public static boolean allBlank(final CharSequence... css) {
        if (isNullOrEmpty(css)) {
            return true;
        }

        for (CharSequence cs : css) {
            if (!isBlank(cs)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Check if all elements are blank.
     *
     * @param css
     * @return
     */
    public static boolean allBlank(final Collection css) {
        if (isNullOrEmpty(css)) {
            return true;
        }

        for (CharSequence cs : css) {
            if (!isBlank(cs)) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static  boolean allNullOrEmpty(final A[] a, final B[] b) {
        return isNullOrEmpty(a) && isNullOrEmpty(b);
    }

    /**
     * @param 
     * @param 
     * @param 
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static  boolean allNullOrEmpty(final A[] a, final B[] b, final C[] c) {
        return isNullOrEmpty(a) && isNullOrEmpty(b) && isNullOrEmpty(c);
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean allNullOrEmpty(final Collection a, final Collection b) {
        return isNullOrEmpty(a) && isNullOrEmpty(b);
    }

    /**
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static boolean allNullOrEmpty(final Collection a, final Collection b, final Collection c) {
        return isNullOrEmpty(a) && isNullOrEmpty(b) && isNullOrEmpty(c);
    }

    /**
     *
     * @param 
     * @param c
     * @param index
     * @return
     * @throws IndexOutOfBoundsException the index out of bounds exception
     */
    public static  T getElement(final Collection c, int index) throws IndexOutOfBoundsException {
        checkIndex(index, size(c));

        if (c instanceof List) {
            return ((List) c).get(index);
        }

        final Iterator iter = c.iterator();

        while (index-- > 0) {
            iter.next();
        }

        return iter.next();
    }

    /**
     * Gets the only element.
     *
     * @param 
     * @param c
     * @return throws TooManyElementsException if there are more than one elements in the specified {@code iterable}.
     * @throws TooManyElementsException
     */
    public static  Nullable getOnlyElement(Collection c) throws TooManyElementsException {
        if (isNullOrEmpty(c)) {
            return Nullable.empty();
        } else if (c.size() > 1) {
            final Iterator iter = c.iterator();

            throw new TooManyElementsException("Expected at most one element but was: [" + Strings.concat(iter.next(), ", ", iter.next(), "...]"));
        }

        return firstElement(c);
    }

    /**
     * Gets the only element.
     *
     * @param 
     * @param iter
     * @return throws TooManyElementsException if there are more than one elements in the specified {@code iter}.
     * @throws TooManyElementsException the duplicated result exception
     */
    public static  Nullable getOnlyElement(final Iterator iter) throws TooManyElementsException {
        if (iter == null) {
            return Nullable.empty();
        }

        final T first = iter.next();

        if (iter.hasNext()) {
            throw new TooManyElementsException("Expected at most one element but was: [" + Strings.concat(first, ", ", iter.next(), "...]"));
        }

        return Nullable.of(first);
    }

    /**
     *
     * @param 
     * @param c
     * @return
     */
    public static  Nullable firstElement(final Collection c) {
        if (isNullOrEmpty(c)) {
            return Nullable.empty();
        }

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

    /**
     *
     * @param 
     * @param iter
     * @return
     */
    public static  Nullable firstElement(final Iterator iter) {
        return iter != null && iter.hasNext() ? Nullable.of(iter.next()) : Nullable. empty();
    }

    /**
     *
     * @param 
     * @param c
     * @return
     */
    public static  Nullable lastElement(final Collection c) {
        if (isNullOrEmpty(c)) {
            return Nullable.empty();
        }

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

            if (c instanceof RandomAccess) {
                return Nullable.of(list.get(c.size() - 1));
            } else {
                return Nullable.of(list.listIterator(list.size()).previous());
            }
        } else if (c instanceof Deque) {
            return Nullable.of(((Deque) c).descendingIterator().next());
        } else {
            try {
                Method m = null;

                if ((m = ClassUtil.getDeclaredMethod(c.getClass(), "descendingIterator")) != null && Modifier.isPublic(m.getModifiers())
                        && Iterator.class.isAssignableFrom(m.getReturnType())) {

                    final Iterator iter = ClassUtil.invokeMethod(c, m);

                    return Nullable.of(iter.next());
                }
            } catch (Exception e2) {
                // continue
            }

            return lastElement(c.iterator());
        }
    }

    /**
     *
     * @param 
     * @param iter
     * @return
     */
    public static  Nullable lastElement(final Iterator iter) {
        if (iter == null || !iter.hasNext()) {
            return Nullable.empty();
        }

        T e = null;

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

        return Nullable.of(e);
    }

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

        if (N.isNullOrEmpty(c) || n == 0) {
            return new ArrayList<>();
        } else if (c.size() <= n) {
            return new ArrayList<>(c);
        } else if (c instanceof List) {
            return new ArrayList<>(((List) c).subList(0, n));
        } else {
            final List result = new ArrayList<>(N.min(n, c.size()));
            int cnt = 0;

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

                if (++cnt == n) {
                    break;
                }
            }

            return result;
        }
    }

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

        if (N.isNullOrEmpty(c) || n == 0) {
            return new ArrayList<>();
        } else if (c.size() <= n) {
            return new ArrayList<>(c);
        } else if (c instanceof List) {
            return new ArrayList<>(((List) c).subList(c.size() - n, c.size()));
        } else {
            final List result = new ArrayList<>(N.min(n, c.size()));
            final Iterator iter = c.iterator();
            int offset = c.size() - n;

            while (offset-- > 0) {
                iter.next();
            }

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

            return result;
        }
    }

    /**
     * First non null.
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static  Optional firstNonNull(final T a, final T b) {
        return a != null ? Optional.of(a) : (b != null ? Optional.of(b) : Optional. empty());
    }

    /**
     * First non null.
     *
     * @param 
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static  Optional firstNonNull(final T a, final T b, final T c) {
        return a != null ? Optional.of(a) : (b != null ? Optional.of(b) : (c != null ? Optional.of(c) : Optional. empty()));
    }

    /**
     * First non null.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  Optional firstNonNull(final T... a) {
        if (isNullOrEmpty(a)) {
            return Optional.empty();
        }

        for (T e : a) {
            if (e != null) {
                return Optional.of(e);
            }
        }

        return Optional.empty();
    }

    /**
     * First non null.
     *
     * @param 
     * @param c
     * @return
     */
    public static  Optional firstNonNull(final Collection c) {
        if (isNullOrEmpty(c)) {
            return Optional.empty();
        }

        for (T e : c) {
            if (e != null) {
                return Optional.of(e);
            }
        }

        return Optional.empty();
    }

    /**
     * First non null.
     *
     * @param 
     * @param iter
     * @return
     */
    public static  Optional firstNonNull(final Iterator iter) {
        if (iter == null) {
            return Optional.empty();
        }

        T e = null;

        while (iter.hasNext()) {
            if ((e = iter.next()) != null) {
                return Optional.of(e);
            }
        }

        return Optional.empty();
    }

    /**
     * Last non null.
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static  Optional lastNonNull(final T a, final T b) {
        return b != null ? Optional.of(b) : (a != null ? Optional.of(a) : Optional. empty());
    }

    /**
     * Last non null.
     *
     * @param 
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static  Optional lastNonNull(final T a, final T b, final T c) {
        return c != null ? Optional.of(c) : (b != null ? Optional.of(b) : (a != null ? Optional.of(a) : Optional. empty()));
    }

    /**
     * Last non null.
     *
     * @param 
     * @param a
     * @return
     */
    @SafeVarargs
    public static  Optional lastNonNull(final T... a) {
        if (isNullOrEmpty(a)) {
            return Optional.empty();
        }

        for (int i = a.length - 1; i >= 0; i--) {
            if (a[i] != null) {
                return Optional.of(a[i]);
            }
        }

        return Optional.empty();
    }

    /**
     * Last non null.
     *
     * @param 
     * @param c
     * @return
     */
    public static  Optional lastNonNull(final Collection c) {
        if (isNullOrEmpty(c)) {
            return Optional.empty();
        }

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

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

                while (iter.hasPrevious()) {
                    if ((pre = iter.previous()) != null) {
                        return Optional.of(pre);
                    }
                }
            }
        } else if (c instanceof Deque) {
            final Iterator iter = ((Deque) c).descendingIterator();
            T next = null;

            while (iter.hasNext()) {
                if ((next = iter.next()) != null) {
                    return Optional.of(next);
                }
            }
        } else {
            try {
                Method m = null;

                if ((m = ClassUtil.getDeclaredMethod(c.getClass(), "descendingIterator")) != null && Modifier.isPublic(m.getModifiers())
                        && Iterator.class.isAssignableFrom(m.getReturnType())) {

                    final Iterator iter = ClassUtil.invokeMethod(c, m);

                    T next = null;

                    while (iter.hasNext()) {
                        if ((next = iter.next()) != null) {
                            return Optional.of(next);
                        }
                    }
                }
            } catch (Exception e2) {
                // continue
            }

            lastNonNull(c.iterator());
        }

        return Optional.empty();
    }

    /**
     * Last non null.
     *
     * @param 
     * @param iter
     * @return
     */
    public static  Optional lastNonNull(final Iterator iter) {
        if (iter == null) {
            return Optional.empty();
        }

        T e = null;
        T lastNonNull = null;

        while (iter.hasNext()) {
            if ((e = iter.next()) != null) {
                lastNonNull = e;
            }
        }

        return Optional.ofNullable(lastNonNull);
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static  Optional firstNonEmpty(final T a, final T b) {
        return notNullOrEmpty(a) ? Optional.of(a) : (notNullOrEmpty(b) ? Optional.of(b) : Optional. empty());
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static  Optional firstNonEmpty(final T a, final T b, final T c) {
        return notNullOrEmpty(a) ? Optional.of(a) : (notNullOrEmpty(b) ? Optional.of(b) : (notNullOrEmpty(c) ? Optional.of(c) : Optional. empty()));
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    public static  Optional firstNonEmpty(final T... a) {
        if (isNullOrEmpty(a)) {
            return Optional.empty();
        }

        for (T e : a) {
            if (N.notNullOrEmpty(e)) {
                return Optional.of(e);
            }
        }

        return Optional.empty();
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static  Optional firstNonBlank(final T a, final T b) {
        return notBlank(a) ? Optional.of(a) : (notBlank(b) ? Optional.of(b) : Optional. empty());
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static  Optional firstNonBlank(final T a, final T b, final T c) {
        return notBlank(a) ? Optional.of(a) : (notBlank(b) ? Optional.of(b) : (notBlank(c) ? Optional.of(c) : Optional. empty()));
    }

    /**
     *
     * @param 
     * @param a
     * @return
     */
    public static  Optional firstNonBlank(final T... a) {
        if (isNullOrEmpty(a)) {
            return Optional.empty();
        }

        for (T e : a) {
            if (N.notBlank(e)) {
                return Optional.of(e);
            }
        }

        return Optional.empty();
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static  Optional firstNonEmpty(final T[] a, final T[] b) {
        return a != null && a.length > 0 ? Optional.of(a) : (b != null && b.length > 0 ? Optional.of(b) : Optional. empty());
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static  Optional firstNonEmpty(final T[] a, final T[] b, final T[] c) {
        return a != null && a.length > 0 ? Optional.of(a)
                : (b != null && b.length > 0 ? Optional.of(b) : (c != null && c.length > 0 ? Optional.of(c) : Optional. empty()));
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static > Optional firstNonEmpty(final T a, final T b) {
        return a != null && a.size() > 0 ? Optional.of(a) : (b != null && b.size() > 0 ? Optional.of(b) : Optional. empty());
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static > Optional firstNonEmpty(final T a, final T b, final T c) {
        return a != null && a.size() > 0 ? Optional.of(a)
                : (b != null && b.size() > 0 ? Optional.of(b) : (c != null && c.size() > 0 ? Optional.of(c) : Optional. empty()));
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param map
     * @return
     */
    public static  Optional> firstEntry(final Map map) {
        if (map == null || map.isEmpty()) {
            return Optional.empty();
        }

        return Optional.of(map.entrySet().iterator().next());
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param map
     * @return
     */
    public static  Optional> lastEntry(final Map map) {
        if (map == null || map.isEmpty()) {
            return Optional.empty();
        }

        return lastNonNull(map.entrySet().iterator());
    }

    /**
     * First or null if empty.
     *
     * @param 
     * @param a
     * @return
     */
    public static  T firstOrNullIfEmpty(final T[] a) {
        return a == null || a.length == 0 ? null : a[0];
    }

    /**
     * First or null if empty.
     *
     * @param 
     * @param c
     * @return
     */
    public static  T firstOrNullIfEmpty(final Collection c) {
        return firstOrDefaultIfEmpty(c, null);
    }

    /**
     * First or null if empty.
     *
     * @param 
     * @param iter
     * @return
     */
    public static  T firstOrNullIfEmpty(final Iterator iter) {
        return firstOrDefaultIfEmpty(iter, null);
    }

    /**
     * First or default if empty.
     *
     * @param 
     * @param a
     * @param defaultValueForEmpty
     * @return
     */
    public static  T firstOrDefaultIfEmpty(final T[] a, final T defaultValueForEmpty) {
        return a == null || a.length == 0 ? defaultValueForEmpty : a[0];
    }

    /**
     * First or default if empty.
     *
     * @param 
     * @param c
     * @param defaultValueForEmpty
     * @return
     */
    public static  T firstOrDefaultIfEmpty(final Collection c, final T defaultValueForEmpty) {
        if (isNullOrEmpty(c)) {
            return defaultValueForEmpty;
        }

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

    /**
     * First or default if empty.
     *
     * @param 
     * @param iter
     * @param defaultValueForEmpty
     * @return
     */
    public static  T firstOrDefaultIfEmpty(final Iterator iter, final T defaultValueForEmpty) {
        if (iter == null || !iter.hasNext()) {
            return defaultValueForEmpty;
        }

        return iter.next();
    }

    /**
     * Last or null if empty.
     *
     * @param 
     * @param a
     * @return
     */
    public static  T lastOrNullIfEmpty(final T[] a) {
        return a == null || a.length == 0 ? null : a[a.length - 1];
    }

    /**
     * Last or null if empty.
     *
     * @param 
     * @param c
     * @return
     */
    public static  T lastOrNullIfEmpty(final Collection c) {
        return lastOrDefaultIfEmpty(c, null);
    }

    /**
     * Last or null if empty.
     *
     * @param 
     * @param iter
     * @return
     */
    public static  T lastOrNullIfEmpty(final Iterator iter) {
        return lastOrDefaultIfEmpty(iter, null);
    }

    /**
     * Last or default if empty.
     *
     * @param 
     * @param a
     * @param defaultValueForEmpty
     * @return
     */
    public static  T lastOrDefaultIfEmpty(final T[] a, final T defaultValueForEmpty) {
        return a == null || a.length == 0 ? defaultValueForEmpty : a[a.length - 1];
    }

    /**
     * Last or default if empty.
     *
     * @param 
     * @param c
     * @param defaultValueForEmpty
     * @return
     */
    public static  T lastOrDefaultIfEmpty(final Collection c, final T defaultValueForEmpty) {
        if (isNullOrEmpty(c)) {
            return defaultValueForEmpty;
        }

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

            if (c instanceof RandomAccess) {
                return list.get(c.size() - 1);
            } else {
                return list.listIterator(list.size()).previous();
            }
        } else if (c instanceof Deque) {
            return ((Deque) c).descendingIterator().next();
        } else {
            try {
                Method m = null;

                if ((m = ClassUtil.getDeclaredMethod(c.getClass(), "descendingIterator")) != null && Modifier.isPublic(m.getModifiers())
                        && Iterator.class.isAssignableFrom(m.getReturnType())) {

                    final Iterator iter = ClassUtil.invokeMethod(c, m);

                    return iter.next();
                }
            } catch (Exception e2) {
                // continue
            }

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

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

            return e;
        }
    }

    /**
     * Last or default if empty.
     *
     * @param 
     * @param iter
     * @param defaultValueForEmpty
     * @return
     */
    public static  T lastOrDefaultIfEmpty(final Iterator iter, final T defaultValueForEmpty) {
        if (iter == null || !iter.hasNext()) {
            return defaultValueForEmpty;
        }

        T e = null;

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

        return e;
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @param predicate
     * @return the nullable
     * @throws E the e
     */
    public static  Nullable findFirst(final T[] a, final Throwables.Predicate predicate) throws E {
        if (N.isNullOrEmpty(a)) {
            return Nullable.empty();
        }

        for (T element : a) {
            if (predicate.test(element)) {
                return Nullable.of(element);
            }
        }

        return Nullable.empty();
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @param predicate
     * @return the nullable
     * @throws E the e
     */
    public static  Nullable findFirst(final Collection c, Throwables.Predicate predicate) throws E {
        if (N.isNullOrEmpty(c)) {
            return Nullable.empty();
        }

        for (T e : c) {
            if (predicate.test(e)) {
                return Nullable.of(e);
            }
        }

        return Nullable.empty();
    }

    /**
     *
     * @param 
     * @param 
     * @param iter
     * @param predicate
     * @return
     * @throws E
     */
    public static  Nullable findFirst(final Iterator iter, Throwables.Predicate predicate) throws E {
        if (iter == null) {
            return Nullable.empty();
        }

        T next = null;

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

            if (predicate.test(next)) {
                return Nullable.of(next);
            }
        }

        return Nullable.empty();
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @param predicate
     * @return the nullable
     * @throws E the e
     */
    public static  Nullable findLast(final T[] a, final Throwables.Predicate predicate) throws E {
        if (N.isNullOrEmpty(a)) {
            return Nullable.empty();
        }

        for (int len = a.length, i = len - 1; i >= 0; i--) {
            if (predicate.test(a[i])) {
                return Nullable.of(a[i]);
            }
        }

        return Nullable.empty();
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @param predicate
     * @return the nullable
     * @throws E the e
     */
    public static  Nullable findLast(final Collection c, Throwables.Predicate predicate) throws E {
        return (Nullable) findLast(c, predicate, false);
    }

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param c
     * @param predicate
     * @param isForNonNull
     * @return the r
     * @throws E the e
     */
    private static  Object findLast(final Collection c, Throwables.Predicate predicate, boolean isForNonNull)
            throws E {
        if (N.isNullOrEmpty(c)) {
            return isForNonNull ? Optional.empty() : Nullable.empty();
        }

        T e = null;

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

            if (c instanceof RandomAccess) {
                for (int i = c.size() - 1; i >= 0; i--) {
                    e = list.get(i);

                    if ((!isForNonNull || e != null) && predicate.test(e)) {
                        return isForNonNull ? Optional.of(e) : Nullable.of(e);
                    }
                }
            } else {
                final ListIterator iter = list.listIterator(list.size());

                while (iter.hasPrevious()) {
                    e = iter.previous();

                    if ((!isForNonNull || e != null) && predicate.test(e)) {
                        return isForNonNull ? Optional.of(e) : Nullable.of(e);
                    }
                }
            }

            return isForNonNull ? Optional.empty() : Nullable.empty();
        } else if (c instanceof Deque) {
            final Iterator iter = ((Deque) c).descendingIterator();

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

                if ((!isForNonNull || e != null) && predicate.test(e)) {
                    return isForNonNull ? Optional.of(e) : Nullable.of(e);
                }
            }

            return isForNonNull ? Optional.empty() : Nullable.empty();
        } else {
            try {
                Method m = null;

                if ((m = ClassUtil.getDeclaredMethod(c.getClass(), "descendingIterator")) != null && Modifier.isPublic(m.getModifiers())
                        && Iterator.class.isAssignableFrom(m.getReturnType())) {

                    final Iterator iter = ClassUtil.invokeMethod(c, m);

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

                        if ((!isForNonNull || e != null) && predicate.test(e)) {
                            return isForNonNull ? Optional.of(e) : Nullable.of(e);
                        }
                    }

                    return isForNonNull ? Optional.empty() : Nullable.empty();
                }
            } catch (Exception e2) {
                // continue
            }

            final T[] a = (T[]) c.toArray();

            for (int i = a.length - 1; i >= 0; i--) {
                if ((!isForNonNull || a[i] != null) && predicate.test(a[i])) {
                    return isForNonNull ? Optional.of(a[i]) : Nullable.of(a[i]);
                }
            }

            return isForNonNull ? Optional.empty() : Nullable.empty();
        }
    }

    /**
     * Find first non null.
     *
     * @param 
     * @param 
     * @param a
     * @param predicate
     * @return the optional
     * @throws E the e
     */
    public static  Optional findFirstNonNull(final T[] a, final Throwables.Predicate predicate) throws E {
        if (N.isNullOrEmpty(a)) {
            return Optional.empty();
        }

        for (T element : a) {
            if (element != null && predicate.test(element)) {
                return Optional.of(element);
            }
        }

        return Optional.empty();
    }

    /**
     * Find first non null.
     *
     * @param 
     * @param 
     * @param c
     * @param predicate
     * @return the optional
     * @throws E the e
     */
    public static  Optional findFirstNonNull(final Collection c, Throwables.Predicate predicate)
            throws E {
        if (N.isNullOrEmpty(c)) {
            return Optional.empty();
        }

        for (T e : c) {
            if (e != null && predicate.test(e)) {
                return Optional.of(e);
            }
        }

        return Optional.empty();
    }

    /**
     *
     * @param 
     * @param 
     * @param iter
     * @param predicate
     * @return
     * @throws E
     */
    public static  Optional findFirstNonNull(final Iterator iter, Throwables.Predicate predicate)
            throws E {
        if (iter == null) {
            return Optional.empty();
        }

        T next = null;

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

            if (next != null && predicate.test(next)) {
                return Optional.of(next);
            }
        }

        return Optional.empty();
    }

    /**
     * Find last non null.
     *
     * @param 
     * @param 
     * @param a
     * @param predicate
     * @return the optional
     * @throws E the e
     */
    public static  Optional findLastNonNull(final T[] a, final Throwables.Predicate predicate) throws E {
        if (N.isNullOrEmpty(a)) {
            return Optional.empty();
        }

        for (int len = a.length, i = len - 1; i >= 0; i--) {
            if (a[i] != null && predicate.test(a[i])) {
                return Optional.of(a[i]);
            }
        }

        return Optional.empty();
    }

    /**
     * Find last non null.
     *
     * @param 
     * @param 
     * @param c
     * @param predicate
     * @return the optional
     * @throws E the e
     */
    public static  Optional findLastNonNull(final Collection c, Throwables.Predicate predicate) throws E {
        return (Optional) findLast(c, predicate, true);
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param s
     * @return
     */
    public static int len(final CharSequence s) {
        return s == null ? 0 : s.length();
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param a
     * @return
     */
    public static int len(final boolean[] a) {
        return a == null ? 0 : a.length;
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param a
     * @return
     */
    public static int len(final char[] a) {
        return a == null ? 0 : a.length;
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param a
     * @return
     */
    public static int len(final byte[] a) {
        return a == null ? 0 : a.length;
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param a
     * @return
     */
    public static int len(final short[] a) {
        return a == null ? 0 : a.length;
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param a
     * @return
     */
    public static int len(final int[] a) {
        return a == null ? 0 : a.length;
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param a
     * @return
     */
    public static int len(final long[] a) {
        return a == null ? 0 : a.length;
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param a
     * @return
     */
    public static int len(final float[] a) {
        return a == null ? 0 : a.length;
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param a
     * @return
     */
    public static int len(final double[] a) {
        return a == null ? 0 : a.length;
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param a
     * @return
     */
    public static int len(final Object[] a) {
        return a == null ? 0 : a.length;
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param c
     * @return
     */
    public static int size(final Collection c) {
        return c == null ? 0 : c.size();
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param m
     * @return
     */
    public static int size(final Map m) {
        return m == null ? 0 : m.size();
    }

    /**
     * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}.
     *
     * @param c
     * @return
     */
    @Beta
    @SuppressWarnings("rawtypes")
    public static int size(final PrimitiveList c) {
        return c == null ? 0 : c.size();
    }

    /**
     * Returns an immutable empty list if the specified List is null, otherwise itself is returned.
     *
     * @param 
     * @param list
     * @return
     * @see #emptyList()
     */
    public static  List nullToEmpty(final List list) {
        return list == null ? emptyList() : list;
    }

    /**
     * Returns an immutable empty set if the specified Set is null, otherwise itself is returned.
     *
     * @param 
     * @param set
     * @return
     * @see #emptySet()
     */
    public static  Set nullToEmpty(final Set set) {
        return set == null ? emptySet() : set;
    }

    /**
     * Returns an immutable empty SortedSet if the specified SortedSet is null, otherwise itself is returned.
     *
     * @param 
     * @param set
     * @return
     * @see #emptySortedSet()
     */
    public static  SortedSet nullToEmpty(final SortedSet set) {
        return set == null ? emptySortedSet() : set;
    }

    /**
     * Returns an immutable empty NavigableSet if the specified NavigableSet is null, otherwise itself is returned.
     *
     * @param 
     * @param set
     * @return
     * @see #emptyNavigableSet()
     */
    public static  NavigableSet nullToEmpty(final NavigableSet set) {
        return set == null ? emptyNavigableSet() : set;
    }

    /**
     * Returns an immutable empty map if the specified Map is null, otherwise itself is returned.
     *
     * @param  the key type
     * @param  the value type
     * @param map
     * @return
     * @see #emptyMap()
     */
    public static  Map nullToEmpty(final Map map) {
        return map == null ? emptyMap() : map;
    }

    /**
     * Returns an immutable empty SortedMap if the specified SortedMap is null, otherwise itself is returned.
     *
     * @param  the key type
     * @param  the value type
     * @param map
     * @return
     * @see #emptySortedMap()
     */
    public static  SortedMap nullToEmpty(final SortedMap map) {
        return map == null ? emptySortedMap() : map;
    }

    /**
     * Returns an immutable empty NavigableMap if the specified NavigableMap is null, otherwise itself is returned.
     *
     * @param  the key type
     * @param  the value type
     * @param map
     * @return
     * @see #emptyNavigableMap()
     */
    public static  NavigableMap nullToEmpty(final NavigableMap map) {
        return map == null ? emptyNavigableMap() : map;
    }

    /**
     * Returns an immutable empty Iterator if the specified Iterator is null, otherwise itself is returned.
     *
     * @param 
     * @param iter
     * @return
     * @see #emptyIterator()
     */
    public static  Iterator nullToEmpty(final Iterator iter) {
        return iter == null ? emptyIterator() : iter;
    }

    /**
     * Returns an immutable empty ListIterator if the specified ListIterator is null, otherwise itself is returned.
     *
     * @param 
     * @param iter
     * @return
     * @see #emptyListIterator()
     */
    public static  ListIterator nullToEmpty(final ListIterator iter) {
        return iter == null ? emptyListIterator() : iter;
    }

    /**
     * Null to empty.
     *
     * @param str
     * @return
     */
    public static String nullToEmpty(final String str) {
        return str == null ? EMPTY_STRING : str;
    }

    /**
     * Null to empty.
     *
     * @param a
     * @return
     */
    public static boolean[] nullToEmpty(final boolean[] a) {
        return a == null ? EMPTY_BOOLEAN_ARRAY : a;
    }

    /**
     * Null to empty.
     *
     * @param a
     * @return
     */
    public static char[] nullToEmpty(final char[] a) {
        return a == null ? EMPTY_CHAR_ARRAY : a;
    }

    /**
     * Null to empty.
     *
     * @param a
     * @return
     */
    public static byte[] nullToEmpty(final byte[] a) {
        return a == null ? EMPTY_BYTE_ARRAY : a;
    }

    /**
     * Null to empty.
     *
     * @param a
     * @return
     */
    public static short[] nullToEmpty(final short[] a) {
        return a == null ? EMPTY_SHORT_ARRAY : a;
    }

    /**
     * Null to empty.
     *
     * @param a
     * @return
     */
    public static int[] nullToEmpty(final int[] a) {
        return a == null ? EMPTY_INT_ARRAY : a;
    }

    /**
     * Null to empty.
     *
     * @param a
     * @return
     */
    public static long[] nullToEmpty(final long[] a) {
        return a == null ? EMPTY_LONG_ARRAY : a;
    }

    /**
     * Null to empty.
     *
     * @param a
     * @return
     */
    public static float[] nullToEmpty(final float[] a) {
        return a == null ? EMPTY_FLOAT_ARRAY : a;
    }

    /**
     * Null to empty.
     *
     * @param a
     * @return
     */
    public static double[] nullToEmpty(final double[] a) {
        return a == null ? EMPTY_DOUBLE_ARRAY : a;
    }

    /**
     * Null to empty.
     *
     * @param a
     * @return
     */
    public static String[] nullToEmpty(final String[] a) {
        return a == null ? EMPTY_STRING_ARRAY : a;
    }

    /**
     * Null to empty.
     *
     * @param a
     * @return
     * @deprecated replaced by {@link nullToEmpty(Object[], Class)}
     */
    @Deprecated
    public static Object[] nullToEmpty(final Object[] a) {
        return a == null ? EMPTY_OBJECT_ARRAY : a;
    }

    //    /**
    //     * Null to empty.
    //     *
    //     * @param 
    //     * @param arrayType
    //     * @param a
    //     * @return
    //     * @deprecated replaced by {@link nullToEmpty(Object[], Class)}
    //     */
    //    @Deprecated
    //    public static  T[] nullToEmpty(final Class arrayType, final T[] a) {
    //        return a == null ? (T[]) newArray(arrayType.getComponentType(), 0) : a;
    //    }

    /**
     * Null to empty.
     *
     * @param 
     * @param a
     * @param arrayType
     * @return
     */
    public static  T[] nullToEmpty(final T[] a, final Class arrayType) {
        return a == null ? (T[]) newArray(arrayType.getComponentType(), 0) : a;
    }

    /**
     * Returns an immutable empty Collection if the specified ImmutableCollection is null, otherwise itself is returned.
     *
     * @param 
     * @param c
     * @return
     */
    public static  ImmutableCollection nullToEmpty(final ImmutableCollection c) {
        return c == null ? ImmutableList. empty() : c;
    }

    /**
     * Returns an immutable empty list if the specified ImmutableList is null, otherwise itself is returned.
     *
     * @param 
     * @param list
     * @return
     */
    public static  ImmutableList nullToEmpty(final ImmutableList list) {
        return list == null ? ImmutableList. empty() : list;
    }

    /**
     * Returns an immutable empty list if the specified ImmutableSet is null, otherwise itself is returned.
     *
     * @param 
     * @param set
     * @return
     */
    public static  ImmutableSet nullToEmpty(final ImmutableSet set) {
        return set == null ? ImmutableSet. empty() : set;
    }

    /**
     * Returns an immutable empty list if the specified ImmutableSortedSet is null, otherwise itself is returned.
     *
     * @param 
     * @param set
     * @return
     */
    public static  ImmutableSortedSet nullToEmpty(final ImmutableSortedSet set) {
        return set == null ? ImmutableSortedSet. empty() : set;
    }

    /**
     * Returns an immutable empty list if the specified ImmutableNavigableSet is null, otherwise itself is returned.
     *
     * @param 
     * @param set
     * @return
     */
    public static  ImmutableNavigableSet nullToEmpty(final ImmutableNavigableSet set) {
        return set == null ? ImmutableNavigableSet. empty() : set;
    }

    /**
     * Returns an immutable empty map if the specified ImmutableMap is null, otherwise itself is returned.
     *
     * @param  the key type
     * @param  the value type
     * @param map
     * @return
     */
    public static  ImmutableMap nullToEmpty(final ImmutableMap map) {
        return map == null ? ImmutableMap. empty() : map;
    }

    /**
     * Returns an immutable empty map if the specified ImmutableSortedMap is null, otherwise itself is returned.
     *
     * @param  the key type
     * @param  the value type
     * @param map
     * @return
     */
    public static  ImmutableSortedMap nullToEmpty(final ImmutableSortedMap map) {
        return map == null ? ImmutableSortedMap. empty() : map;
    }

    /**
     * Returns an immutable empty map if the specified ImmutableNavigableMap is null, otherwise itself is returned.
     *
     * @param  the key type
     * @param  the value type
     * @param map
     * @return
     */
    public static  ImmutableNavigableMap nullToEmpty(final ImmutableNavigableMap map) {
        return map == null ? ImmutableNavigableMap. empty() : map;
    }

    /**
     * Returns an immutable empty map if the specified ImmutableBiMap is null, otherwise itself is returned.
     *
     * @param  the key type
     * @param  the value type
     * @param map
     * @return
     */
    public static  ImmutableBiMap nullToEmpty(final ImmutableBiMap map) {
        return map == null ? ImmutableBiMap. empty() : map;
    }

    //    /**
    //     * Checks if is null or default. {@code null} is default value for all reference types, {@code false} is default value for primitive boolean, {@code 0} is the default value for primitive number type.
    //     *
    //     * @param s
    //     * @return true, if is null or default
    //     * @deprecated internal only
    //     */
    //    @Deprecated
    //    @Internal
    //    @Beta
    //    static boolean isNullOrDefault(final Object value) {
    //        return (value == null) || equals(value, defaultValueOf(value.getClass()));
    //    }

    /**
     * Checks if is null or empty.
     *
     * @param s
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final CharSequence s) {
        return (s == null) || (s.length() == 0);
    }

    /**
     * Checks if is null or empty.
     *
     * @param a
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final boolean[] a) {
        return (a == null) || (a.length == 0);
    }

    /**
     * Checks if is null or empty.
     *
     * @param a
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final char[] a) {
        return (a == null) || (a.length == 0);
    }

    /**
     * Checks if is null or empty.
     *
     * @param a
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final byte[] a) {
        return (a == null) || (a.length == 0);
    }

    /**
     * Checks if is null or empty.
     *
     * @param a
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final short[] a) {
        return (a == null) || (a.length == 0);
    }

    /**
     * Checks if is null or empty.
     *
     * @param a
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final int[] a) {
        return (a == null) || (a.length == 0);
    }

    /**
     * Checks if is null or empty.
     *
     * @param a
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final long[] a) {
        return (a == null) || (a.length == 0);
    }

    /**
     * Checks if is null or empty.
     *
     * @param a
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final float[] a) {
        return (a == null) || (a.length == 0);
    }

    /**
     * Checks if is null or empty.
     *
     * @param a
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final double[] a) {
        return (a == null) || (a.length == 0);
    }

    /**
     * Checks if is null or empty.
     *
     * @param a
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final Object[] a) {
        return (a == null) || (a.length == 0);
    }

    /**
     * Checks if is null or empty.
     *
     * @param c
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final Collection c) {
        return (c == null) || (c.isEmpty());
    }

    /**
     * Not null or empty.
     *
     * @param iter
     * @return
     */
    @Beta
    public static boolean isNullOrEmpty(final Iterable iter) {
        if (iter == null) {
            return true;
        }

        if (iter instanceof Collection) {
            return isNullOrEmpty((Collection) iter);
        } else {
            return isNullOrEmpty(iter.iterator());
        }
    }

    /**
     * Not null or empty.
     *
     * @param iter
     * @return
     */
    @Beta
    public static boolean isNullOrEmpty(final Iterator iter) {
        return iter == null || (iter.hasNext() == false);
    }

    /**
     * Checks if is null or empty.
     *
     * @param m
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final Map m) {
        return (m == null) || (m.isEmpty());
    }

    /**
     * Checks if is null or empty.
     *
     * @param list
     * @return true, if is null or empty
     */
    @SuppressWarnings("rawtypes")
    public static boolean isNullOrEmpty(final PrimitiveList list) {
        return (list == null) || (list.isEmpty());
    }

    /**
     * Checks if is null or empty.
     *
     * @param s
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final Multiset s) {
        return (s == null) || (s.isEmpty());
    }

    /**
     * Checks if is null or empty.
     *
     * @param s
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final LongMultiset s) {
        return (s == null) || (s.isEmpty());
    }

    /**
     * Checks if is null or empty.
     *
     * @param m
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final Multimap m) {
        return (m == null) || (m.isEmpty());
    }

    /**
     * Checks if is null or empty.
     *
     * @param rs
     * @return true, if is null or empty
     */
    public static boolean isNullOrEmpty(final DataSet rs) {
        return (rs == null) || (rs.isEmpty());
    }

    /**
     * Note: Copied from Commons-Lang under Apache License v2.
     * 

     * 
Checks if a CharSequence is {@code null}, empty ("") or whitespace only.

     *
     * 
Whitespace is defined by {@link Character#isWhitespace(char)}.

     *
     * 
     * StringUtils.isBlank(null)      = true
     * StringUtils.isBlank("")        = true
     * StringUtils.isBlank(" ")       = true
     * StringUtils.isBlank("bob")     = false
     * StringUtils.isBlank("  bob  ") = false
     * 

     *
     * @param cs  the CharSequence to check, may be null
     * @return {@code true} if the CharSequence is null, empty or whitespace only
     * @see #notBlank(CharSequence)
     * @see #checkArgNotBlank(CharSequence, String)
     */
    // DON'T change 'OrEmptyOrBlank' to 'OrBlank' because of the occurring order in the auto-completed context menu.
    public static boolean isBlank(final CharSequence cs) {
        if (isNullOrEmpty(cs)) {
            return true;
        }

        for (int i = 0, len = cs.length(); i < len; i++) {
            if (!Character.isWhitespace(cs.charAt(i))) {
                return false;
            }
        }

        return true;
    }

    /**
     * Not null or empty.
     *
     * @param s
     * @return
     */
    public static boolean notNullOrEmpty(final CharSequence s) {
        return (s != null) && (s.length() > 0);
    }

    /**
     * Not null or empty.
     *
     * @param a
     * @return
     */
    public static boolean notNullOrEmpty(final boolean[] a) {
        return (a != null) && (a.length > 0);
    }

    /**
     * Not null or empty.
     *
     * @param a
     * @return
     */
    public static boolean notNullOrEmpty(final char[] a) {
        return (a != null) && (a.length > 0);
    }

    /**
     * Not null or empty.
     *
     * @param a
     * @return
     */
    public static boolean notNullOrEmpty(final byte[] a) {
        return (a != null) && (a.length > 0);
    }

    /**
     * Not null or empty.
     *
     * @param a
     * @return
     */
    public static boolean notNullOrEmpty(final short[] a) {
        return (a != null) && (a.length > 0);
    }

    /**
     * Not null or empty.
     *
     * @param a
     * @return
     */
    public static boolean notNullOrEmpty(final int[] a) {
        return (a != null) && (a.length > 0);
    }

    /**
     * Not null or empty.
     *
     * @param a
     * @return
     */
    public static boolean notNullOrEmpty(final long[] a) {
        return (a != null) && (a.length > 0);
    }

    /**
     * Not null or empty.
     *
     * @param a
     * @return
     */
    public static boolean notNullOrEmpty(final float[] a) {
        return (a != null) && (a.length > 0);
    }

    /**
     * Not null or empty.
     *
     * @param a
     * @return
     */
    public static boolean notNullOrEmpty(final double[] a) {
        return (a != null) && (a.length > 0);
    }

    /**
     * Not null or empty.
     *
     * @param a
     * @return
     */
    public static boolean notNullOrEmpty(final Object[] a) {
        return (a != null) && (a.length > 0);
    }

    /**
     * Not null or empty.
     *
     * @param c
     * @return
     */
    public static boolean notNullOrEmpty(final Collection c) {
        return (c != null) && (c.size() > 0);
    }

    /**
     * Not null or empty.
     *
     * @param iter
     * @return
     */
    @Beta
    public static boolean notNullOrEmpty(final Iterable iter) {
        if (iter == null) {
            return false;
        }

        if (iter instanceof Collection) {
            return notNullOrEmpty((Collection) iter);
        } else {
            return notNullOrEmpty(iter.iterator());
        }
    }

    /**
     * Not null or empty.
     *
     * @param iter
     * @return
     */
    @Beta
    public static boolean notNullOrEmpty(final Iterator iter) {
        return (iter != null) && (iter.hasNext());
    }

    /**
     * Not null or empty.
     *
     * @param m
     * @return
     */
    public static boolean notNullOrEmpty(final Map m) {
        return (m != null) && (m.size() > 0);
    }

    /**
     * Not null or empty.
     *
     * @param list
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static boolean notNullOrEmpty(final PrimitiveList list) {
        return (list != null) && (list.size() > 0);
    }

    /**
     * Not null or empty.
     *
     * @param s
     * @return
     */
    public static boolean notNullOrEmpty(final Multiset s) {
        return (s != null) && (s.size() > 0);
    }

    /**
     * Not null or empty.
     *
     * @param s
     * @return
     */
    public static boolean notNullOrEmpty(final LongMultiset s) {
        return (s != null) && (s.size() > 0);
    }

    /**
     * Not null or empty.
     *
     * @param m
     * @return
     */
    public static boolean notNullOrEmpty(final Multimap m) {
        return (m != null) && (m.size() > 0);
    }

    /**
     * Not null or empty.
     *
     * @param rs
     * @return
     */
    public static boolean notNullOrEmpty(final DataSet rs) {
        return (rs != null) && (rs.size() > 0);
    }

    /**
     * Note: Copied from Commons-Lang under Apache License v2.
     * 

     * 
Checks if a CharSequence is NOT {@code null}, empty ("") or whitespace only.

     *
     * 
Whitespace is defined by {@link Character#isWhitespace(char)}.

     *
     * 
     * StringUtils.notBlank(null)      = false
     * StringUtils.notBlank("")        = false
     * StringUtils.notBlank(" ")       = false
     * StringUtils.notBlank("bob")     = true
     * StringUtils.notBlank("  bob  ") = true
     * 

     *
     * @param cs  the CharSequence to check, may be null
     * @return {@code true} if the CharSequence is not {@code null}, empty ("") or whitespace only.
     * @see #isBlank(CharSequence)
     * @see #checkArgNotBlank(CharSequence, String)
     */
    // DON'T change 'OrEmptyOrBlank' to 'OrBlank' because of the occurring order in the auto-completed context menu.
    public static boolean notBlank(final CharSequence cs) {
        return !isBlank(cs);
    }

    /**
     *
     * @param index
     * @param length
     * @throws IndexOutOfBoundsException the index out of bounds exception
     */
    public static void checkIndex(final int index, final int length) throws IndexOutOfBoundsException {
        if (index < 0 || index >= length) {
            throw new IndexOutOfBoundsException("Index " + index + " is out-of-bounds for length " + length);
        }
    }

    /**
     * Check from to index.
     *
     * @param fromIndex
     * @param toIndex
     * @param length
     * @throws IndexOutOfBoundsException the index out of bounds exception
     */
    public static void checkFromToIndex(final int fromIndex, final int toIndex, final int length) throws IndexOutOfBoundsException {
        if (fromIndex < 0 || fromIndex > toIndex || toIndex > length) {
            throw new IndexOutOfBoundsException("Index range [" + fromIndex + ", " + toIndex + "] is out-of-bounds for length " + length);
        }
    }

    /**
     * Check from index size.
     *
     * @param fromIndex the lower-bound (inclusive) of the sub-interval
     * @param size the size of the sub-range
     * @param length the upper-bound (exclusive) of the range
     * @throws IndexOutOfBoundsException the index out of bounds exception
     */
    public static void checkFromIndexSize(final int fromIndex, final int size, final int length) throws IndexOutOfBoundsException {
        if ((fromIndex < 0 || size < 0 || length < 0) || size > length - fromIndex) {
            throw new IndexOutOfBoundsException("Start Index " + fromIndex + " with size " + size + " is out-of-bounds for length " + length);
        }
    }

    /**
     * Check arg not null.
     *
     * @param 
     * @param obj
     * @return
     * @throws IllegalArgumentException if {@code obj} is {@code null}
     */
    public static  T checkArgNotNull(final T obj) {
        if (obj == null) {
            throw new IllegalArgumentException();
        }

        return obj;
    }

    /**
     * Check arg not null.
     *
     * @param 
     * @param obj
     * @param errorMessage
     * @return
     * @throws IllegalArgumentException if {@code obj} is {@code null}
     */
    public static  T checkArgNotNull(final T obj, final String errorMessage) {
        if (obj == null) {
            if (isArgNameOnly(errorMessage)) {
                throw new IllegalArgumentException("'" + errorMessage + "' can not be null");
            } else {
                throw new IllegalArgumentException(errorMessage);
            }
        }

        return obj;
    }

    private static boolean isArgNameOnly(final String argNameOrErrorMsg) {
        // shortest message: "it is null"
        return !(argNameOrErrorMsg.length() > 9 && argNameOrErrorMsg.indexOf(WD._SPACE) > 0); //NOSONAR
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static  T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static boolean[] checkArgNotNullOrEmpty(final boolean[] arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static char[] checkArgNotNullOrEmpty(final char[] arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static byte[] checkArgNotNullOrEmpty(final byte[] arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static short[] checkArgNotNullOrEmpty(final short[] arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static int[] checkArgNotNullOrEmpty(final int[] arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static long[] checkArgNotNullOrEmpty(final long[] arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static float[] checkArgNotNullOrEmpty(final float[] arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static double[] checkArgNotNullOrEmpty(final double[] arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static  T[] checkArgNotNullOrEmpty(final T[] arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static > T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    @Beta
    public static > T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    @Beta
    public static > T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static > T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static > T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static  Multiset checkArgNotNullOrEmpty(final Multiset arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static  LongMultiset checkArgNotNullOrEmpty(final LongMultiset arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static > T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is.
     *
     * @param 
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty.
     */
    public static  T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) {
        if (isNullOrEmpty(arg)) {
            throwIllegalArgumentExceptionForNllOrEmptyCheck(argNameOrErrorMsg);
        }

        return arg;
    }

    private static void throwIllegalArgumentExceptionForNllOrEmptyCheck(final String errorMessage) {
        if (isArgNameOnly(errorMessage)) {
            throw new IllegalArgumentException("'" + errorMessage + "' can not be null or empty");
        } else {
            throw new IllegalArgumentException(errorMessage);
        }
    }

    /**
     * 
Checks if a CharSequence is NOT {@code null}, empty ("") or whitespace only.

     *
     * @param 
     * @param arg
     * @param msg name of parameter or error message
     * @return
     * @throws IllegalArgumentException if the specified parameter is {@code null}, empty ("") or whitespace only.
     * @see #isBlank(CharSequence)
     * @see #notBlank(CharSequence)
     */
    // DON'T change 'OrEmptyOrBlank' to 'OrBlank' because of the occurring order in the auto-completed context menu.
    public static  T checkArgNotBlank(final T arg, final String msg) {
        if (isBlank(arg)) {
            if (isArgNameOnly(msg)) {
                throw new IllegalArgumentException("'" + msg + "' can not be null or empty or blank");
            } else {
                throw new IllegalArgumentException(msg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is not negative, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static byte checkArgNotNegative(final byte arg, final String argNameOrErrorMsg) {
        if (arg < 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be negative: " + arg); //NOSONAR
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is not negative, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static short checkArgNotNegative(final short arg, final String argNameOrErrorMsg) {
        if (arg < 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be negative: " + arg); //NOSONAR
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is not negative, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static int checkArgNotNegative(final int arg, final String argNameOrErrorMsg) {
        if (arg < 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be negative: " + arg); //NOSONAR
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is not negative, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static long checkArgNotNegative(final long arg, final String argNameOrErrorMsg) {
        if (arg < 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be negative: " + arg);
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is not negative, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static float checkArgNotNegative(final float arg, final String argNameOrErrorMsg) {
        if (arg < 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be negative: " + arg);
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is not negative, and throws {@code IllegalArgumentException} if it is.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static double checkArgNotNegative(final double arg, final String argNameOrErrorMsg) {
        if (arg < 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be negative: " + arg);
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is positive, and throws {@code IllegalArgumentException} if it is not.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static byte checkArgPositive(final byte arg, final String argNameOrErrorMsg) {
        if (arg <= 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be zero or negative: " + arg);
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is positive, and throws {@code IllegalArgumentException} if it is not.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static short checkArgPositive(final short arg, final String argNameOrErrorMsg) {
        if (arg <= 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be zero or negative: " + arg);
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is positive, and throws {@code IllegalArgumentException} if it is not.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static int checkArgPositive(final int arg, final String argNameOrErrorMsg) {
        if (arg <= 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be zero or negative: " + arg);
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is positive, and throws {@code IllegalArgumentException} if it is not.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static long checkArgPositive(final long arg, final String argNameOrErrorMsg) {
        if (arg <= 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be zero or negative: " + arg);
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is positive, and throws {@code IllegalArgumentException} if it is not.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static float checkArgPositive(final float arg, final String argNameOrErrorMsg) {
        if (arg <= 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be zero or negative: " + arg);
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Checks if the specified {@code arg} is positive, and throws {@code IllegalArgumentException} if it is not.
     *
     * @param arg
     * @param argNameOrErrorMsg
     * @return
     * @throws IllegalArgumentException if the specified {@code arg} is negative.
     */
    public static double checkArgPositive(final double arg, final String argNameOrErrorMsg) {
        if (arg <= 0) {
            if (isArgNameOnly(argNameOrErrorMsg)) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be zero or negative: " + arg);
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }

    /**
     * Check if the specified {@code Array} contains any {@code null} element.
     *
     * @param a
     * @throws IllegalArgumentException if {@code null} element found in {@code a}
     */
    public static void checkElementNotNull(final Object[] a) {
        if (N.isNullOrEmpty(a)) {
            return;
        }

        for (Object e : a) {
            if (e == null) {
                throw new IllegalArgumentException("null element is found in collection");
            }
        }
    }

    /**
     * Check if the specified {@code Array} contains any {@code null} element.
     *
     * @param a
     * @param argNameOrErrorMsg
     * @throws IllegalArgumentException if {@code null} element found in {@code a}
     */
    public static void checkElementNotNull(final Object[] a, final String argNameOrErrorMsg) {
        if (N.isNullOrEmpty(a)) {
            return;
        }

        for (Object e : a) {
            if (e == null) {
                if (isArgNameOnly(argNameOrErrorMsg)) {
                    throw new IllegalArgumentException("null element is found in " + argNameOrErrorMsg);
                } else {
                    throw new IllegalArgumentException(argNameOrErrorMsg);
                }
            }
        }
    }

    /**
     * Check if the specified {@code Collection} contains any {@code null} element.
     *
     * @param c
     * @throws IllegalArgumentException if {@code null} element found in {@code c}
     */
    public static void checkElementNotNull(final Collection c) {
        if (N.isNullOrEmpty(c)) {
            return;
        }

        for (Object e : c) {
            if (e == null) {
                throw new IllegalArgumentException("null element is found in collection");
            }
        }
    }

    /**
     * Check if the specified {@code Collection} contains any {@code null} element.
     *
     * @param c
     * @param argNameOrErrorMsg
     * @throws IllegalArgumentException if {@code null} element found in {@code c}
     */
    public static void checkElementNotNull(final Collection c, final String argNameOrErrorMsg) {
        if (N.isNullOrEmpty(c)) {
            return;
        }

        for (Object e : c) {
            if (e == null) {
                if (isArgNameOnly(argNameOrErrorMsg)) {
                    throw new IllegalArgumentException("null element is found in " + argNameOrErrorMsg);
                } else {
                    throw new IllegalArgumentException(argNameOrErrorMsg);
                }
            }
        }
    }

    /**
     * Check if the specified {@code Map} contains any {@code null} key.
     *
     * @param m
     * @throws IllegalArgumentException if {@code null} key found in {@code m}
     */
    public static void checkKeyNotNull(final Map m) {
        if (N.isNullOrEmpty(m)) {
            return;
        }

        for (Object e : m.keySet()) {
            if (e == null) {
                throw new IllegalArgumentException("null key is found in Map");
            }
        }
    }

    /**
     * Check if the specified {@code Map} contains any {@code null} key.
     *
     * @param m
     * @param argNameOrErrorMsg
     * @throws IllegalArgumentException if {@code null} key found in {@code m}
     */
    public static void checkKeyNotNull(final Map m, final String argNameOrErrorMsg) {
        if (N.isNullOrEmpty(m)) {
            return;
        }

        for (Object e : m.keySet()) {
            if (e == null) {
                if (isArgNameOnly(argNameOrErrorMsg)) {
                    throw new IllegalArgumentException("null key is found in " + argNameOrErrorMsg);
                } else {
                    throw new IllegalArgumentException(argNameOrErrorMsg);
                }
            }
        }
    }

    /**
     * Check if the specified {@code Map} contains any {@code null} value.
     *
     * @param m
     * @throws IllegalArgumentException if {@code null} value found in {@code m}
     */
    public static void checkValueNotNull(final Map m) {
        if (N.isNullOrEmpty(m)) {
            return;
        }

        for (Object e : m.values()) {
            if (e == null) {
                throw new IllegalArgumentException("null value is found in Map");
            }
        }
    }

    /**
     * Check if the specified {@code Map} contains any {@code null} value.
     *
     * @param m
     * @param argNameOrErrorMsg
     * @throws IllegalArgumentException if {@code null} value found in {@code m}
     */
    public static void checkValueNotNull(final Map m, final String argNameOrErrorMsg) {
        if (N.isNullOrEmpty(m)) {
            return;
        }

        for (Object e : m.values()) {
            if (e == null) {
                if (isArgNameOnly(argNameOrErrorMsg)) {
                    throw new IllegalArgumentException("null value is found in " + argNameOrErrorMsg);
                } else {
                    throw new IllegalArgumentException(argNameOrErrorMsg);
                }
            }
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * @param expression a boolean expression
     * @throws IllegalArgumentException if {@code expression} is false
     */
    public static void checkArgument(boolean expression) {
        if (!expression) {
            throw new IllegalArgumentException();
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * @param expression a boolean expression
     * @param errorMessage the exception message to use if the check fails; will be converted to a
     *     string using {@link String#valueOf(Object)}
     * @throws IllegalArgumentException if {@code expression} is false
     */
    public static void checkArgument(boolean expression, String errorMessage) {
        if (!expression) {
            throw new IllegalArgumentException(errorMessage);
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, boolean p) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, boolean p1, boolean p2) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, boolean p1, boolean p2, boolean p3) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, char p) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, byte p) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, short p) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, int p) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, int p1, int p2) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, int p1, int p2, int p3) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, long p) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, long p1, long p2) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, long p1, long p2, long p3) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, float p) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, float p1, float p2) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, float p1, float p2, float p3) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, double p) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, double p1, double p2) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, double p1, double p2, double p3) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, Object p) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, Object p1, Object p2) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving one or more parameters to the calling method.
     *
     * 
See {@link #checkArgument(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkArgument(boolean b, String errorMessageTemplate, Object p1, Object p2, Object p3) {
        if (!b) {
            throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     *
     *
     * @param b
     * @param errorMessageSupplier
     */
    public static void checkArgument(boolean b, Supplier errorMessageSupplier) {
        if (!b) {
            throw new IllegalArgumentException(errorMessageSupplier.get());
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * @param expression a boolean expression
     * @throws IllegalStateException if {@code expression} is false
     */
    public static void checkState(boolean expression) {
        if (!expression) {
            throw new IllegalStateException();
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * @param expression a boolean expression
     * @param errorMessage the exception message to use if the check fails; will be converted to a
     *     string using {@link String#valueOf(Object)}
     * @throws IllegalStateException if {@code expression} is false
     */
    public static void checkState(boolean expression, String errorMessage) {
        if (!expression) {
            throw new IllegalStateException(errorMessage);
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkState(boolean b, String errorMessageTemplate, int p) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkState(boolean b, String errorMessageTemplate, int p1, int p2) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkState(boolean b, String errorMessageTemplate, int p1, int p2, int p3) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkState(boolean b, String errorMessageTemplate, long p) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkState(boolean b, String errorMessageTemplate, long p1, long p2) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkState(boolean b, String errorMessageTemplate, long p1, long p2, long p3) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkState(boolean b, String errorMessageTemplate, float p) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkState(boolean b, String errorMessageTemplate, float p1, float p2) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkState(boolean b, String errorMessageTemplate, float p1, float p2, float p3) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkState(boolean b, String errorMessageTemplate, double p) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkState(boolean b, String errorMessageTemplate, double p1, double p2) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkState(boolean b, String errorMessageTemplate, double p1, double p2, double p3) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p
     */
    public static void checkState(boolean b, String errorMessageTemplate, Object p) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     */
    public static void checkState(boolean b, String errorMessageTemplate, Object p1, Object p2) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p1, p2));
        }
    }

    /**
     * Ensures the truth of an expression involving the state of the calling instance, but not
     * involving any parameters to the calling method.
     *
     * 
See {@link #checkState(boolean, String, Object...)} for details.
     *
     * @param b
     * @param errorMessageTemplate
     * @param p1
     * @param p2
     * @param p3
     */
    public static void checkState(boolean b, String errorMessageTemplate, Object p1, Object p2, Object p3) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p1, p2, p3));
        }
    }

    /**
     *
     *
     * @param b
     * @param errorMessageSupplier
     */
    public static void checkState(boolean b, Supplier errorMessageSupplier) {
        if (!b) {
            throw new IllegalStateException(errorMessageSupplier.get());
        }
    }

    /**
     *
     * @param template
     * @param arg
     * @return
     */
    static String format(String template, Object arg) {
        template = String.valueOf(template); // null -> "null"

        // start substituting the arguments into the '%s' placeholders
        final StringBuilder sb = Objectory.createStringBuilder(template.length() + 16);

        String placeholder = "{}";
        int placeholderStart = template.indexOf(placeholder);

        if (placeholderStart < 0) {
            placeholder = "%s";
            placeholderStart = template.indexOf(placeholder);
        }

        if (placeholderStart >= 0) {
            sb.append(template, 0, placeholderStart);
            sb.append(toString(arg));
            sb.append(template, placeholderStart + 2, template.length());
        } else {
            sb.append(" [");
            sb.append(toString(arg));
            sb.append(']');
        }

        final String result = sb.toString();

        Objectory.recycle(sb);

        return result;
    }

    /**
     *
     * @param template
     * @param arg1
     * @param arg2
     * @return
     */
    static String format(String template, Object arg1, Object arg2) {
        template = String.valueOf(template); // null -> "null"

        // start substituting the arguments into the '%s' placeholders
        final StringBuilder sb = Objectory.createStringBuilder(template.length() + 32);

        String placeholder = "{}";
        int placeholderStart = template.indexOf(placeholder);

        if (placeholderStart < 0) {
            placeholder = "%s";
            placeholderStart = template.indexOf(placeholder);
        }

        int templateStart = 0;
        int cnt = 0;

        if (placeholderStart >= 0) {
            cnt++;
            sb.append(template, templateStart, placeholderStart);
            sb.append(toString(arg1));
            templateStart = placeholderStart + 2;
            placeholderStart = template.indexOf(placeholder, templateStart);

            if (placeholderStart >= 0) {
                cnt++;
                sb.append(template, templateStart, placeholderStart);
                sb.append(toString(arg2));
                templateStart = placeholderStart + 2;
            }

            sb.append(template, templateStart, template.length());
        }

        if (cnt == 0) {
            sb.append(" [");
            sb.append(toString(arg1));
            sb.append(", ");
            sb.append(toString(arg2));
            sb.append(']');
        } else if (cnt == 1) {
            sb.append(" [");
            sb.append(toString(arg2));
            sb.append(']');
        }

        final String result = sb.toString();

        Objectory.recycle(sb);

        return result;
    }

    /**
     *
     * @param template
     * @param arg1
     * @param arg2
     * @param arg3
     * @return
     */
    static String format(String template, Object arg1, Object arg2, Object arg3) {
        template = String.valueOf(template); // null -> "null"

        // start substituting the arguments into the '%s' placeholders
        final StringBuilder sb = Objectory.createStringBuilder(template.length() + 48);

        String placeholder = "{}";
        int placeholderStart = template.indexOf(placeholder);

        if (placeholderStart < 0) {
            placeholder = "%s";
            placeholderStart = template.indexOf(placeholder);
        }

        int templateStart = 0;
        int cnt = 0;

        if (placeholderStart >= 0) {
            cnt++;
            sb.append(template, templateStart, placeholderStart);
            sb.append(toString(arg1));
            templateStart = placeholderStart + 2;
            placeholderStart = template.indexOf(placeholder, templateStart);

            if (placeholderStart >= 0) {
                cnt++;
                sb.append(template, templateStart, placeholderStart);
                sb.append(toString(arg2));
                templateStart = placeholderStart + 2;
                placeholderStart = template.indexOf(placeholder, templateStart);

                if (placeholderStart >= 0) {
                    cnt++;
                    sb.append(template, templateStart, placeholderStart);
                    sb.append(toString(arg3));
                    templateStart = placeholderStart + 2;
                }
            }

            sb.append(template, templateStart, template.length());
        }

        if (cnt == 0) {
            sb.append(" [");
            sb.append(toString(arg1));
            sb.append(", ");
            sb.append(toString(arg2));
            sb.append(", ");
            sb.append(toString(arg3));
            sb.append(']');
        } else if (cnt == 1) {
            sb.append(" [");
            sb.append(toString(arg2));
            sb.append(", ");
            sb.append(toString(arg3));
            sb.append(']');
        } else if (cnt == 2) {
            sb.append(" [");
            sb.append(toString(arg3));
            sb.append(']');
        }

        final String result = sb.toString();

        Objectory.recycle(sb);

        return result;
    }

    /**
     * Substitutes each {@code %s} in {@code template} with an argument. These are matched by
     * position: the first {@code %s} gets {@code args[0]}, etc. If there are more arguments than
     * placeholders, the unmatched arguments will be appended to the end of the formatted message in
     * square braces.
     *
     * @param template a non-null string containing 0 or more {@code %s} placeholders.
     * @param args the arguments to be substituted into the message template. Arguments are converted
     *     to strings using {@link String#valueOf(Object)}. Arguments can be null.
     * @return
     */
    // Note that this is somewhat-improperly used from Verify.java as well.
    static String format(String template, Object... args) {
        template = String.valueOf(template); // null -> "null"

        if (isNullOrEmpty(args)) {
            return template;
        }

        // start substituting the arguments into the '%s' placeholders
        final StringBuilder sb = Objectory.createStringBuilder(template.length() + 16 * args.length);
        int templateStart = 0;
        int i = 0;

        String placeholder = "{}";
        int placeholderStart = template.indexOf(placeholder);

        if (placeholderStart < 0) {
            placeholder = "%s";
            placeholderStart = template.indexOf(placeholder);
        }

        while (placeholderStart >= 0 && i < args.length) {
            sb.append(template, templateStart, placeholderStart);
            sb.append(toString(args[i++]));
            templateStart = placeholderStart + 2;
            placeholderStart = template.indexOf(placeholder, templateStart);
        }

        sb.append(template, templateStart, template.length());

        // if we run out of placeholders, append the extra args in square braces
        if (i < args.length) {
            sb.append(" [");
            sb.append(toString(args[i++]));
            while (i < args.length) {
                sb.append(", ");
                sb.append(toString(args[i++]));
            }
            sb.append(']');
        }

        final String result = sb.toString();

        Objectory.recycle(sb);

        return result;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final boolean a, final boolean b) {
        return (a == b) ? 0 : (a ? 1 : -1);
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final byte a, final byte b) {
        return (a < b) ? -1 : ((a == b) ? 0 : 1);
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final short a, final short b) {
        return (a < b) ? -1 : ((a == b) ? 0 : 1);
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final int a, final int b) {
        return (a < b) ? -1 : ((a == b) ? 0 : 1);
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final long a, final long b) {
        return (a < b) ? -1 : ((a == b) ? 0 : 1);
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final float a, final float b) {
        return Float.compare(a, b);
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final double a, final double b) {
        return Double.compare(a, b);
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static > int compare(final T a, final T b) {
        return a == null ? (b == null ? 0 : -1) : (b == null ? 1 : a.compareTo(b));
    }

    /**
     * Returns 0 if the arguments are identical and {@code c.compare(a, b)}
     * otherwise. Consequently, if both arguments are {@code null} 0 is
     * returned.
     *
     * 

     * Note that if one of the arguments is {@code null}, a
     * {@code NullPointerException} may or may not be thrown depending on what
     * ordering policy, if any, the {@link Comparator Comparator} chooses to
     * have for {@code null} values.
     *
     * @param 
     *            the type of the objects being compared
     * @param a
     *            an object
     * @param b
     *            an object to be compared with {@code a}
     * @param cmp
     *            the {@code Comparator} to compare the first two arguments
     * @return 0 if the arguments are identical and {@code c.compare(a, b)}
     *         otherwise.
     * @see Comparable
     * @see Comparator
     */
    public static  int compare(final T a, final T b, final Comparator cmp) {
        return a == null ? (b == null ? 0 : -1) : (b == null ? 1 : (cmp == null ? NATURAL_ORDER : cmp).compare(a, b));
    }

    /**
     * Continue to compare the pairs of values (a1, b1), (a2, b2) until they're not equal.
     * 0 is returned if all of the pairs of values are equal.
     *
     * @param 
     * @param 
     * @param a1
     * @param b1
     * @param a2
     * @param b2
     * @return
     */
    public static , T2 extends Comparable> int compare(T1 a1, T1 b1, T2 a2, T2 b2) {
        int res = compare(a1, b1);

        return res == 0 ? compare(a2, b2) : res;
    }

    /**
     * Continue to compare the pairs of values (a1, b1), (a2, b2), (a3, b3) until they're not equal.
     * 0 is returned if all of the pairs of values are equal.
     *
     * @param 
     * @param 
     * @param 
     * @param a1
     * @param b1
     * @param a2
     * @param b2
     * @param a3
     * @param b3
     * @return
     */
    @SuppressWarnings("java:S1871")
    public static , T2 extends Comparable, T3 extends Comparable> int compare(T1 a1, T1 b1, T2 a2, T2 b2, T3 a3, T3 b3) {
        int res = 0;

        if ((res = compare(a1, b1)) != 0) {
            return res;
        } else if ((res = compare(a2, b2)) != 0) {
            return res;
        }

        return compare(a3, b3);
    }

    /**
     * Continue to compare the pairs of values (a1, b1), (a2, b2), (a3, b3), (a4, b4) until they're not equal.
     * 0 is returned if all of the pairs of values are equal.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a1
     * @param b1
     * @param a2
     * @param b2
     * @param a3
     * @param b3
     * @param a4
     * @param b4
     * @return
     * @see Builder#compare(Comparable, Comparable)
     * @deprecated please use {@code Builder.ComparisonBuilder}
     */
    @Deprecated
    @SuppressWarnings("java:S1871")
    public static , T2 extends Comparable, T3 extends Comparable, T4 extends Comparable> int compare(T1 a1, T1 b1, T2 a2,
            T2 b2, T3 a3, T3 b3, T4 a4, T4 b4) {
        int res = 0;

        if ((res = compare(a1, b1)) != 0) {
            return res;
        } else if ((res = compare(a2, b2)) != 0) {
            return res;
        } else if ((res = compare(a3, b3)) != 0) {
            return res;
        }

        return compare(a4, b4);
    }

    /**
     * Continue to compare the pairs of values (a1, b1), (a2, b2), (a3, b3), (a4, b4), (a5, b5) until they're not equal.
     * 0 is returned if all of the pairs of values are equal.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a1
     * @param b1
     * @param a2
     * @param b2
     * @param a3
     * @param b3
     * @param a4
     * @param b4
     * @param a5
     * @param b5
     * @return
     * @see Builder#compare(Comparable, Comparable)
     * @deprecated please use {@code Builder.ComparisonBuilder}
     */
    @Deprecated
    @SuppressWarnings("java:S1871")
    public static , T2 extends Comparable, T3 extends Comparable, T4 extends Comparable, T5 extends Comparable> int compare(
            T1 a1, T1 b1, T2 a2, T2 b2, T3 a3, T3 b3, T4 a4, T4 b4, T5 a5, T5 b5) {
        int res = 0;

        if ((res = compare(a1, b1)) != 0) {
            return res;
        } else if ((res = compare(a2, b2)) != 0) {
            return res;
        } else if ((res = compare(a3, b3)) != 0) {
            return res;
        } else if ((res = compare(a4, b4)) != 0) {
            return res;
        }

        return compare(a5, b5);
    }

    /**
     * Continue to compare the pairs of values (a1, b1), (a2, b2), (a3, b3), (a4, b4), (a5, b5), (a6, b6) until they're not equal.
     * 0 is returned if all of the pairs of values are equal.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a1
     * @param b1
     * @param a2
     * @param b2
     * @param a3
     * @param b3
     * @param a4
     * @param b4
     * @param a5
     * @param b5
     * @param a6
     * @param b6
     * @return
     * @see Builder#compare(Comparable, Comparable)
     * @deprecated please use {@code Builder.ComparisonBuilder}
     */
    @Deprecated
    @SuppressWarnings("java:S1871")
    public static , T2 extends Comparable, T3 extends Comparable, T4 extends Comparable, T5 extends Comparable, T6 extends Comparable> int compare(
            T1 a1, T1 b1, T2 a2, T2 b2, T3 a3, T3 b3, T4 a4, T4 b4, T5 a5, T5 b5, T6 a6, T6 b6) {
        int res = 0;

        if ((res = compare(a1, b1)) != 0) {
            return res;
        } else if ((res = compare(a2, b2)) != 0) {
            return res;
        } else if ((res = compare(a3, b3)) != 0) {
            return res;
        } else if ((res = compare(a4, b4)) != 0) {
            return res;
        } else if ((res = compare(a5, b5)) != 0) {
            return res;
        }

        return compare(a6, b6);
    }

    /**
     * Continue to compare the pairs of values (a1, b1), (a2, b2), (a3, b3), (a4, b4), (a5, b5), (a6, b6), (a7, b7) until they're not equal.
     * 0 is returned if all of the pairs of values are equal.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param a1
     * @param b1
     * @param a2
     * @param b2
     * @param a3
     * @param b3
     * @param a4
     * @param b4
     * @param a5
     * @param b5
     * @param a6
     * @param b6
     * @param a7
     * @param b7
     * @return
     * @see Builder#compare(Comparable, Comparable)
     * @deprecated please use {@code Builder.ComparisonBuilder}
     */
    @Deprecated
    @SuppressWarnings("java:S1871")
    public static , T2 extends Comparable, T3 extends Comparable, T4 extends Comparable, T5 extends Comparable, T6 extends Comparable, T7 extends Comparable> int compare(
            T1 a1, T1 b1, T2 a2, T2 b2, T3 a3, T3 b3, T4 a4, T4 b4, T5 a5, T5 b5, T6 a6, T6 b6, T7 a7, T7 b7) {
        int res = 0;

        if ((res = compare(a1, b1)) != 0) {
            return res;
        } else if ((res = compare(a2, b2)) != 0) {
            return res;
        } else if ((res = compare(a3, b3)) != 0) {
            return res;
        } else if ((res = compare(a4, b4)) != 0) {
            return res;
        } else if ((res = compare(a5, b5)) != 0) {
            return res;
        } else if ((res = compare(a6, b6)) != 0) {
            return res;
        }

        return compare(a7, b7);
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final boolean[] a, final boolean[] b) {
        if (isNullOrEmpty(a)) {
            return isNullOrEmpty(b) ? 0 : -1;
        } else if (isNullOrEmpty(b)) {
            return 1;
        }

        for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) {
            if (a[i] != b[i]) {
                return a[i] ? 1 : -1;
            }
        }

        return a.length - b.length;
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static int compare(final boolean[] a, final int fromIndexA, final boolean[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return 0;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return a[i] ? 1 : -1;
            }
        }

        return 0;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final char[] a, final char[] b) {
        if (isNullOrEmpty(a)) {
            return isNullOrEmpty(b) ? 0 : -1;
        } else if (isNullOrEmpty(b)) {
            return 1;
        }

        for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) {
            if (a[i] != b[i]) {
                return a[i] > b[i] ? 1 : -1;
            }
        }

        return a.length - b.length;
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static int compare(final char[] a, final int fromIndexA, final char[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return 0;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return a[i] > b[i] ? 1 : -1;
            }
        }

        return 0;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final byte[] a, final byte[] b) {
        if (isNullOrEmpty(a)) {
            return isNullOrEmpty(b) ? 0 : -1;
        } else if (isNullOrEmpty(b)) {
            return 1;
        }

        for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) {
            if (a[i] != b[i]) {
                return a[i] > b[i] ? 1 : -1;
            }
        }

        return a.length - b.length;
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static int compare(final byte[] a, final int fromIndexA, final byte[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return 0;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return a[i] > b[i] ? 1 : -1;
            }
        }

        return 0;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final short[] a, final short[] b) {
        if (isNullOrEmpty(a)) {
            return isNullOrEmpty(b) ? 0 : -1;
        } else if (isNullOrEmpty(b)) {
            return 1;
        }

        for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) {
            if (a[i] != b[i]) {
                return a[i] > b[i] ? 1 : -1;
            }
        }

        return a.length - b.length;
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static int compare(final short[] a, final int fromIndexA, final short[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return 0;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return a[i] > b[i] ? 1 : -1;
            }
        }

        return 0;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final int[] a, final int[] b) {
        if (isNullOrEmpty(a)) {
            return isNullOrEmpty(b) ? 0 : -1;
        } else if (isNullOrEmpty(b)) {
            return 1;
        }

        for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) {
            if (a[i] != b[i]) {
                return a[i] > b[i] ? 1 : -1;
            }
        }

        return a.length - b.length;
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static int compare(final int[] a, final int fromIndexA, final int[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return 0;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return a[i] > b[i] ? 1 : -1;
            }
        }

        return 0;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final long[] a, final long[] b) {
        if (isNullOrEmpty(a)) {
            return isNullOrEmpty(b) ? 0 : -1;
        } else if (isNullOrEmpty(b)) {
            return 1;
        }

        for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) {
            if (a[i] != b[i]) {
                return a[i] > b[i] ? 1 : -1;
            }
        }

        return a.length - b.length;
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static int compare(final long[] a, final int fromIndexA, final long[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return 0;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return a[i] > b[i] ? 1 : -1;
            }
        }

        return 0;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final float[] a, final float[] b) {
        if (isNullOrEmpty(a)) {
            return isNullOrEmpty(b) ? 0 : -1;
        } else if (isNullOrEmpty(b)) {
            return 1;
        }

        int value = 0;

        for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) {
            if ((value = Float.compare(a[i], b[i])) != 0) {
                return value;
            }
        }

        return a.length - b.length;
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static int compare(final float[] a, final int fromIndexA, final float[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return 0;
        }

        int value = 0;

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if ((value = Float.compare(a[i], b[j])) != 0) {
                return value;
            }
        }

        return 0;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static int compare(final double[] a, final double[] b) {
        if (isNullOrEmpty(a)) {
            return isNullOrEmpty(b) ? 0 : -1;
        } else if (isNullOrEmpty(b)) {
            return 1;
        }

        int value = 0;

        for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) {
            if ((value = Double.compare(a[i], b[i])) != 0) {
                return value;
            }
        }

        return a.length - b.length;
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static int compare(final double[] a, final int fromIndexA, final double[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return 0;
        }

        int value = 0;

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if ((value = Double.compare(a[i], b[j])) != 0) {
                return value;
            }
        }

        return 0;
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static > int compare(final T[] a, final T[] b) {
        final Comparator cmp = NATURAL_ORDER;

        return compare(a, b, cmp);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static > int compare(final T[] a, final int fromIndexA, final T[] b, final int fromIndexB, final int len) {
        final Comparator cmp = NATURAL_ORDER;

        return compare(a, fromIndexA, b, fromIndexB, len, cmp);
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @param cmp
     * @return
     */
    public static  int compare(final T[] a, final T[] b, Comparator cmp) {
        if (isNullOrEmpty(a)) {
            return isNullOrEmpty(b) ? 0 : -1;
        } else if (isNullOrEmpty(b)) {
            return 1;
        }

        cmp = cmp == null ? NATURAL_ORDER : cmp;

        int value = 0;

        for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) {
            if ((value = cmp.compare(a[i], b[i])) != 0) {
                return value;
            }
        }

        return a.length - b.length;
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @param cmp
     * @return
     */
    public static  int compare(final T[] a, final int fromIndexA, final T[] b, final int fromIndexB, final int len, Comparator cmp) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return 0;
        }

        cmp = cmp == null ? NATURAL_ORDER : cmp;

        int value = 0;

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if ((value = cmp.compare(a[i], b[j])) != 0) {
                return value;
            }
        }

        return 0;
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static > int compare(final Collection a, final Collection b) {
        final Comparator cmp = NATURAL_ORDER;

        return compare(a, b, cmp);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static  int compare(final Collection a, int fromIndexA, final Collection b, int fromIndexB, final int len) {
        final Comparator cmp = NATURAL_ORDER;

        return compare(a, fromIndexA, b, fromIndexB, len, cmp);
    }

    /**
     *
     * @param 
     * @param a
     * @param b
     * @param cmp
     * @return
     */
    public static  int compare(final Collection a, final Collection b, Comparator cmp) {
        if (isNullOrEmpty(a)) {
            return isNullOrEmpty(b) ? 0 : -1;
        } else if (isNullOrEmpty(b)) {
            return 1;
        }

        cmp = cmp == null ? NATURAL_ORDER : cmp;

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

        for (int i = 0, minLen = N.min(a.size(), b.size()); i < minLen; i++) {
            if ((value = cmp.compare(iterA.next(), iterB.next())) != 0) {
                return value;
            }
        }

        return a.size() - b.size();
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @param cmp
     * @return
     */
    public static  int compare(final Collection a, int fromIndexA, final Collection b, int fromIndexB, final int len, Comparator cmp) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, size(a));
        checkFromIndexSize(fromIndexB, len, size(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return 0;
        }

        cmp = cmp == null ? NATURAL_ORDER : cmp;
        final Iterator iterA = a.iterator();
        final Iterator iterB = b.iterator();

        while (fromIndexA-- > 0) {
            iterA.next();
        }

        while (fromIndexB-- > 0) {
            iterB.next();
        }

        int value = 0;

        for (int i = 0; i < len; i++) {
            if ((value = cmp.compare(iterA.next(), iterB.next())) != 0) {
                return value;
            }
        }

        return 0;
    }

    /**
     * Compare ignore case.
     *
     * @param a
     * @param b
     * @return
     */
    public static int compareIgnoreCase(final String a, final String b) {
        return a == null ? (b == null ? 0 : -1) : (b == null ? 1 : a.compareToIgnoreCase(b));
    }

    /**
     * Returns {@code true} is {@code a < b}, otherwise {@code false} is returned.
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static > boolean lessThan(final T a, final T b) {
        return compare(a, b) < 0;
    }

    /**
     * Returns {@code true} is {@code a <= b}, otherwise {@code false} is returned.
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static > boolean lessEqual(final T a, final T b) {
        return compare(a, b) <= 0;
    }

    /**
     * Returns {@code true} is {@code a > b}, otherwise {@code false} is returned.
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static > boolean greaterThan(final T a, final T b) {
        return compare(a, b) > 0;
    }

    /**
     * Returns {@code true} is {@code a >= b}, otherwise {@code false} is returned.
     *
     * @param 
     * @param a
     * @param b
     * @return
     */
    public static > boolean greaterEqual(final T a, final T b) {
        return compare(a, b) >= 0;
    }

    /**
     * Returns {@code true} is {@code min < value < max}, otherwise {@code false} is returned.
     *
     * @param 
     * @param value
     * @param min
     * @param max
     * @return
     */
    public static > boolean gtAndLt(final T value, final T min, final T max) {
        if (compare(value, min) <= 0) {
            return false;
        }

        return compare(value, max) < 0;
    }

    /**
     * Returns {@code true} is {@code min <= value < max}, otherwise {@code false} is returned.
     *
     * @param 
     * @param value
     * @param min
     * @param max
     * @return
     */
    public static > boolean geAndLt(final T value, final T min, final T max) {
        if (compare(value, min) < 0) {
            return false;
        }

        return compare(value, max) < 0;
    }

    /**
     * Returns {@code true} is {@code min <= value <= max}, otherwise {@code false} is returned.
     *
     * @param 
     * @param value
     * @param min
     * @param max
     * @return
     */
    public static > boolean geAndLe(final T value, final T min, final T max) {
        if (compare(value, min) < 0) {
            return false;
        }

        return compare(value, max) <= 0;
    }

    /**
     * Returns {@code true} is {@code min < value <= max}, otherwise {@code false} is returned.
     *
     * @param 
     * @param value
     * @param min
     * @param max
     * @return
     */
    public static > boolean gtAndLe(final T value, final T min, final T max) {
        if (compare(value, min) <= 0) {
            return false;
        }

        return compare(value, max) <= 0;
    }

    /**
     *
     * @param 
     * @param value
     * @param min
     * @param max
     * @return
     * @deprecated replaced by {@link #gtAndLt(Comparable, Comparable, Comparable)}
     */
    @Deprecated
    public static > boolean isBetween(final T value, final T min, final T max) {
        return gtAndLt(value, min, max);
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     */
    public static boolean equals(final boolean a, final boolean b) {
        return a == b;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     */
    public static boolean equals(final char a, final char b) {
        return a == b;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     */
    public static boolean equals(final byte a, final byte b) {
        return a == b;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     */
    public static boolean equals(final short a, final short b) {
        return a == b;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     */
    public static boolean equals(final int a, final int b) {
        return a == b;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     */
    public static boolean equals(final long a, final long b) {
        return a == b;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     */
    public static boolean equals(final float a, final float b) {
        return Float.compare(a, b) == 0;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     */
    public static boolean equals(final double a, final double b) {
        return Double.compare(a, b) == 0;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean equals(final String a, final String b) {
        return (a == null) ? b == null : (b == null ? false : a.length() == b.length() && a.equals(b));
    }

    /**
     * Equals ignore case.
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean equalsIgnoreCase(final String a, final String b) {
        return (a == null) ? b == null : (b == null ? false : a.equalsIgnoreCase(b));
    }

    /**
     * compare {@code a} and {@code b} by
     * {@link Arrays#equals(Object[], Object[])} if both of them are array.
     *
     * @param a
     * @param b
     * @return boolean
     */
    public static boolean equals(final Object a, final Object b) {
        if ((a == null) ? b == null : (b == null ? false : a.equals(b))) {
            return true;
        }

        if ((a != null) && (b != null)) {
            final Type typeA = typeOf(a.getClass());

            if (typeA.isPrimitiveArray()) {
                final Type typeB = typeOf(b.getClass());

                return typeA.clazz().equals(typeB.clazz()) && typeA.equals(a, b);
            } else if (typeA.isObjectArray()) {
                final Type typeB = typeOf(b.getClass());

                return typeB.isObjectArray() && typeA.equals(a, b);
            }
        }

        return false;
    }

    /**
     * compare {@code a} and {@code b} by
     * {@link Arrays#equals(Object[], Object[])} if both of them are array.
     *
     * @param a
     * @param b
     * @return boolean
     */
    public static boolean deepEquals(final Object a, final Object b) {
        if ((a == null) ? b == null : (b == null ? false : a.equals(b))) {
            return true;
        }

        if ((a != null) && (b != null) && a.getClass().isArray() && a.getClass().equals(b.getClass())) {
            return typeOf(a.getClass()).deepEquals(a, b);
        }

        return false;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     * @see Arrays#equals(boolean[], boolean[])
     */
    public static boolean equals(final boolean[] a, final boolean[] b) {
        return Arrays.equals(a, b);
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean equals(final boolean[] a, final int fromIndexA, final boolean[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     * @see Arrays#equals(char[], char[])
     */
    public static boolean equals(final char[] a, final char[] b) {
        return Arrays.equals(a, b);
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean equals(final char[] a, final int fromIndexA, final char[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     * @see Arrays#equals(byte[], byte[])
     */
    public static boolean equals(final byte[] a, final byte[] b) {
        return Arrays.equals(a, b);
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean equals(final byte[] a, final int fromIndexA, final byte[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     * @see Arrays#equals(short[], short[])
     */
    public static boolean equals(final short[] a, final short[] b) {
        return Arrays.equals(a, b);
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean equals(final short[] a, final int fromIndexA, final short[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     * @see Arrays#equals(int[], int[])
     */
    public static boolean equals(final int[] a, final int[] b) {
        return Arrays.equals(a, b);
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean equals(final int[] a, final int fromIndexA, final int[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     * @see Arrays#equals(long[], long[])
     */
    public static boolean equals(final long[] a, final long[] b) {
        return Arrays.equals(a, b);
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean equals(final long[] a, final int fromIndexA, final long[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (a[i] != b[j]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     * @see Arrays#equals(float[], float[])
     */
    public static boolean equals(final float[] a, final float[] b) {
        return Arrays.equals(a, b);
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean equals(final float[] a, final int fromIndexA, final float[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (Float.compare(a[i], b[j]) != 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     * @see Arrays#equals(double[], double[])
     */
    public static boolean equals(final double[] a, final double[] b) {
        return Arrays.equals(a, b);
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean equals(final double[] a, final int fromIndexA, final double[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (Double.compare(a[i], b[j]) != 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param a
     * @param b
     * @return boolean
     * @see Arrays#equals(Object[], Object[])
     */
    public static boolean equals(final Object[] a, final Object[] b) {
        return a == b || (a != null && b != null && a.length == b.length && equals(a, 0, b, 0, a.length));
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean equals(final Object[] a, final int fromIndexA, final Object[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        } else if (!a.getClass().equals(b.getClass())) {
            return false;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (!equals(a[i], b[j])) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param a
     * @param b
     * @return
     * @see Arrays#deepEquals(Object[], Object[])
     */
    public static boolean deepEquals(final Object[] a, final Object[] b) {
        return a == b || (a != null && b != null && a.length == b.length && deepEquals(a, 0, b, 0, a.length));
    }

    /**
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean deepEquals(final Object[] a, final int fromIndexA, final Object[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        } else if (!a.getClass().equals(b.getClass())) {
            return false;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (!deepEquals(a[i], b[j])) {
                return false;
            }
        }

        return true;
    }

    /**
     * Equals ignore case.
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean equalsIgnoreCase(final String[] a, final String[] b) {
        return (a == null || b == null) ? a == b : (a.length == b.length && equalsIgnoreCase(a, 0, b, 0, a.length));
    }

    /**
     * Equals ignore case.
     *
     * @param a
     * @param fromIndexA
     * @param b
     * @param fromIndexB
     * @param len
     * @return
     */
    public static boolean equalsIgnoreCase(final String[] a, final int fromIndexA, final String[] b, final int fromIndexB, final int len) {
        checkArgNotNegative(len, "len");
        checkFromIndexSize(fromIndexA, len, len(a));
        checkFromIndexSize(fromIndexB, len, len(b));

        if ((fromIndexA == fromIndexB && a == b) || len == 0) {
            return true;
        } else if (!a.getClass().equals(b.getClass())) {
            return false;
        }

        for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) {
            if (((a[i] == null || b[j] == null) ? (a != b) : !a[i].equalsIgnoreCase(b[j]))) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param bean1
     * @param bean2
     * @return
     * @see MapDifference#of(Object, Object)
     */
    public static boolean equalsByCommonProps(final Object bean1, final Object bean2) {
        N.checkArgNotNull(bean1);
        N.checkArgNotNull(bean2);
        N.checkArgument(ClassUtil.isBeanClass(bean1.getClass()), "{} is not a bean class", bean1.getClass());
        N.checkArgument(ClassUtil.isBeanClass(bean2.getClass()), "{} is not a bean class", bean2.getClass());

        BeanInfo beanInfo1 = ParserUtil.getBeanInfo(bean1.getClass());
        BeanInfo beanInfo2 = ParserUtil.getBeanInfo(bean2.getClass());

        PropInfo propInfo2 = null;
        Object propValue1 = null;

        for (PropInfo propInfo1 : beanInfo1.propInfoList) {
            propInfo2 = beanInfo2.getPropInfo(propInfo1);

            if (propInfo2 != null) {
                propValue1 = propInfo1.getPropValue(bean1);

                if (!equals(propValue1, propInfo2.getPropValue(bean2))) {
                    return false;
                }
            }
        }

        return true;
    }

    /**
     *
     * @param bean1
     * @param bean2
     * @param propNamesToCompare
     * @return
     * @see MapDifference#of(Object, Object)
     */
    public static boolean equalsByCommonProps(final Object bean1, final Object bean2, final Collection propNamesToCompare) {
        N.checkArgNotNull(bean1);
        N.checkArgNotNull(bean2);
        N.checkArgument(ClassUtil.isBeanClass(bean1.getClass()), "{} is not a bean class", bean1.getClass());
        N.checkArgument(ClassUtil.isBeanClass(bean2.getClass()), "{} is not a bean class", bean2.getClass());

        if (N.isNullOrEmpty(propNamesToCompare)) {
            return true;
        }

        BeanInfo beanInfo1 = ParserUtil.getBeanInfo(bean1.getClass());
        BeanInfo beanInfo2 = ParserUtil.getBeanInfo(bean2.getClass());

        PropInfo propInfo1 = null;
        PropInfo propInfo2 = null;
        Object propValue1 = null;

        for (String propName : propNamesToCompare) {
            propInfo1 = beanInfo1.getPropInfo(propName);

            if (propInfo1 != null) {
                propInfo2 = beanInfo2.getPropInfo(propInfo1);

                if (propInfo2 == null) {
                    throw new IllegalArgumentException("No field found in class: " + bean2.getClass() + " by name: " + propName);
                }
            } else {
                propInfo2 = beanInfo2.getPropInfo(propName);

                if (propInfo2 != null) {
                    propInfo1 = beanInfo1.getPropInfo(propInfo2);
                }

                if (propInfo1 == null) {
                    throw new IllegalArgumentException("No field found in class: " + bean1.getClass() + " by name: " + propName);
                }
            }

            propValue1 = propInfo1.getPropValue(bean1);

            if (!equals(propValue1, propInfo2.getPropValue(bean2))) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     * @param value
     * @return int
     */
    public static int hashCode(final boolean value) {
        return value ? 1231 : 1237;
    }

    /**
     *
     * @param value
     * @return int
     */
    public static int hashCode(final char value) {
        return value;
    }

    /**
     *
     * @param value
     * @return int
     */
    public static int hashCode(final byte value) {
        return value;
    }

    /**
     *
     * @param value
     * @return int
     */
    public static int hashCode(final short value) {
        return value;
    }

    /**
     *
     * @param value
     * @return int
     */
    public static int hashCode(final int value) {
        return value;
    }

    /**
     *
     * @param value
     * @return int
     */
    public static int hashCode(final long value) {
        return (int) (value ^ (value >>> 32));
    }

    /**
     *
     * @param value
     * @return int
     */
    public static int hashCode(final float value) {
        return Float.floatToIntBits(value);
    }

    /**
     *
     * @param value
     * @return int
     */
    public static int hashCode(final double value) {
        long bits = Double.doubleToLongBits(value);

        return (int) (bits ^ (bits >>> 32));
    }

    /**
     *
     * @param obj
     * @return int
     */
    public static int hashCode(final Object obj) {
        if (obj == null) {
            return 0;
        }

        if (obj.getClass().isArray()) {
            return typeOf(obj.getClass()).hashCode(obj);
        }

        return obj.hashCode();
    }

    /**
     *
     * @param obj
     * @return int
     */
    public static int deepHashCode(final Object obj) {
        if (obj == null) {
            return 0;
        }

        if (obj.getClass().isArray()) {
            return typeOf(obj.getClass()).deepHashCode(obj);
        }

        return obj.hashCode();
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#hashCode(boolean[])
     */
    public static int hashCode(final boolean[] a) {
        return a == null ? 0 : hashCode(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int hashCode(final boolean[] a, final int fromIndex, final int toIndex) {
        if (a == null) {
            return 0;
        }

        int result = 1;

        for (int i = fromIndex; i < toIndex; i++) {
            result = 31 * result + (a[i] ? 1231 : 1237);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#hashCode(char[])
     */
    public static int hashCode(final char[] a) {
        return a == null ? 0 : hashCode(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int hashCode(final char[] a, final int fromIndex, final int toIndex) {
        if (a == null) {
            return 0;
        }

        int result = 1;

        for (int i = fromIndex; i < toIndex; i++) {
            result = 31 * result + a[i];
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#hashCode(byte[])
     */
    public static int hashCode(final byte[] a) {
        return a == null ? 0 : hashCode(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int hashCode(final byte[] a, final int fromIndex, final int toIndex) {
        if (a == null) {
            return 0;
        }

        int result = 1;

        for (int i = fromIndex; i < toIndex; i++) {
            result = 31 * result + a[i];
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#hashCode(short[])
     */
    public static int hashCode(final short[] a) {
        return a == null ? 0 : hashCode(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int hashCode(final short[] a, final int fromIndex, final int toIndex) {
        if (a == null) {
            return 0;
        }

        int result = 1;

        for (int i = fromIndex; i < toIndex; i++) {
            result = 31 * result + a[i];
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#hashCode(int[])
     */
    public static int hashCode(final int[] a) {
        return a == null ? 0 : hashCode(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int hashCode(final int[] a, final int fromIndex, final int toIndex) {
        if (a == null) {
            return 0;
        }

        int result = 1;

        for (int i = fromIndex; i < toIndex; i++) {
            result = 31 * result + a[i];
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#hashCode(long[])
     */
    public static int hashCode(final long[] a) {
        return a == null ? 0 : hashCode(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int hashCode(final long[] a, final int fromIndex, final int toIndex) {
        if (a == null) {
            return 0;
        }

        int result = 1;

        for (int i = fromIndex; i < toIndex; i++) {
            result = 31 * result + (int) (a[i] ^ (a[i] >>> 32));
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#hashCode(float[])
     */
    public static int hashCode(final float[] a) {
        return a == null ? 0 : hashCode(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int hashCode(final float[] a, final int fromIndex, final int toIndex) {
        if (a == null) {
            return 0;
        }

        int result = 1;

        for (int i = fromIndex; i < toIndex; i++) {
            result = 31 * result + Float.floatToIntBits(a[i]);
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#hashCode(double[])
     */
    public static int hashCode(final double[] a) {
        return a == null ? 0 : hashCode(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int hashCode(final double[] a, final int fromIndex, final int toIndex) {
        if (a == null) {
            return 0;
        }

        int result = 1;

        for (int i = fromIndex; i < toIndex; i++) {
            long bits = Double.doubleToLongBits(a[i]);
            result = 31 * result + (int) (bits ^ (bits >>> 32));
        }

        return result;
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#hashCode(Object[])
     */
    public static int hashCode(final Object[] a) {
        return a == null ? 0 : hashCode(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int hashCode(final Object[] a, final int fromIndex, final int toIndex) {
        if (a == null) {
            return 0;
        }

        int result = 1;

        for (int i = fromIndex; i < toIndex; i++) {
            result = 31 * result + (a[i] == null ? 0 : a[i].hashCode());
        }

        return result;
    }

    /**
     * Deep hash code.
     *
     * @param a
     * @return
     * @see Arrays#deepHashCode(Object[])
     */
    public static int deepHashCode(final Object[] a) {
        return a == null ? 0 : deepHashCode(a, 0, a.length);
    }

    /**
     * Deep hash code.
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static int deepHashCode(final Object[] a, final int fromIndex, final int toIndex) {
        if (a == null) {
            return 0;
        }

        int result = 1;

        for (int i = fromIndex; i < toIndex; i++) {
            result = 31 * result + (a[i] == null ? 0 : deepHashCode(a[i]));
        }

        return result;
    }

    /**
     *
     * @param value
     * @return int
     */
    public static String toString(final boolean value) {
        return stringOf(value);
    }

    /**
     *
     * @param value
     * @return int
     */
    public static String toString(final char value) {
        return stringOf(value);
    }

    /**
     *
     * @param value
     * @return int
     */
    public static String toString(final byte value) {
        return stringOf(value);
    }

    /**
     *
     * @param value
     * @return int
     */
    public static String toString(final short value) {
        return stringOf(value);
    }

    /**
     *
     * @param value
     * @return int
     */
    public static String toString(final int value) {
        return stringOf(value);
    }

    /**
     *
     * @param value
     * @return int
     */
    public static String toString(final long value) {
        return stringOf(value);
    }

    /**
     *
     * @param value
     * @return int
     */
    public static String toString(final float value) {
        return stringOf(value);
    }

    /**
     *
     * @param value
     * @return int
     */
    public static String toString(final double value) {
        return stringOf(value);
    }

    /**
     *
     * @param obj
     * @return int
     */
    public static String toString(final Object obj) {
        if (obj == null) {
            return Strings.NULL_STRING;
        } else if (obj instanceof CharSequence) {
            return obj.toString();
        }

        if (obj.getClass().isArray()) {
            return typeOf(obj.getClass()).toString(obj);
        } else if (obj instanceof Iterator) {
            final Iterator iter = (Iterator) obj;
            final Joiner joiner = Joiner.with(", ", "[", "]").reuseCachedBuffer();

            while (iter.hasNext()) {
                joiner.append(toString(iter.next()));
            }

            return joiner.toString();
        }

        final Integer typeIdx = CLASS_TYPE_ENUM.get(obj.getClass());

        if (typeIdx == null) {
            return obj.toString();
        }

        switch (typeIdx) {
            case 21:
                return toString(((Boolean) obj).booleanValue());

            case 22:
                return toString(((Character) obj).charValue());

            case 23:
                return toString(((Byte) obj).byteValue());

            case 24:
                return toString(((Short) obj).shortValue());

            case 25:
                return toString(((Integer) obj).intValue());

            case 26:
                return toString(((Long) obj).longValue());

            //    case 27:
            //        return toString(((Float) obj).floatValue());
            //
            //    case 28:
            //        return toString(((Double) obj).doubleValue());

            default:
                return obj.toString();
        }
    }

    /**
     *
     * @param obj
     * @return int
     */
    public static String deepToString(final Object obj) {
        if (obj == null) {
            return Strings.NULL_STRING;
        }

        if (obj.getClass().isArray()) {
            return typeOf(obj.getClass()).deepToString(obj);
        }

        return obj.toString();
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#toString(boolean[])
     */
    public static String toString(final boolean[] a) {
        if (a == null) {
            return Strings.NULL_STRING;
        }

        if (a.length == 0) {
            return "[]";
        }

        return toString(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String toString(final boolean[] a, final int fromIndex, final int toIndex) {
        final StringBuilder sb = Objectory.createStringBuilder();

        try {
            toString(sb, a, fromIndex, toIndex);

            return sb.toString();
        } finally {
            Objectory.recycle(sb);
        }
    }

    /**
     *
     * @param sb
     * @param a
     */
    static void toString(final StringBuilder sb, final boolean[] a) {
        if (a == null) {
            sb.append(Strings.NULL_STRING);
        } else if (a.length == 0) {
            sb.append("[]");
        } else {
            toString(sb, a, 0, a.length);
        }
    }

    /**
     *
     * @param sb
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    static void toString(final StringBuilder sb, final boolean[] a, final int fromIndex, final int toIndex) {
        sb.append(WD._BRACKET_L);

        for (int i = fromIndex; i < toIndex; i++) {
            if (i > fromIndex) {
                sb.append(WD.COMMA_SPACE);
            }

            sb.append(a[i]);
        }

        sb.append(WD._BRACKET_R);
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#toString(char[])
     */
    public static String toString(final char[] a) {
        if (a == null) {
            return Strings.NULL_STRING;
        } else if (a.length == 0) {
            return "[]";
        }

        return toString(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String toString(final char[] a, final int fromIndex, final int toIndex) {
        final StringBuilder sb = Objectory.createStringBuilder();

        try {
            toString(sb, a, fromIndex, toIndex);

            return sb.toString();
        } finally {
            Objectory.recycle(sb);
        }
    }

    /**
     *
     * @param sb
     * @param a
     */
    static void toString(final StringBuilder sb, final char[] a) {
        if (a == null) {
            sb.append(Strings.NULL_STRING);
        } else if (a.length == 0) {
            sb.append("[]");
        } else {
            toString(sb, a, 0, a.length);
        }
    }

    /**
     *
     * @param sb
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    static void toString(final StringBuilder sb, final char[] a, final int fromIndex, final int toIndex) {
        sb.append(WD._BRACKET_L);

        for (int i = fromIndex; i < toIndex; i++) {
            if (i > fromIndex) {
                sb.append(WD.COMMA_SPACE);
            }

            sb.append(a[i]);
        }

        sb.append(WD._BRACKET_R);
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#toString(byte[])
     */
    public static String toString(final byte[] a) {
        if (a == null) {
            return Strings.NULL_STRING;
        } else if (a.length == 0) {
            return "[]";
        }

        return toString(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String toString(final byte[] a, final int fromIndex, final int toIndex) {
        final StringBuilder sb = Objectory.createStringBuilder();

        try {
            toString(sb, a, fromIndex, toIndex);

            return sb.toString();
        } finally {
            Objectory.recycle(sb);
        }
    }

    /**
     *
     * @param sb
     * @param a
     */
    static void toString(final StringBuilder sb, final byte[] a) {
        if (a == null) {
            sb.append(Strings.NULL_STRING);
        } else if (a.length == 0) {
            sb.append("[]");
        } else {
            toString(sb, a, 0, a.length);
        }
    }

    /**
     *
     * @param sb
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    static void toString(final StringBuilder sb, final byte[] a, final int fromIndex, final int toIndex) {
        sb.append(WD._BRACKET_L);

        for (int i = fromIndex; i < toIndex; i++) {
            if (i > fromIndex) {
                sb.append(WD.COMMA_SPACE);
            }

            sb.append(a[i]);
        }

        sb.append(WD._BRACKET_R);
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#toString(short[])
     */
    public static String toString(final short[] a) {
        if (a == null) {
            return Strings.NULL_STRING;
        } else if (a.length == 0) {
            return "[]";
        }

        return toString(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String toString(final short[] a, final int fromIndex, final int toIndex) {
        final StringBuilder sb = Objectory.createStringBuilder();

        try {
            toString(sb, a, fromIndex, toIndex);

            return sb.toString();
        } finally {
            Objectory.recycle(sb);
        }
    }

    /**
     *
     * @param sb
     * @param a
     */
    static void toString(final StringBuilder sb, final short[] a) {
        if (a == null) {
            sb.append(Strings.NULL_STRING);
        } else if (a.length == 0) {
            sb.append("[]");
        } else {
            toString(sb, a, 0, a.length);
        }
    }

    /**
     *
     * @param sb
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    static void toString(final StringBuilder sb, final short[] a, final int fromIndex, final int toIndex) {
        sb.append(WD._BRACKET_L);

        for (int i = fromIndex; i < toIndex; i++) {
            if (i > fromIndex) {
                sb.append(WD.COMMA_SPACE);
            }

            sb.append(a[i]);
        }

        sb.append(WD._BRACKET_R);
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#toString(int[])
     */
    public static String toString(final int[] a) {
        if (a == null) {
            return Strings.NULL_STRING;
        } else if (a.length == 0) {
            return "[]";
        }

        return toString(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String toString(final int[] a, final int fromIndex, final int toIndex) {
        final StringBuilder sb = Objectory.createStringBuilder();

        try {
            toString(sb, a, fromIndex, toIndex);

            return sb.toString();
        } finally {
            Objectory.recycle(sb);
        }
    }

    /**
     *
     * @param sb
     * @param a
     */
    static void toString(final StringBuilder sb, final int[] a) {
        if (a == null) {
            sb.append(Strings.NULL_STRING);
        } else if (a.length == 0) {
            sb.append("[]");
        } else {
            toString(sb, a, 0, a.length);
        }
    }

    /**
     *
     * @param sb
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    static void toString(final StringBuilder sb, final int[] a, final int fromIndex, final int toIndex) {
        sb.append(WD._BRACKET_L);

        for (int i = fromIndex; i < toIndex; i++) {
            if (i > fromIndex) {
                sb.append(WD.COMMA_SPACE);
            }

            sb.append(a[i]);
        }

        sb.append(WD._BRACKET_R);
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#toString(long[])
     */
    public static String toString(final long[] a) {
        if (a == null) {
            return Strings.NULL_STRING;
        } else if (a.length == 0) {
            return "[]";
        }

        return toString(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String toString(final long[] a, final int fromIndex, final int toIndex) {
        final StringBuilder sb = Objectory.createStringBuilder();

        try {
            toString(sb, a, fromIndex, toIndex);

            return sb.toString();
        } finally {
            Objectory.recycle(sb);
        }
    }

    /**
     *
     * @param sb
     * @param a
     */
    static void toString(final StringBuilder sb, final long[] a) {
        if (a == null) {
            sb.append(Strings.NULL_STRING);
        } else if (a.length == 0) {
            sb.append("[]");
        } else {
            toString(sb, a, 0, a.length);
        }
    }

    /**
     *
     * @param sb
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    static void toString(final StringBuilder sb, final long[] a, final int fromIndex, final int toIndex) {
        sb.append(WD._BRACKET_L);

        for (int i = fromIndex; i < toIndex; i++) {
            if (i > fromIndex) {
                sb.append(WD.COMMA_SPACE);
            }

            sb.append(a[i]);
        }

        sb.append(WD._BRACKET_R);
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#toString(float[])
     */
    public static String toString(final float[] a) {
        if (a == null) {
            return Strings.NULL_STRING;
        } else if (a.length == 0) {
            return "[]";
        }

        return toString(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String toString(final float[] a, final int fromIndex, final int toIndex) {
        final StringBuilder sb = Objectory.createStringBuilder();

        try {
            toString(sb, a, fromIndex, toIndex);

            return sb.toString();
        } finally {
            Objectory.recycle(sb);
        }
    }

    /**
     *
     * @param sb
     * @param a
     */
    static void toString(final StringBuilder sb, final float[] a) {
        if (a == null) {
            sb.append(Strings.NULL_STRING);
        } else if (a.length == 0) {
            sb.append("[]");
        } else {
            toString(sb, a, 0, a.length);
        }
    }

    /**
     *
     * @param sb
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    static void toString(final StringBuilder sb, final float[] a, final int fromIndex, final int toIndex) {
        sb.append(WD._BRACKET_L);

        for (int i = fromIndex; i < toIndex; i++) {
            if (i > fromIndex) {
                sb.append(WD.COMMA_SPACE);
            }

            sb.append(a[i]);
        }

        sb.append(WD._BRACKET_R);
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#toString(double[])
     */
    public static String toString(final double[] a) {
        if (a == null) {
            return Strings.NULL_STRING;
        } else if (a.length == 0) {
            return "[]";
        }

        return toString(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String toString(final double[] a, final int fromIndex, final int toIndex) {
        final StringBuilder sb = Objectory.createStringBuilder();

        try {
            toString(sb, a, fromIndex, toIndex);

            return sb.toString();
        } finally {
            Objectory.recycle(sb);
        }
    }

    /**
     *
     * @param sb
     * @param a
     */
    static void toString(final StringBuilder sb, final double[] a) {
        if (a == null) {
            sb.append(Strings.NULL_STRING);
        } else if (a.length == 0) {
            sb.append("[]");
        } else {
            toString(sb, a, 0, a.length);
        }
    }

    /**
     *
     * @param sb
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    static void toString(final StringBuilder sb, final double[] a, final int fromIndex, final int toIndex) {
        sb.append(WD._BRACKET_L);

        for (int i = fromIndex; i < toIndex; i++) {
            if (i > fromIndex) {
                sb.append(WD.COMMA_SPACE);
            }

            sb.append(a[i]);
        }

        sb.append(WD._BRACKET_R);
    }

    /**
     *
     * @param a
     * @return
     * @see Arrays#toString(Object[])
     */
    public static String toString(final Object[] a) {
        if (a == null) {
            return Strings.NULL_STRING;
        } else if (a.length == 0) {
            return "[]";
        }

        return toString(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String toString(final Object[] a, final int fromIndex, final int toIndex) {
        final StringBuilder sb = Objectory.createStringBuilder();

        try {
            toString(sb, a, fromIndex, toIndex);

            return sb.toString();
        } finally {
            Objectory.recycle(sb);
        }
    }

    /**
     *
     * @param sb
     * @param a
     */
    static void toString(final StringBuilder sb, final Object[] a) {
        if (a == null) {
            sb.append(Strings.NULL_STRING);
        } else if (a.length == 0) {
            sb.append("[]");
        } else {
            toString(sb, a, 0, a.length);
        }
    }

    /**
     *
     * @param sb
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    static void toString(final StringBuilder sb, final Object[] a, final int fromIndex, final int toIndex) {
        sb.append(WD._BRACKET_L);

        for (int i = fromIndex; i < toIndex; i++) {
            if (i > fromIndex) {
                sb.append(WD.COMMA_SPACE);
            }

            sb.append(toString(a[i]));
        }

        sb.append(WD._BRACKET_R);
    }

    /**
     *
     * @param a
     * @param defaultIfNull
     * @return
     */
    public static String toString(final Object a, final String defaultIfNull) {
        return a == null ? defaultIfNull : toString(a);
    }

    /**
     * Deep to string.
     *
     * @param a
     * @return
     * @see Arrays#deepToString(Object[])
     */
    public static String deepToString(final Object[] a) {
        if (a == null) {
            return Strings.NULL_STRING;
        } else if (a.length == 0) {
            return "[]";
        }

        return deepToString(a, 0, a.length);
    }

    /**
     * Deep to string.
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String deepToString(final Object[] a, final int fromIndex, final int toIndex) {
        final StringBuilder sb = Objectory.createStringBuilder();
        final Set set = Objectory.createSet();

        try {
            deepToString(sb, a, fromIndex, toIndex, set);

            return sb.toString();
        } finally {
            Objectory.recycle(set);
            Objectory.recycle(sb);
        }
    }

    /**
     * Deep to string.
     *
     * @param sb
     * @param a
     * @param processedElements
     */
    static void deepToString(final StringBuilder sb, final Object[] a, final Set processedElements) {
        deepToString(sb, a, 0, a.length, processedElements);
    }

    /**
     * Deep to string.
     *
     * @param sb
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param processedElements
     */
    static void deepToString(final StringBuilder sb, final Object[] a, final int fromIndex, final int toIndex, final Set processedElements) {
        processedElements.add(a);

        sb.append(WD._BRACKET_L);

        Object element = null;
        Class eClass = null;
        for (int i = fromIndex; i < toIndex; i++) {
            element = a[i];

            if (i > fromIndex) {
                sb.append(WD.COMMA_SPACE);
            }

            if (element == null) {
                sb.append(Strings.NULL_CHAR_ARRAY);

                continue;
            }

            eClass = element.getClass();

            if (eClass.isArray()) {
                Integer enumInt = CLASS_TYPE_ENUM.get(eClass);

                int num = enumInt == null ? 0 : enumInt;

                switch (num) {
                    case 11:
                        toString(sb, (boolean[]) element);
                        break;

                    case 12:
                        toString(sb, (char[]) element);
                        break;

                    case 13:
                        toString(sb, (byte[]) element);
                        break;

                    case 14:
                        toString(sb, (short[]) element);
                        break;

                    case 15:
                        toString(sb, (int[]) element);
                        break;

                    case 16:
                        toString(sb, (long[]) element);
                        break;

                    case 17:
                        toString(sb, (float[]) element);
                        break;

                    case 18:
                        toString(sb, (double[]) element);
                        break;

                    case 19:
                        toString(sb, (String[]) element);
                        break;

                    default:
                        if (processedElements.contains(element)) {
                            sb.append("[...]");
                        } else {
                            deepToString(sb, (Object[]) element, processedElements);
                        }
                }
            } else { // element is non-null and not an array
                sb.append(element.toString());
            }
        }

        sb.append(WD._BRACKET_R);

        processedElements.remove(a);
    }

    /**
     * Deep to string.
     *
     * @param a
     * @param defaultIfNull
     * @return
     */
    public static String deepToString(final Object[] a, final String defaultIfNull) {
        return a == null ? defaultIfNull : deepToString(a);
    }

    /**
     * 

     * Reverses the order of the given array.
     * 

     *
     * @param a
     */
    public static void reverse(final boolean[] a) {
        if (isNullOrEmpty(a)) {
            return;
        }

        reverse(a, 0, a.length);
    }

    /**
     * 

     * Reverses the order of the given array in the given range.
     * 

     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverse(final boolean[] a, int fromIndex, int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        boolean tmp = false;

        for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

    /**
     * 

     * Reverses the order of the given array.
     * 

     *
     * @param a
     */
    public static void reverse(final char[] a) {
        if (isNullOrEmpty(a)) {
            return;
        }

        reverse(a, 0, a.length);
    }

    /**
     * 

     * Reverses the order of the given array in the given range.
     * 

     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverse(final char[] a, int fromIndex, int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        char tmp = 0;

        for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

    /**
     * 

     * Reverses the order of the given array.
     * 

     *
     * @param a
     */
    public static void reverse(final byte[] a) {
        if (isNullOrEmpty(a)) {
            return;
        }

        reverse(a, 0, a.length);
    }

    /**
     * 

     * Reverses the order of the given array in the given range.
     * 

     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverse(final byte[] a, int fromIndex, int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        byte tmp = 0;

        for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

    /**
     * 

     * Reverses the order of the given array.
     * 

     *
     * @param a
     */
    public static void reverse(final short[] a) {
        if (isNullOrEmpty(a)) {
            return;
        }

        reverse(a, 0, a.length);
    }

    /**
     * 

     * Reverses the order of the given array in the given range.
     * 

     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverse(final short[] a, int fromIndex, int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        short tmp = 0;

        for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

    /**
     * 

     * Reverses the order of the given array.
     * 

     *
     * @param a
     */
    public static void reverse(final int[] a) {
        if (isNullOrEmpty(a)) {
            return;
        }

        reverse(a, 0, a.length);
    }

    /**
     * 

     * Reverses the order of the given array in the given range.
     * 

     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverse(final int[] a, int fromIndex, int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        int tmp = 0;

        for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

    /**
     * 

     * Reverses the order of the given array.
     * 

     *
     * @param a
     */
    public static void reverse(final long[] a) {
        if (isNullOrEmpty(a)) {
            return;
        }

        reverse(a, 0, a.length);
    }

    /**
     * 

     * Reverses the order of the given array in the given range.
     * 

     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverse(final long[] a, int fromIndex, int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        long tmp = 0L; //NOSONAR

        for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

    /**
     * 

     * Reverses the order of the given array.
     * 

     *
     * @param a
     */
    public static void reverse(final float[] a) {
        if (isNullOrEmpty(a)) {
            return;
        }

        reverse(a, 0, a.length);
    }

    /**
     * 

     * Reverses the order of the given array in the given range.
     * 

     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverse(final float[] a, int fromIndex, int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        float tmp = 0f; //NOSONAR

        for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

    /**
     * 

     * Reverses the order of the given array.
     * 

     *
     * @param a
     */
    public static void reverse(final double[] a) {
        if (isNullOrEmpty(a)) {
            return;
        }

        reverse(a, 0, a.length);
    }

    /**
     * 

     * Reverses the order of the given array in the given range.
     * 

     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverse(final double[] a, int fromIndex, int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        double tmp = 0d; //NOSONAR

        for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

    // Reverse
    // -----------------------------------------------------------------------
    /**
     * 

     * Reverses the order of the given array.
     * 

     *
     * 

     * There is no special handling for multi-dimensional arrays.
     * 

     *
     * @param a
     */
    public static void reverse(final Object[] a) {
        if (isNullOrEmpty(a)) {
            return;
        }

        reverse(a, 0, a.length);
    }

    /**
     * 

     * Reverses the order of the given array in the given range.
     * 

     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverse(final Object[] a, int fromIndex, int toIndex) {
        checkFromToIndex(fromIndex, toIndex, len(a));

        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        Object tmp = null;

        for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

    /**
     *
     * @param list
     */
    public static void reverse(final List list) {
        if (isNullOrEmpty(list)) {
            return;
        }

        reverse(list, 0, list.size());
    }

    /**
     *
     * @param list
     * @param fromIndex
     * @param toIndex
     */
    public static void reverse(final List list, int fromIndex, int toIndex) {
        checkFromToIndex(fromIndex, toIndex, size(list));

        if (isNullOrEmpty(list) || list.size() == 1) {
            return;
        }

        final List l = (List) list;

        if (toIndex - fromIndex < REVERSE_THRESHOLD || list instanceof RandomAccess) {
            for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
                l.set(i, l.set(j, l.get(i)));
            }
        } else {
            final ListIterator fwd = l.listIterator(fromIndex);
            final ListIterator rev = l.listIterator(toIndex);

            for (int i = 0, mid = (toIndex - fromIndex) / 2; i < mid; i++) {
                Object tmp = fwd.next();
                fwd.set(rev.previous());
                rev.set(tmp);
            }
        }
    }

    /**
     *
     * @param c
     */
    @SuppressWarnings("rawtypes")
    public static void reverse(final Collection c) {
        if (isNullOrEmpty(c) || c.size() < 2) {
            return;
        }

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

    /**
     *
     * @param a
     * @param distance
     */
    public static void rotate(final boolean[] a, int distance) {
        if (a == null || a.length <= 1 || distance % a.length == 0) {
            return;
        }

        final int len = a.length;
        distance = distance % len;

        if (distance < 0) {
            distance += len;
        }

        if (distance == 0) {
            return;
        }

        for (int i = 0, count = 0; count < len; i++) {
            boolean tmp = a[i];
            int curr = i;
            int next = curr < distance ? curr - distance + len : curr - distance;

            while (next != i) {
                a[curr] = a[next];
                curr = next;
                next = curr < distance ? curr - distance + len : curr - distance;
                count++;
            }

            a[curr] = tmp;
            count++;
        }
    }

    /**
     *
     * @param a
     * @param distance
     */
    public static void rotate(final char[] a, int distance) {
        if (a == null || a.length <= 1 || distance % a.length == 0) {
            return;
        }

        final int len = a.length;
        distance = distance % len;

        if (distance < 0) {
            distance += len;
        }

        if (distance == 0) {
            return;
        }

        for (int i = 0, count = 0; count < len; i++) {
            char tmp = a[i];
            int curr = i;
            int next = curr < distance ? curr - distance + len : curr - distance;

            while (next != i) {
                a[curr] = a[next];
                curr = next;
                next = curr < distance ? curr - distance + len : curr - distance;
                count++;
            }

            a[curr] = tmp;
            count++;
        }
    }

    /**
     *
     * @param a
     * @param distance
     */
    public static void rotate(final byte[] a, int distance) {
        if (a == null || a.length <= 1 || distance % a.length == 0) {
            return;
        }

        final int len = a.length;
        distance = distance % len;

        if (distance < 0) {
            distance += len;
        }

        if (distance == 0) {
            return;
        }

        for (int i = 0, count = 0; count < len; i++) {
            byte tmp = a[i];
            int curr = i;
            int next = curr < distance ? curr - distance + len : curr - distance;

            while (next != i) {
                a[curr] = a[next];
                curr = next;
                next = curr < distance ? curr - distance + len : curr - distance;
                count++;
            }

            a[curr] = tmp;
            count++;
        }
    }

    /**
     *
     * @param a
     * @param distance
     */
    public static void rotate(final short[] a, int distance) {
        if (a == null || a.length <= 1 || distance % a.length == 0) {
            return;
        }

        final int len = a.length;
        distance = distance % len;

        if (distance < 0) {
            distance += len;
        }

        if (distance == 0) {
            return;
        }

        for (int i = 0, count = 0; count < len; i++) {
            short tmp = a[i];
            int curr = i;
            int next = curr < distance ? curr - distance + len : curr - distance;

            while (next != i) {
                a[curr] = a[next];
                curr = next;
                next = curr < distance ? curr - distance + len : curr - distance;
                count++;
            }

            a[curr] = tmp;
            count++;
        }
    }

    /**
     *
     * @param a
     * @param distance
     */
    public static void rotate(final int[] a, int distance) {
        if (a == null || a.length <= 1 || distance % a.length == 0) {
            return;
        }

        final int len = a.length;
        distance = distance % len;

        if (distance < 0) {
            distance += len;
        }

        if (distance == 0) {
            return;
        }

        for (int i = 0, count = 0; count < len; i++) {
            int tmp = a[i];
            int curr = i;
            int next = curr < distance ? curr - distance + len : curr - distance;

            while (next != i) {
                a[curr] = a[next];
                curr = next;
                next = curr < distance ? curr - distance + len : curr - distance;
                count++;
            }

            a[curr] = tmp;
            count++;
        }
    }

    /**
     *
     * @param a
     * @param distance
     */
    public static void rotate(final long[] a, int distance) {
        if (a == null || a.length <= 1 || distance % a.length == 0) {
            return;
        }

        final int len = a.length;
        distance = distance % len;

        if (distance < 0) {
            distance += len;
        }

        if (distance == 0) {
            return;
        }

        for (int i = 0, count = 0; count < len; i++) {
            long tmp = a[i];
            int curr = i;
            int next = curr < distance ? curr - distance + len : curr - distance;

            while (next != i) {
                a[curr] = a[next];
                curr = next;
                next = curr < distance ? curr - distance + len : curr - distance;
                count++;
            }

            a[curr] = tmp;
            count++;
        }
    }

    /**
     *
     * @param a
     * @param distance
     */
    public static void rotate(final float[] a, int distance) {
        if (a == null || a.length <= 1 || distance % a.length == 0) {
            return;
        }

        final int len = a.length;
        distance = distance % len;

        if (distance < 0) {
            distance += len;
        }

        if (distance == 0) {
            return;
        }

        for (int i = 0, count = 0; count < len; i++) {
            float tmp = a[i];
            int curr = i;
            int next = curr < distance ? curr - distance + len : curr - distance;

            while (next != i) {
                a[curr] = a[next];
                curr = next;
                next = curr < distance ? curr - distance + len : curr - distance;
                count++;
            }

            a[curr] = tmp;
            count++;
        }
    }

    /**
     *
     * @param a
     * @param distance
     */
    public static void rotate(final double[] a, int distance) {
        if (a == null || a.length <= 1 || distance % a.length == 0) {
            return;
        }

        final int len = a.length;
        distance = distance % len;

        if (distance < 0) {
            distance += len;
        }

        if (distance == 0) {
            return;
        }

        for (int i = 0, count = 0; count < len; i++) {
            double tmp = a[i];
            int curr = i;
            int next = curr < distance ? curr - distance + len : curr - distance;

            while (next != i) {
                a[curr] = a[next];
                curr = next;
                next = curr < distance ? curr - distance + len : curr - distance;
                count++;
            }

            a[curr] = tmp;
            count++;
        }
    }

    /**
     *
     * @param a
     * @param distance
     */
    public static void rotate(final Object[] a, int distance) {
        if (a == null || a.length <= 1 || distance % a.length == 0) {
            return;
        }

        final int len = a.length;
        distance = distance % len;

        if (distance < 0) {
            distance += len;
        }

        if (distance == 0) {
            return;
        }

        for (int i = 0, count = 0; count < len; i++) {
            Object tmp = a[i];
            int curr = i;
            int next = curr < distance ? curr - distance + len : curr - distance;

            while (next != i) {
                a[curr] = a[next];
                curr = next;
                next = curr < distance ? curr - distance + len : curr - distance;
                count++;
            }

            a[curr] = tmp;
            count++;
        }
    }

    /**
     *
     * @param list
     * @param distance
     * @see java.util.Collections#rotate(List, int)
     */
    public static void rotate(final List list, final int distance) {
        if (list == null || list.size() <= 1 || distance % list.size() == 0) {
            return;
        }

        Collections.rotate(list, distance);
    }

    /**
     *
     * @param c
     * @param distance
     */
    @SuppressWarnings("rawtypes")
    public static void rotate(final Collection c, final int distance) {
        if (isNullOrEmpty(c) || c.size() < 2) {
            return;
        }

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

    /**
     *
     * @param a
     */
    public static void shuffle(final boolean[] a) {
        shuffle(a, RAND);
    }

    /**
     *
     * @param a
     * @param rnd
     */
    public static void shuffle(final boolean[] a, final Random rnd) {
        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        for (int i = a.length; i > 1; i--) {
            swap(a, i - 1, rnd.nextInt(i));
        }
    }

    /**
     *
     * @param a
     */
    public static void shuffle(final char[] a) {
        shuffle(a, RAND);
    }

    /**
     *
     * @param a
     * @param rnd
     */
    public static void shuffle(final char[] a, final Random rnd) {
        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        for (int i = a.length; i > 1; i--) {
            swap(a, i - 1, rnd.nextInt(i));
        }
    }

    /**
     *
     * @param a
     */
    public static void shuffle(final byte[] a) {
        shuffle(a, RAND);
    }

    /**
     *
     * @param a
     * @param rnd
     */
    public static void shuffle(final byte[] a, final Random rnd) {
        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        for (int i = a.length; i > 1; i--) {
            swap(a, i - 1, rnd.nextInt(i));
        }
    }

    /**
     *
     * @param a
     */
    public static void shuffle(final short[] a) {
        shuffle(a, RAND);
    }

    /**
     *
     * @param a
     * @param rnd
     */
    public static void shuffle(final short[] a, final Random rnd) {
        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        for (int i = a.length; i > 1; i--) {
            swap(a, i - 1, rnd.nextInt(i));
        }
    }

    /**
     *
     * @param a
     */
    public static void shuffle(final int[] a) {
        shuffle(a, RAND);
    }

    /**
     *
     * @param a
     * @param rnd
     */
    public static void shuffle(final int[] a, final Random rnd) {
        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        for (int i = a.length; i > 1; i--) {
            swap(a, i - 1, rnd.nextInt(i));
        }
    }

    /**
     *
     * @param a
     */
    public static void shuffle(final long[] a) {
        shuffle(a, RAND);
    }

    /**
     *
     * @param a
     * @param rnd
     */
    public static void shuffle(final long[] a, final Random rnd) {
        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        for (int i = a.length; i > 1; i--) {
            swap(a, i - 1, rnd.nextInt(i));
        }
    }

    /**
     *
     * @param a
     */
    public static void shuffle(final float[] a) {
        shuffle(a, RAND);
    }

    /**
     *
     * @param a
     * @param rnd
     */
    public static void shuffle(final float[] a, final Random rnd) {
        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        for (int i = a.length; i > 1; i--) {
            swap(a, i - 1, rnd.nextInt(i));
        }
    }

    /**
     *
     * @param a
     */
    public static void shuffle(final double[] a) {
        shuffle(a, RAND);
    }

    /**
     *
     * @param a
     * @param rnd
     */
    public static void shuffle(final double[] a, final Random rnd) {
        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        for (int i = a.length; i > 1; i--) {
            swap(a, i - 1, rnd.nextInt(i));
        }
    }

    /**
     *
     * @param 
     * @param a
     */
    public static  void shuffle(final T[] a) {
        shuffle(a, RAND);
    }

    /**
     *
     * @param 
     * @param a
     * @param rnd
     */
    public static  void shuffle(final T[] a, final Random rnd) {
        if (isNullOrEmpty(a) || a.length == 1) {
            return;
        }

        for (int i = a.length; i > 1; i--) {
            swap(a, i - 1, rnd.nextInt(i));
        }
    }

    /**
     *
     * @param list
     */
    public static void shuffle(final List list) {
        shuffle(list, RAND);
    }

    /**
     *
     * @param list
     * @param rnd
     * @see java.util.Collections#shuffle(List, Random)
     */
    public static void shuffle(final List list, final Random rnd) {
        if (isNullOrEmpty(list) || list.size() == 1) {
            return;
        }

        Collections.shuffle(list, rnd);
    }

    /**
     *
     * @param c
     */
    @SuppressWarnings("rawtypes")
    public static void shuffle(final Collection c) {
        if (isNullOrEmpty(c) || c.size() < 2) {
            return;
        }

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

    /**
     *
     * @param c
     * @param rnd
     */
    @SuppressWarnings("rawtypes")
    public static void shuffle(final Collection c, final Random rnd) {
        if (isNullOrEmpty(c) || c.size() < 2) {
            return;
        }

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

    /**
     *
     * @param a
     * @param i
     * @param j
     */
    public static void swap(final boolean[] a, final int i, final int j) {
        final boolean tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     *
     * @param a
     * @param i
     * @param j
     */
    public static void swap(final char[] a, final int i, final int j) {
        final char tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     *
     * @param a
     * @param i
     * @param j
     */
    public static void swap(final byte[] a, final int i, final int j) {
        final byte tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     *
     * @param a
     * @param i
     * @param j
     */
    public static void swap(final short[] a, final int i, final int j) {
        final short tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     *
     * @param a
     * @param i
     * @param j
     */
    public static void swap(final int[] a, final int i, final int j) {
        final int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     *
     * @param a
     * @param i
     * @param j
     */
    public static void swap(final long[] a, final int i, final int j) {
        final long tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     *
     * @param a
     * @param i
     * @param j
     */
    public static void swap(final float[] a, final int i, final int j) {
        final float tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     *
     * @param a
     * @param i
     * @param j
     */
    public static void swap(final double[] a, final int i, final int j) {
        final double tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     *
     * @param a
     * @param i
     * @param j
     */
    public static void swap(final Object[] a, final int i, final int j) {
        final Object tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     *
     * @param list
     * @param i
     * @param j
     */
    public static void swap(final List list, final int i, final int j) {
        Collections.swap(list, i, j);
    }

    /**
     *
     * @param 
     * @param pair
     */
    public static  void swap(final Pair pair) {
        pair.set(pair.right, pair.left);
    }

    /**
     *
     * @param 
     * @param 
     * @param pair
     * @param predicate
     * @return
     * @throws E the e
     */
    public static  boolean swapIf(final Pair pair, Throwables.Predicate, E> predicate) throws E {
        if (predicate.test(pair)) {
            pair.set(pair.right, pair.left);
            return true;
        }

        return false;
    }

    /**
     *
     * @param 
     * @param 
     * @param triple
     */
    public static  void swap(final Triple triple) {
        final T left = triple.left;
        triple.setLeft(triple.right);
        triple.setRight(left);
    }

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param triple
     * @param predicate
     * @return
     * @throws E the e
     */
    public static  boolean swapIf(final Triple triple, Throwables.Predicate, E> predicate)
            throws E {
        if (predicate.test(triple)) {
            final T left = triple.left;
            triple.setLeft(triple.right);
            triple.setRight(left);
            return true;
        }

        return false;
    }

    /**
     *
     * @param a
     * @param val
     */
    public static void fill(final boolean[] a, final boolean val) {
        Arrays.fill(a, val);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param val
     */
    public static void fill(final boolean[] a, final int fromIndex, final int toIndex, final boolean val) {
        Arrays.fill(a, fromIndex, toIndex, val);
    }

    /**
     *
     * @param a
     * @param val
     */
    public static void fill(final char[] a, final char val) {
        Arrays.fill(a, val);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param val
     */
    public static void fill(final char[] a, final int fromIndex, final int toIndex, final char val) {
        Arrays.fill(a, fromIndex, toIndex, val);
    }

    /**
     *
     * @param a
     * @param val
     */
    public static void fill(final byte[] a, final byte val) {
        Arrays.fill(a, val);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param val
     */
    public static void fill(final byte[] a, final int fromIndex, final int toIndex, final byte val) {
        Arrays.fill(a, fromIndex, toIndex, val);
    }

    /**
     *
     * @param a
     * @param val
     */
    public static void fill(final short[] a, final short val) {
        Arrays.fill(a, val);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param val
     */
    public static void fill(final short[] a, final int fromIndex, final int toIndex, final short val) {
        Arrays.fill(a, fromIndex, toIndex, val);
    }

    /**
     *
     * @param a
     * @param val
     */
    public static void fill(final int[] a, final int val) {
        Arrays.fill(a, val);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param val
     */
    public static void fill(final int[] a, final int fromIndex, final int toIndex, final int val) {
        Arrays.fill(a, fromIndex, toIndex, val);
    }

    /**
     *
     * @param a
     * @param val
     */
    public static void fill(final long[] a, final long val) {
        Arrays.fill(a, val);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param val
     */
    public static void fill(final long[] a, final int fromIndex, final int toIndex, final long val) {
        Arrays.fill(a, fromIndex, toIndex, val);
    }

    /**
     *
     * @param a
     * @param val
     */
    public static void fill(final float[] a, final float val) {
        Arrays.fill(a, val);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param val
     */
    public static void fill(final float[] a, final int fromIndex, final int toIndex, final float val) {
        Arrays.fill(a, fromIndex, toIndex, val);
    }

    /**
     *
     * @param a
     * @param val
     */
    public static void fill(final double[] a, final double val) {
        Arrays.fill(a, val);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param val
     */
    public static void fill(final double[] a, final int fromIndex, final int toIndex, final double val) {
        Arrays.fill(a, fromIndex, toIndex, val);
    }

    /**
     *
     * @param a
     * @param val
     */
    public static void fill(final Object[] a, final Object val) {
        Arrays.fill(a, val);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param val
     */
    public static void fill(final Object[] a, final int fromIndex, final int toIndex, final Object val) {
        Arrays.fill(a, fromIndex, toIndex, val);
    }

    /**
     *
     * @param 
     * @param list
     * @param val
     */
    public static  void fill(final List list, final T val) {
        fill(list, 0, list.size(), val);
    }

    /**
     * The specified value will be added/inserted into the specified List.
     * The List will be extended automatically if the size of the List is less than the specified toIndex.
     *
     * @param 
     * @param list
     * @param fromIndex
     * @param toIndex
     * @param val
     */
    public static  void fill(final List list, final int fromIndex, final int toIndex, final T val) {
        checkFromToIndex(fromIndex, toIndex, Integer.MAX_VALUE);

        int size = list.size();

        if (size < toIndex) {
            if (fromIndex < size) {
                for (int i = fromIndex; i < size; i++) {
                    list.set(i, val);
                }
            } else {
                for (int i = size; i < fromIndex; i++) {
                    list.add(null);
                }
            }

            for (int i = 0, len = toIndex - list.size(); i < len; i++) {
                list.add(val);
            }
        } else {
            if (toIndex - fromIndex < FILL_THRESHOLD || list instanceof RandomAccess) {
                for (int i = fromIndex; i < toIndex; i++) {
                    list.set(i, val);
                }
            } else {
                final ListIterator itr = list.listIterator(fromIndex);

                for (int i = fromIndex; i < toIndex; i++) {
                    itr.next();

                    itr.set(val);
                }
            }
        }
    }

    /**
     * Fill the properties of the bean with random values.
     *
     * @param bean a bean object with getter/setter method
     */
    public static void fill(Object bean) {
        TestUtil.fill(bean);
    }

    /**
     * Fill the properties of the bean with random values.
     *
     * @param 
     * @param beanClass bean class with getter/setter methods
     * @return
     */
    public static  T fill(Class beanClass) {
        return TestUtil.fill(beanClass);
    }

    /**
     * Fill the properties of the bean with random values.
     *
     * @param 
     * @param beanClass bean class with getter/setter methods
     * @param count
     * @return
     */
    public static  List fill(Class beanClass, int count) {
        return TestUtil.fill(beanClass, count);
    }

    /**
     *
     * @param 
     * @param value
     * @param n
     * @return
     */
    public static  List repeat(final T value, final int n) {
        checkArgNotNegative(n, "n");

        final List res = new ArrayList<>(n);
        fill(res, 0, n, value);
        return res;
    }

    /**
     * Repeats the elements in the specified Collection one by one.
     *
     * 
     * 
     * repeatEach(N.asList(1, 2, 3), 2) => [1, 1, 2, 2, 3, 3]
     * 
     * 

     *
     * @param 
     * @param c
     * @param n
     * @return
     */
    public static  List repeatEach(final Collection c, final int n) {
        checkArgNotNegative(n, "n");

        if (n == 0 || 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;
    }

    /**
     * 
     * 
     * repeatAll(N.asList(1, 2, 3), 2) => [1, 2, 3, 1, 2, 3]
     * 
     * 

     *
     * @param 
     * @param c
     * @param n
     * @return
     */
    public static  List repeatAll(final Collection c, final int n) {
        checkArgNotNegative(n, "n");

        if (n == 0 || isNullOrEmpty(c)) {
            return new ArrayList<>();
        }

        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 till reach the specified size.
     *
     * 
     * 
     * repeatEachToSize(N.asList(1, 2, 3), 5) => [1, 1, 2, 2, 3]
     * 
     * 

     *
     * @param 
     * @param c
     * @param size
     * @return
     */
    public static  List repeatEachToSize(final Collection c, final int size) {
        checkArgNotNegative(size, "size");
        checkArgument(size == 0 || notNullOrEmpty(c), "Collection can not be empty or null when size > 0");

        if (size == 0 || 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;
    }

    /**
     * 
     * 
     * repeatAllToSize(N.asList(1, 2, 3), 5) => [1, 2, 3, 1, 2]
     * 
     * 

     *
     * @param 
     * @param c
     * @param size
     * @return
     */
    public static  List repeatAllToSize(final Collection c, final int size) {
        checkArgNotNegative(size, "size");
        checkArgument(size == 0 || notNullOrEmpty(c), "Collection can not be empty or null when size > 0");

        if (size == 0 || 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;
    }

    /**
     * Copies all of the elements from one list into another.  After the
     * operation, the index of each copied element in the destination list
     * will be identical to its index in the source list.  The destination
     * list must be at least as long as the source list.  If it is longer, the
     * remaining elements in the destination list are unaffected. 

     *
     * This method runs in linear time.
     *
     * @param 
     * @param src
     * @param dest
     * @throws IndexOutOfBoundsException if the destination list is too small
     *         to contain the entire source List.
     * @throws UnsupportedOperationException if the destination list's
     *         list-iterator does not support the set operation.
     * @see java.util.Collections#copy(List, List)
     */
    public static  void copy(final List src, final List dest) {
        if (src.size() > dest.size()) {
            throw new IllegalArgumentException("Source does not fit in dest");
        }

        Collections.copy(dest, src);
    }

    /**
     *
     * @param 
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     */
    public static  void copy(final List src, final int srcPos, final List dest, final int destPos, final int length) {
        if (src.size() < srcPos + length) {
            throw new IllegalArgumentException("The size of src list less than " + (srcPos + length));
        }

        if (dest.size() < destPos + length) {
            throw new IllegalArgumentException("The size of dest list less than " + (destPos + length));
        }

        if (src instanceof RandomAccess && dest instanceof RandomAccess) {
            for (int i = 0; i < length; i++) {
                dest.set(destPos + i, src.get(srcPos + i));
            }
        } else {
            final ListIterator srcIterator = src.listIterator();
            final ListIterator destIterator = dest.listIterator();

            int idx = 0;
            while (idx < srcPos) {
                srcIterator.next();
                idx++;
            }

            idx = 0;
            while (idx < destPos) {
                destIterator.next();
                idx++;
            }

            for (int i = 0; i < length; i++) {
                destIterator.next();
                destIterator.set(srcIterator.next());
            }
        }
    }

    /**
     *
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     */
    public static void copy(final boolean[] src, final int srcPos, final boolean[] dest, final int destPos, final int length) {
        if (src.length < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (dest.length < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        if (length < MIN_SIZE_FOR_COPY_ALL) {
            // for same array copy.
            if (destPos > srcPos) {
                for (int i = length - 1; i >= 0; i--) {
                    dest[destPos + i] = src[srcPos + i];
                }
            } else {
                for (int i = 0; i < length; i++) {
                    dest[destPos + i] = src[srcPos + i];
                }
            }
        } else {
            System.arraycopy(src, srcPos, dest, destPos, length);
        }
    }

    /**
     *
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     */
    public static void copy(final char[] src, final int srcPos, final char[] dest, final int destPos, final int length) {
        if (src.length < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (dest.length < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        if (length < MIN_SIZE_FOR_COPY_ALL) {
            // for same array copy.
            if (destPos > srcPos) {
                for (int i = length - 1; i >= 0; i--) {
                    dest[destPos + i] = src[srcPos + i];
                }
            } else {
                for (int i = 0; i < length; i++) {
                    dest[destPos + i] = src[srcPos + i];
                }
            }
        } else {
            System.arraycopy(src, srcPos, dest, destPos, length);
        }
    }

    /**
     *
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     */
    public static void copy(final byte[] src, final int srcPos, final byte[] dest, final int destPos, final int length) {
        if (src.length < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (dest.length < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        if (length < MIN_SIZE_FOR_COPY_ALL) {
            // for same array copy.
            if (destPos > srcPos) {
                for (int i = length - 1; i >= 0; i--) {
                    dest[destPos + i] = src[srcPos + i];
                }
            } else {
                for (int i = 0; i < length; i++) {
                    dest[destPos + i] = src[srcPos + i];
                }
            }
        } else {
            System.arraycopy(src, srcPos, dest, destPos, length);
        }
    }

    /**
     *
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     */
    public static void copy(final short[] src, final int srcPos, final short[] dest, final int destPos, final int length) {
        if (src.length < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (dest.length < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        if (length < MIN_SIZE_FOR_COPY_ALL) {
            // for same array copy.
            if (destPos > srcPos) {
                for (int i = length - 1; i >= 0; i--) {
                    dest[destPos + i] = src[srcPos + i];
                }
            } else {
                for (int i = 0; i < length; i++) {
                    dest[destPos + i] = src[srcPos + i];
                }
            }
        } else {
            System.arraycopy(src, srcPos, dest, destPos, length);
        }
    }

    /**
     *
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     */
    public static void copy(final int[] src, final int srcPos, final int[] dest, final int destPos, final int length) {
        if (src.length < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (dest.length < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        if (length < MIN_SIZE_FOR_COPY_ALL) {
            // for same array copy.
            if (destPos > srcPos) {
                for (int i = length - 1; i >= 0; i--) {
                    dest[destPos + i] = src[srcPos + i];
                }
            } else {
                for (int i = 0; i < length; i++) {
                    dest[destPos + i] = src[srcPos + i];
                }
            }
        } else {
            System.arraycopy(src, srcPos, dest, destPos, length);
        }
    }

    /**
     *
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     */
    public static void copy(final long[] src, final int srcPos, final long[] dest, final int destPos, final int length) {
        if (src.length < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (dest.length < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        if (length < MIN_SIZE_FOR_COPY_ALL) {
            // for same array copy.
            if (destPos > srcPos) {
                for (int i = length - 1; i >= 0; i--) {
                    dest[destPos + i] = src[srcPos + i];
                }
            } else {
                for (int i = 0; i < length; i++) {
                    dest[destPos + i] = src[srcPos + i];
                }
            }
        } else {
            System.arraycopy(src, srcPos, dest, destPos, length);
        }
    }

    /**
     *
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     */
    public static void copy(final float[] src, final int srcPos, final float[] dest, final int destPos, final int length) {
        if (src.length < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (dest.length < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        if (length < MIN_SIZE_FOR_COPY_ALL) {
            // for same array copy.
            if (destPos > srcPos) {
                for (int i = length - 1; i >= 0; i--) {
                    dest[destPos + i] = src[srcPos + i];
                }
            } else {
                for (int i = 0; i < length; i++) {
                    dest[destPos + i] = src[srcPos + i];
                }
            }
        } else {
            System.arraycopy(src, srcPos, dest, destPos, length);
        }
    }

    /**
     *
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     */
    public static void copy(final double[] src, final int srcPos, final double[] dest, final int destPos, final int length) {
        if (src.length < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (dest.length < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        if (length < MIN_SIZE_FOR_COPY_ALL) {
            // for same array copy.
            if (destPos > srcPos) {
                for (int i = length - 1; i >= 0; i--) {
                    dest[destPos + i] = src[srcPos + i];
                }
            } else {
                for (int i = 0; i < length; i++) {
                    dest[destPos + i] = src[srcPos + i];
                }
            }
        } else {
            System.arraycopy(src, srcPos, dest, destPos, length);
        }
    }

    /**
     *
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     */
    public static void copy(final Object[] src, final int srcPos, final Object[] dest, final int destPos, final int length) {
        if (src.length < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (dest.length < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        if (length < MIN_SIZE_FOR_COPY_ALL) {
            // for same array copy.
            if (destPos > srcPos) {
                for (int i = length - 1; i >= 0; i--) {
                    dest[destPos + i] = src[srcPos + i];
                }
            } else {
                for (int i = 0; i < length; i++) {
                    dest[destPos + i] = src[srcPos + i];
                }
            }
        } else {
            System.arraycopy(src, srcPos, dest, destPos, length);
        }
    }

    /**
     *
     * @param src
     * @param srcPos
     * @param dest
     * @param destPos
     * @param length
     * @see System#arraycopy(Object, int, Object, int, int) is called
     */
    public static void copy(final Object src, final int srcPos, final Object dest, final int destPos, final int length) {
        if (Array.getLength(src) < srcPos + length) {
            throw new IllegalArgumentException("The size of src array less than " + (srcPos + length));
        }

        if (Array.getLength(dest) < destPos + length) {
            throw new IllegalArgumentException("The size of dest array less than " + (destPos + length));
        }

        System.arraycopy(src, srcPos, dest, destPos, length);
    }

    /**
     *
     * @param original
     * @param newLength
     * @return
     * @see Arrays#copyOf(boolean[], int)
     */
    public static boolean[] copyOf(final boolean[] original, final int newLength) {
        if (newLength == original.length) {
            return original.clone();
        }

        final boolean[] copy = new boolean[newLength];

        if (notNullOrEmpty(original)) {
            copy(original, 0, copy, 0, Math.min(original.length, newLength));
        }

        return copy;
    }

    /**
     *
     * @param original
     * @param newLength
     * @return
     * @see Arrays#copyOf(char[], int)
     */
    public static char[] copyOf(final char[] original, final int newLength) {
        if (newLength == original.length) {
            return original.clone();
        }

        final char[] copy = new char[newLength];

        if (notNullOrEmpty(original)) {
            copy(original, 0, copy, 0, Math.min(original.length, newLength));
        }

        return copy;
    }

    /**
     *
     * @param original
     * @param newLength
     * @return
     * @see Arrays#copyOf(byte[], int)
     */
    public static byte[] copyOf(final byte[] original, final int newLength) {
        if (newLength == original.length) {
            return original.clone();
        }

        final byte[] copy = new byte[newLength];

        if (notNullOrEmpty(original)) {
            copy(original, 0, copy, 0, Math.min(original.length, newLength));
        }

        return copy;
    }

    /**
     *
     * @param original
     * @param newLength
     * @return
     * @see Arrays#copyOf(short[], int)
     */
    public static short[] copyOf(final short[] original, final int newLength) {
        if (newLength == original.length) {
            return original.clone();
        }

        final short[] copy = new short[newLength];

        if (notNullOrEmpty(original)) {
            copy(original, 0, copy, 0, Math.min(original.length, newLength));
        }

        return copy;
    }

    /**
     *
     * @param original
     * @param newLength
     * @return
     * @see Arrays#copyOf(int[], int)
     */
    public static int[] copyOf(final int[] original, final int newLength) {
        if (newLength == original.length) {
            return original.clone();
        }

        final int[] copy = new int[newLength];

        if (notNullOrEmpty(original)) {
            copy(original, 0, copy, 0, Math.min(original.length, newLength));
        }

        return copy;
    }

    /**
     *
     * @param original
     * @param newLength
     * @return
     * @see Arrays#copyOf(long[], int)
     */
    public static long[] copyOf(final long[] original, final int newLength) {
        if (newLength == original.length) {
            return original.clone();
        }

        final long[] copy = new long[newLength];

        if (notNullOrEmpty(original)) {
            copy(original, 0, copy, 0, Math.min(original.length, newLength));
        }

        return copy;
    }

    /**
     *
     * @param original
     * @param newLength
     * @return
     * @see Arrays#copyOf(float[], int)
     */
    public static float[] copyOf(final float[] original, final int newLength) {
        if (newLength == original.length) {
            return original.clone();
        }

        final float[] copy = new float[newLength];

        if (notNullOrEmpty(original)) {
            copy(original, 0, copy, 0, Math.min(original.length, newLength));
        }

        return copy;
    }

    /**
     *
     * @param original
     * @param newLength
     * @return
     * @see Arrays#copyOf(double[], int)
     */
    public static double[] copyOf(final double[] original, final int newLength) {
        if (newLength == original.length) {
            return original.clone();
        }

        final double[] copy = new double[newLength];

        if (notNullOrEmpty(original)) {
            copy(original, 0, copy, 0, Math.min(original.length, newLength));
        }

        return copy;
    }

    /**
     *
     * @param 
     * @param original
     * @param newLength
     * @return
     * @see Arrays#copyOf(Object[], int)
     */
    public static  T[] copyOf(final T[] original, final int newLength) {
        if (newLength == original.length) {
            return original.clone();
        }

        return (T[]) copyOf(original, newLength, original.getClass());
    }

    /**
     *
     * @param 
     * @param 
     * @param original
     * @param newLength
     * @param newType
     * @return
     * @see Arrays#copyOf(Object[], int, Class)
     */
    public static  T[] copyOf(final U[] original, final int newLength, final Class newType) {
        final T[] copy = Object[].class.equals(newType) ? (T[]) new Object[newLength] : (T[]) newArray(newType.getComponentType(), newLength);

        if (notNullOrEmpty(original)) {
            copy(original, 0, copy, 0, Math.min(original.length, newLength));
        }

        return copy;
    }

    /**
     * Copy of range.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @return
     * @see Arrays#copyOfRange(boolean[], int, int)
     */
    public static boolean[] copyOfRange(final boolean[] original, final int fromIndex, final int toIndex) {
        if (fromIndex == 0 && toIndex == original.length) {
            return original.clone();
        }

        final int newLength = toIndex - fromIndex;
        final boolean[] copy = new boolean[newLength];
        copy(original, fromIndex, copy, 0, Math.min(original.length - fromIndex, newLength));
        return copy;
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     * @see copyOfRange(int[], int, int, int)
     */
    public static boolean[] copyOfRange(final boolean[] original, int fromIndex, final int toIndex, final int step) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, original.length);

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return EMPTY_BOOLEAN_ARRAY;
        }

        if (step == 1) {
            return copyOfRange(original, fromIndex, toIndex);
        }

        fromIndex = fromIndex > toIndex ? N.min(original.length - 1, fromIndex) : fromIndex;
        final int len = (toIndex - fromIndex) / step + ((toIndex - fromIndex) % step == 0 ? 0 : 1);
        final boolean[] copy = new boolean[len];

        for (int i = 0, j = fromIndex; i < len; i++, j += step) {
            copy[i] = original[j];
        }

        return copy;
    }

    /**
     * Copy of range.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @return
     * @see Arrays#copyOfRange(char[], int, int)
     */
    public static char[] copyOfRange(final char[] original, final int fromIndex, final int toIndex) {
        if (fromIndex == 0 && toIndex == original.length) {
            return original.clone();
        }

        final int newLength = toIndex - fromIndex;
        final char[] copy = new char[newLength];
        copy(original, fromIndex, copy, 0, Math.min(original.length - fromIndex, newLength));
        return copy;
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     * @see copyOfRange(int[], int, int, int)
     */
    public static char[] copyOfRange(final char[] original, int fromIndex, final int toIndex, final int step) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, original.length);

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return EMPTY_CHAR_ARRAY;
        }

        if (step == 1) {
            return copyOfRange(original, fromIndex, toIndex);
        }

        fromIndex = fromIndex > toIndex ? N.min(original.length - 1, fromIndex) : fromIndex;
        final int len = (toIndex - fromIndex) / step + ((toIndex - fromIndex) % step == 0 ? 0 : 1);
        final char[] copy = new char[len];

        for (int i = 0, j = fromIndex; i < len; i++, j += step) {
            copy[i] = original[j];
        }

        return copy;
    }

    /**
     * Copy of range.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @return
     * @see Arrays#copyOfRange(byte[], int, int)
     */
    public static byte[] copyOfRange(final byte[] original, final int fromIndex, final int toIndex) {
        if (fromIndex == 0 && toIndex == original.length) {
            return original.clone();
        }

        final int newLength = toIndex - fromIndex;
        final byte[] copy = new byte[newLength];
        copy(original, fromIndex, copy, 0, Math.min(original.length - fromIndex, newLength));
        return copy;
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     * @see copyOfRange(int[], int, int, int)
     */
    public static byte[] copyOfRange(final byte[] original, int fromIndex, final int toIndex, final int step) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, original.length);

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return EMPTY_BYTE_ARRAY;
        }

        if (step == 1) {
            return copyOfRange(original, fromIndex, toIndex);
        }

        fromIndex = fromIndex > toIndex ? N.min(original.length - 1, fromIndex) : fromIndex;
        final int len = (toIndex - fromIndex) / step + ((toIndex - fromIndex) % step == 0 ? 0 : 1);
        final byte[] copy = new byte[len];

        for (int i = 0, j = fromIndex; i < len; i++, j += step) {
            copy[i] = original[j];
        }

        return copy;
    }

    /**
     * Copy of range.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @return
     * @see Arrays#copyOfRange(short[], int, int)
     */
    public static short[] copyOfRange(final short[] original, final int fromIndex, final int toIndex) {
        if (fromIndex == 0 && toIndex == original.length) {
            return original.clone();
        }

        final int newLength = toIndex - fromIndex;
        final short[] copy = new short[newLength];
        copy(original, fromIndex, copy, 0, Math.min(original.length - fromIndex, newLength));
        return copy;
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     * @see copyOfRange(int[], int, int, int)
     */
    public static short[] copyOfRange(final short[] original, int fromIndex, final int toIndex, final int step) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, original.length);

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return EMPTY_SHORT_ARRAY;
        }

        if (step == 1) {
            return copyOfRange(original, fromIndex, toIndex);
        }

        fromIndex = fromIndex > toIndex ? N.min(original.length - 1, fromIndex) : fromIndex;
        final int len = (toIndex - fromIndex) / step + ((toIndex - fromIndex) % step == 0 ? 0 : 1);
        final short[] copy = new short[len];

        for (int i = 0, j = fromIndex; i < len; i++, j += step) {
            copy[i] = original[j];
        }

        return copy;
    }

    /**
     * Copy of range.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @return
     * @see Arrays#copyOfRange(int[], int, int)
     */
    public static int[] copyOfRange(final int[] original, final int fromIndex, final int toIndex) {
        if (fromIndex == 0 && toIndex == original.length) {
            return original.clone();
        }

        final int newLength = toIndex - fromIndex;
        final int[] copy = new int[newLength];
        copy(original, fromIndex, copy, 0, Math.min(original.length - fromIndex, newLength));
        return copy;
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * 
     * 
     * int[] a = { 0, 1, 2, 3, 4, 5 };
     * N.copyOfRange(a, 1, 5, 1)); // [1, 2, 3, 4]
     * N.copyOfRange(a, 1, 5, 2); // [1, 3]
     *
     * N.copyOfRange(a, 5, 1, -1); // [5, 4, 3, 2]
     * N.copyOfRange(a, 5, 1, -2); // [5, 3]
     * N.copyOfRange(a, 5, -1, -1); // [5, 4, 3, 2, 1, 0]
     * N.copyOfRange(a, 6, -1, -1); // [5, 4, 3, 2, 1, 0]
     * 
     * 

     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     */
    public static int[] copyOfRange(final int[] original, int fromIndex, final int toIndex, final int step) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, original.length);

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return EMPTY_INT_ARRAY;
        }

        if (step == 1) {
            return copyOfRange(original, fromIndex, toIndex);
        }

        fromIndex = fromIndex > toIndex ? N.min(original.length - 1, fromIndex) : fromIndex;
        final int len = (toIndex - fromIndex) / step + ((toIndex - fromIndex) % step == 0 ? 0 : 1);
        final int[] copy = new int[len];

        for (int i = 0, j = fromIndex; i < len; i++, j += step) {
            copy[i] = original[j];
        }

        return copy;
    }

    /**
     * Copy of range.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @return
     * @see Arrays#copyOfRange(long[], int, int)
     */
    public static long[] copyOfRange(final long[] original, final int fromIndex, final int toIndex) {
        if (fromIndex == 0 && toIndex == original.length) {
            return original.clone();
        }

        final int newLength = toIndex - fromIndex;
        final long[] copy = new long[newLength];
        copy(original, fromIndex, copy, 0, Math.min(original.length - fromIndex, newLength));
        return copy;
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     * @see copyOfRange(int[], int, int, int)
     */
    public static long[] copyOfRange(final long[] original, int fromIndex, final int toIndex, final int step) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, original.length);

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return EMPTY_LONG_ARRAY;
        }

        if (step == 1) {
            return copyOfRange(original, fromIndex, toIndex);
        }

        fromIndex = fromIndex > toIndex ? N.min(original.length - 1, fromIndex) : fromIndex;
        final int len = (toIndex - fromIndex) / step + ((toIndex - fromIndex) % step == 0 ? 0 : 1);
        final long[] copy = new long[len];

        for (int i = 0, j = fromIndex; i < len; i++, j += step) {
            copy[i] = original[j];
        }

        return copy;
    }

    /**
     * Copy of range.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @return
     * @see Arrays#copyOfRange(float[], int, int)
     */
    public static float[] copyOfRange(final float[] original, final int fromIndex, final int toIndex) {
        if (fromIndex == 0 && toIndex == original.length) {
            return original.clone();
        }

        final int newLength = toIndex - fromIndex;
        final float[] copy = new float[newLength];
        copy(original, fromIndex, copy, 0, Math.min(original.length - fromIndex, newLength));
        return copy;
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     * @see copyOfRange(int[], int, int, int)
     */
    public static float[] copyOfRange(final float[] original, int fromIndex, final int toIndex, final int step) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, original.length);

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return EMPTY_FLOAT_ARRAY;
        }

        if (step == 1) {
            return copyOfRange(original, fromIndex, toIndex);
        }

        fromIndex = fromIndex > toIndex ? N.min(original.length - 1, fromIndex) : fromIndex;
        final int len = (toIndex - fromIndex) / step + ((toIndex - fromIndex) % step == 0 ? 0 : 1);
        final float[] copy = new float[len];

        for (int i = 0, j = fromIndex; i < len; i++, j += step) {
            copy[i] = original[j];
        }

        return copy;
    }

    /**
     * Copy of range.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @return
     * @see Arrays#copyOfRange(double[], int, int)
     */
    public static double[] copyOfRange(final double[] original, final int fromIndex, final int toIndex) {
        if (fromIndex == 0 && toIndex == original.length) {
            return original.clone();
        }

        final int newLength = toIndex - fromIndex;
        final double[] copy = new double[newLength];
        copy(original, fromIndex, copy, 0, Math.min(original.length - fromIndex, newLength));
        return copy;
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     * @see copyOfRange(int[], int, int, int)
     */
    public static double[] copyOfRange(final double[] original, int fromIndex, final int toIndex, final int step) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, original.length);

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return EMPTY_DOUBLE_ARRAY;
        }

        if (step == 1) {
            return copyOfRange(original, fromIndex, toIndex);
        }

        fromIndex = fromIndex > toIndex ? N.min(original.length - 1, fromIndex) : fromIndex;
        final int len = (toIndex - fromIndex) / step + ((toIndex - fromIndex) % step == 0 ? 0 : 1);
        final double[] copy = new double[len];

        for (int i = 0, j = fromIndex; i < len; i++, j += step) {
            copy[i] = original[j];
        }

        return copy;
    }

    /**
     * Copy of range.
     *
     * @param 
     * @param original
     * @param fromIndex
     * @param toIndex
     * @return
     * @see Arrays#copyOfRange(T[], int, int)
     */
    public static  T[] copyOfRange(final T[] original, final int fromIndex, final int toIndex) {
        if (fromIndex == 0 && toIndex == original.length) {
            return original.clone();
        }

        return copyOfRange(original, fromIndex, toIndex, (Class) original.getClass());
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * @param 
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     */
    public static  T[] copyOfRange(final T[] original, final int fromIndex, final int toIndex, final int step) {
        return copyOfRange(original, fromIndex, toIndex, step, (Class) original.getClass());
    }

    /**
     * {@link Arrays#copyOfRange(Object[], int, int, Class)}.
     *
     * @param 
     * @param 
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param newType
     * @return
     */
    public static  T[] copyOfRange(final U[] original, final int fromIndex, final int toIndex, final Class newType) {
        final int newLength = toIndex - fromIndex;
        final T[] copy = Object[].class.equals(newType) ? (T[]) new Object[newLength] : (T[]) newArray(newType.getComponentType(), newLength);
        copy(original, fromIndex, copy, 0, Math.min(original.length - fromIndex, newLength));
        return copy;
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * @param 
     * @param original
     * @param fromIndex
     * @param toIndex
     * @param step
     * @param newType
     * @return
     * @see copyOfRange(int[], int, int, int)
     */
    public static  T[] copyOfRange(final T[] original, int fromIndex, final int toIndex, final int step, final Class newType) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, original.length);

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return Object[].class.equals(newType) ? (T[]) new Object[0] : (T[]) newArray(newType.getComponentType(), 0);
        }

        if (step == 1) {
            return copyOfRange(original, fromIndex, toIndex);
        }

        fromIndex = fromIndex > toIndex ? N.min(original.length - 1, fromIndex) : fromIndex;
        final int len = (toIndex - fromIndex) / step + ((toIndex - fromIndex) % step == 0 ? 0 : 1);
        final T[] copy = Object[].class.equals(newType) ? (T[]) new Object[len] : (T[]) newArray(newType.getComponentType(), len);

        for (int i = 0, j = fromIndex; i < len; i++, j += step) {
            copy[i] = original[j];
        }

        return copy;
    }

    /**
     * Copy of range.
     *
     * @param 
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     * @see Arrays#copyOfRange(T[], int, int)
     */
    public static  List copyOfRange(final List c, final int fromIndex, final int toIndex) {
        checkFromToIndex(fromIndex, toIndex, c.size());

        final List result = new ArrayList<>(toIndex - fromIndex);
        result.addAll(c.subList(fromIndex, toIndex));
        return result;
    }

    /**
     * Copy all the elements in original, through to-from, by step.
     *
     * @param 
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     */
    @SuppressWarnings("deprecation")
    public static  List copyOfRange(final List c, int fromIndex, final int toIndex, final int step) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, c.size());

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return new ArrayList<>();
        }

        if (step == 1) {
            return copyOfRange(c, fromIndex, toIndex);
        }

        fromIndex = fromIndex > toIndex ? N.min(c.size() - 1, fromIndex) : fromIndex;
        final int len = (toIndex - fromIndex) / step + ((toIndex - fromIndex) % step == 0 ? 0 : 1);
        List result = null;

        if (c instanceof RandomAccess) {
            result = new ArrayList<>(len);

            for (int i = 0, j = fromIndex; i < len; i++, j += step) {
                result.add(c.get(j));
            }
        } else {
            final T[] a = (T[]) c.subList(fromIndex, toIndex).toArray();
            result = InternalUtil.createList(copyOfRange(a, 0, a.length, step));
        }

        return result;
    }

    /**
     * Copy of range.
     *
     * @param str
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static String copyOfRange(final String str, final int fromIndex, final int toIndex) {
        return str.substring(fromIndex, toIndex);
    }

    /**
     * Copy of range.
     *
     * @param str
     * @param fromIndex
     * @param toIndex
     * @param step
     * @return
     * @see copyOfRange(int[], int, int, int)
     */
    @SuppressWarnings("deprecation")
    public static String copyOfRange(final String str, int fromIndex, final int toIndex, final int step) {
        checkFromToIndex(fromIndex < toIndex ? fromIndex : (toIndex == -1 ? 0 : toIndex), fromIndex < toIndex ? toIndex : fromIndex, str.length());

        if (step == 0) {
            throw new IllegalArgumentException("The input parameter 'by' can not be zero");
        }

        if (fromIndex == toIndex || fromIndex < toIndex != step > 0) {
            return EMPTY_STRING;
        }

        if (step == 1) {
            return copyOfRange(str, fromIndex, toIndex);
        }

        return InternalUtil.newString(copyOfRange(InternalUtil.getCharsForReadOnly(str), fromIndex, toIndex, step), true);
    }

    /**
     * Clone the original array. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static boolean[] clone(final boolean[] original) {
        if (original == null) {
            return null;
        }

        return original.clone();
    }

    /**
     * Clone the original array. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static char[] clone(final char[] original) {
        if (original == null) {
            return null;
        }

        return original.clone();
    }

    /**
     * Clone the original array. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static byte[] clone(final byte[] original) {
        if (original == null) {
            return null;
        }

        return original.clone();
    }

    /**
     * Clone the original array. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static short[] clone(final short[] original) {
        if (original == null) {
            return null;
        }

        return original.clone();
    }

    /**
     * Clone the original array. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static int[] clone(final int[] original) {
        if (original == null) {
            return null;
        }

        return original.clone();
    }

    /**
     * Clone the original array. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static long[] clone(final long[] original) {
        if (original == null) {
            return null;
        }

        return original.clone();
    }

    /**
     * Clone the original array. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static float[] clone(final float[] original) {
        if (original == null) {
            return null;
        }

        return original.clone();
    }

    /**
     * Clone the original array. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static double[] clone(final double[] original) {
        if (original == null) {
            return null;
        }

        return original.clone();
    }

    /**
     * Clone the original array. null is returned if the input array is null.
     *
     * @param 
     * @param original
     * @return
     */
    public static  T[] clone(final T[] original) {
        if (original == null) {
            return null;
        }

        return original.clone();
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static boolean[][] clone(final boolean[][] original) {
        if (original == null) {
            return null;
        }

        final boolean[][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static char[][] clone(final char[][] original) {
        if (original == null) {
            return null;
        }

        final char[][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static byte[][] clone(final byte[][] original) {
        if (original == null) {
            return null;
        }

        final byte[][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static short[][] clone(final short[][] original) {
        if (original == null) {
            return null;
        }

        final short[][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static int[][] clone(final int[][] original) {
        if (original == null) {
            return null;
        }

        final int[][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static long[][] clone(final long[][] original) {
        if (original == null) {
            return null;
        }

        final long[][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static float[][] clone(final float[][] original) {
        if (original == null) {
            return null;
        }

        final float[][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static double[][] clone(final double[][] original) {
        if (original == null) {
            return null;
        }

        final double[][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param 
     * @param original
     * @return
     */
    public static  T[][] clone(final T[][] original) {
        if (original == null) {
            return null;
        }

        final T[][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static boolean[][][] clone(final boolean[][][] original) {
        if (original == null) {
            return null;
        }

        final boolean[][][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static char[][][] clone(final char[][][] original) {
        if (original == null) {
            return null;
        }

        final char[][][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static byte[][][] clone(final byte[][][] original) {
        if (original == null) {
            return null;
        }

        final byte[][][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static short[][][] clone(final short[][][] original) {
        if (original == null) {
            return null;
        }

        final short[][][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static int[][][] clone(final int[][][] original) {
        if (original == null) {
            return null;
        }

        final int[][][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static long[][][] clone(final long[][][] original) {
        if (original == null) {
            return null;
        }

        final long[][][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static float[][][] clone(final float[][][] original) {
        if (original == null) {
            return null;
        }

        final float[][][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param original
     * @return
     */
    public static double[][][] clone(final double[][][] original) {
        if (original == null) {
            return null;
        }

        final double[][][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    /**
     * Clone the original array and its sub arrays. null is returned if the input array is null.
     *
     * @param 
     * @param original
     * @return
     */
    public static  T[][][] clone(final T[][][] original) {
        if (original == null) {
            return null;
        }

        final T[][][] cp = original.clone();

        for (int i = 0, len = cp.length; i < len; i++) {
            cp[i] = clone(original[i]);
        }

        return cp;
    }

    //    /**
    //     *
    //     * @param 
    //     * @param newType
    //     * @param a
    //     * @return
    //     */
    //    public static  T[] copy(Class newType, Object[] a) {
    //        if (isNullOrEmpty(a)) {
    //            return newArray(newType.getComponentType(), 0);
    //        }
    //
    //        return copyOf(a, a.length, newType);
    //    }
    //
    //    /**
    //     *
    //     * @param 
    //     * @param newType
    //     * @param a
    //     * @return
    //     */
    //    public static  T[][] copy(Class newType, Object[][] a) {
    //        final Class componentType = (Class) newType.getComponentType();
    //
    //        if (isNullOrEmpty(a)) {
    //            return newArray(componentType, 0);
    //        }
    //
    //        final int len = len(a);
    //        final T[][] result = newArray(componentType, len);
    //
    //        for (int i = 0; i < len; i++) {
    //            result[i] = copy(componentType, a[i]);
    //        }
    //
    //        return result;
    //    }
    //
    //    /**
    //     *
    //     * @param 
    //     * @param newType
    //     * @param a
    //     * @return
    //     */
    //    public static  T[][][] copy(Class newType, Object[][][] a) {
    //        final Class componentType = (Class) newType.getComponentType();
    //
    //        if (isNullOrEmpty(a)) {
    //            return newArray(componentType, 0);
    //        }
    //
    //        final int len = len(a);
    //        final T[][][] result = newArray(componentType, len);
    //
    //        for (int i = 0; i < len; i++) {
    //            result[i] = copy(componentType, a[i]);
    //        }
    //
    //        return result;
    //    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static boolean isSorted(final boolean[] a) {
        final int len = N.len(a);

        if (len < 2) {
            return true;
        } else if (Boolean.compare(a[len - 1], a[0]) < 0) {
            return false;
        }

        for (int i = 1; i < len; i++) {
            if (Boolean.compare(a[i], a[i - 1]) < 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static boolean isSorted(final boolean[] a, final int fromIndex, final int toIndex) {
        final int len = N.len(a);

        N.checkFromToIndex(fromIndex, toIndex, len);

        if (toIndex - fromIndex < 2) {
            return true;
        } else if (Boolean.compare(a[toIndex - 1], a[fromIndex]) < 0) {
            return false;
        }

        for (int i = fromIndex + 1; i < toIndex; i++) {
            if (Boolean.compare(a[i], a[i - 1]) < 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static boolean isSorted(final char[] a) {
        final int len = N.len(a);

        if (len < 2) {
            return true;
        } else if (a[len - 1] < a[0]) {
            return false;
        }

        for (int i = 1; i < len; i++) {
            if (a[i] < a[i - 1]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static boolean isSorted(final char[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, N.len(a));

        if (toIndex - fromIndex < 2) {
            return true;
        } else if (a[toIndex - 1] < a[fromIndex]) {
            return false;
        }

        for (int i = fromIndex + 1; i < toIndex; i++) {
            if (a[i] < a[i - 1]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static boolean isSorted(final byte[] a) {
        final int len = N.len(a);

        if (len < 2) {
            return true;
        } else if (a[len - 1] < a[0]) {
            return false;
        }

        for (int i = 1; i < len; i++) {
            if (a[i] < a[i - 1]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static boolean isSorted(final byte[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, N.len(a));

        if (toIndex - fromIndex < 2) {
            return true;
        } else if (a[toIndex - 1] < a[fromIndex]) {
            return false;
        }

        for (int i = fromIndex + 1; i < toIndex; i++) {
            if (a[i] < a[i - 1]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static boolean isSorted(final short[] a) {
        final int len = N.len(a);

        if (len < 2) {
            return true;
        } else if (a[len - 1] < a[0]) {
            return false;
        }

        for (int i = 1; i < len; i++) {
            if (a[i] < a[i - 1]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static boolean isSorted(final short[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, N.len(a));

        if (toIndex - fromIndex < 2) {
            return true;
        } else if (a[toIndex - 1] < a[fromIndex]) {
            return false;
        }

        for (int i = fromIndex + 1; i < toIndex; i++) {
            if (a[i] < a[i - 1]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static boolean isSorted(final int[] a) {
        final int len = N.len(a);

        if (len < 2) {
            return true;
        } else if (a[len - 1] < a[0]) {
            return false;
        }

        for (int i = 1; i < len; i++) {
            if (a[i] < a[i - 1]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static boolean isSorted(final int[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, N.len(a));

        if (toIndex - fromIndex < 2) {
            return true;
        } else if (a[toIndex - 1] < a[fromIndex]) {
            return false;
        }

        for (int i = fromIndex + 1; i < toIndex; i++) {
            if (a[i] < a[i - 1]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static boolean isSorted(final long[] a) {
        final int len = N.len(a);

        if (len < 2) {
            return true;
        } else if (a[len - 1] < a[0]) {
            return false;
        }

        for (int i = 1; i < len; i++) {
            if (a[i] < a[i - 1]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static boolean isSorted(final long[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, N.len(a));

        if (toIndex - fromIndex < 2) {
            return true;
        } else if (a[toIndex - 1] < a[fromIndex]) {
            return false;
        }

        for (int i = fromIndex + 1; i < toIndex; i++) {
            if (a[i] < a[i - 1]) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static boolean isSorted(final float[] a) {
        final int len = N.len(a);

        if (len < 2) {
            return true;
        } else if (Float.compare(a[len - 1], a[0]) < 0) {
            return false;
        }

        for (int i = 1; i < len; i++) {
            if (Float.compare(a[i], a[i - 1]) < 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static boolean isSorted(final float[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, N.len(a));

        if (toIndex - fromIndex < 2) {
            return true;
        } else if (Float.compare(a[toIndex - 1], a[fromIndex]) < 0) {
            return false;
        }

        for (int i = fromIndex + 1; i < toIndex; i++) {
            if (Float.compare(a[i], a[i - 1]) < 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @return
     */
    public static boolean isSorted(final double[] a) {
        final int len = N.len(a);

        if (len < 2) {
            return true;
        } else if (Double.compare(a[len - 1], a[0]) < 0) {
            return false;
        }

        for (int i = 1; i < len; i++) {
            if (Double.compare(a[i], a[i - 1]) < 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static boolean isSorted(final double[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, N.len(a));

        if (toIndex - fromIndex < 2) {
            return true;
        } else if (Double.compare(a[toIndex - 1], a[fromIndex]) < 0) {
            return false;
        }

        for (int i = fromIndex + 1; i < toIndex; i++) {
            if (Double.compare(a[i], a[i - 1]) < 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param 
     * @param a
     * @return
     */
    public static > boolean isSorted(final T[] a) {
        final int len = N.len(a);

        if (len < 2) {
            return true;
        } else if (N.compare(a[len - 1], a[0]) < 0) {
            return false;
        }

        for (int i = 1; i < len; i++) {
            if (N.compare(a[i], a[i - 1]) < 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static > boolean isSorted(final T[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, N.len(a));

        if (toIndex - fromIndex < 2) {
            return true;
        } else if (N.compare(a[toIndex - 1], a[fromIndex]) < 0) {
            return false;
        }

        for (int i = fromIndex + 1; i < toIndex; i++) {
            if (N.compare(a[i], a[i - 1]) < 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param 
     * @param a
     * @param cmp
     * @return
     */
    public static  boolean isSorted(final T[] a, Comparator cmp) {
        cmp = cmp == null ? NATURAL_ORDER : cmp;

        final int len = N.len(a);

        if (len < 2) {
            return true;
        } else if (cmp.compare(a[len - 1], a[0]) < 0) {
            return false;
        }

        for (int i = 1; i < len; i++) {
            if (cmp.compare(a[i], a[i - 1]) < 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param cmp
     * @return
     */
    public static  boolean isSorted(final T[] a, final int fromIndex, final int toIndex, Comparator cmp) {
        N.checkFromToIndex(fromIndex, toIndex, N.len(a));

        cmp = cmp == null ? NATURAL_ORDER : cmp;

        if (toIndex - fromIndex < 2) {
            return true;
        } else if (cmp.compare(a[toIndex - 1], a[fromIndex]) < 0) {
            return false;
        }

        for (int i = fromIndex + 1; i < toIndex; i++) {
            if (cmp.compare(a[i], a[i - 1]) < 0) {
                return false;
            }
        }

        return true;
    }

    /**
     *
     *
     * @param 
     * @param c
     * @return
     */
    public static > boolean isSorted(final Collection c) {
        if (N.size(c) < 2) {
            return true;
        }

        final Iterator iter = c.iterator();
        T prev = iter.next();
        T cur = null;

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

            if (N.compare(cur, prev) < 0) {
                return false;
            }

            prev = cur;
        }

        return true;
    }

    /**
     *
     *
     * @param 
     * @param c
     * @param fromIndex
     * @param toIndex
     * @return
     */
    public static > boolean isSorted(final Collection c, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, N.size(c));

        if (toIndex - fromIndex < 2) {
            return true;
        }

        final Iterator iter = c.iterator();
        int cursor = 0;

        while (cursor < fromIndex) {
            iter.next();
            cursor++;
        }

        cursor++;
        T prev = iter.next();
        T cur = null;

        while (cursor < toIndex) {
            cur = iter.next();

            if (N.compare(cur, prev) < 0) {
                return false;
            }

            prev = cur;
            cursor++;
        }

        return true;
    }

    /**
     *
     *
     * @param 
     * @param c
     * @param cmp
     * @return
     */
    public static  boolean isSorted(final Collection c, Comparator cmp) {
        if (N.size(c) < 2) {
            return true;
        }

        cmp = cmp == null ? NATURAL_ORDER : cmp;

        final Iterator iter = c.iterator();
        T prev = iter.next();
        T cur = null;

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

            if (cmp.compare(cur, prev) < 0) {
                return false;
            }

            prev = cur;
        }

        return true;
    }

    /**
     *
     *
     * @param 
     * @param c
     * @param fromIndex
     * @param toIndex
     * @param cmp
     * @return
     */
    public static  boolean isSorted(final Collection c, final int fromIndex, final int toIndex, Comparator cmp) {
        N.checkFromToIndex(fromIndex, toIndex, N.size(c));

        if (toIndex - fromIndex < 2) {
            return true;
        }

        cmp = cmp == null ? NATURAL_ORDER : cmp;

        final Iterator iter = c.iterator();
        int cursor = 0;

        while (cursor < fromIndex) {
            iter.next();
            cursor++;
        }

        cursor++;
        T prev = iter.next();
        T cur = null;

        while (cursor < toIndex) {
            cur = iter.next();

            if (cmp.compare(cur, prev) < 0) {
                return false;
            }

            prev = cur;
            cursor++;
        }

        return true;
    }

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

        int numOfFalse = 0;
        for (boolean element : a) {
            if (!element) {
                numOfFalse++;
            }
        }

        N.fill(a, 0, numOfFalse, false);
        N.fill(a, numOfFalse, a.length, true);
    }

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

        Arrays.sort(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void sort(final char[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.sort(a, fromIndex, toIndex);
    }

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

        Arrays.sort(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void sort(final byte[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.sort(a, fromIndex, toIndex);
    }

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

        Arrays.sort(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void sort(final short[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.sort(a, fromIndex, toIndex);
    }

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

        Arrays.sort(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void sort(final int[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.sort(a, fromIndex, toIndex);
    }

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

        Arrays.sort(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void sort(final long[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.sort(a, fromIndex, toIndex);
    }

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

        Arrays.sort(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void sort(final float[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.sort(a, fromIndex, toIndex);
    }

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

        Arrays.sort(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void sort(final double[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.sort(a, fromIndex, toIndex);
    }

    /**
     *
     * @param a
     */
    public static void sort(final Object[] a) {
        if (N.isNullOrEmpty(a)) {
            return;
        }

        Arrays.sort(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void sort(final Object[] a, final int fromIndex, final int toIndex) {
        sort(a, fromIndex, toIndex, Comparators.NATURAL_ORDER);
    }

    /**
     *
     * @param 
     * @param a
     * @param cmp
     */
    public static  void sort(final T[] a, final Comparator cmp) {
        if (N.isNullOrEmpty(a)) {
            return;
        }

        sort(a, 0, a.length, cmp);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param cmp
     */
    public static  void sort(final T[] a, final int fromIndex, final int toIndex, final Comparator cmp) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.sort(a, fromIndex, toIndex, cmp);
    }

    /**
     *
     * @param 
     * @param list
     */
    public static > void sort(final List list) {
        if (N.isNullOrEmpty(list)) {
            return;
        }

        sort(list, 0, list.size(), Comparators.NATURAL_ORDER);
    }

    /**
     *
     * @param 
     * @param list
     * @param fromIndex
     * @param toIndex
     */
    public static > void sort(final List list, final int fromIndex, final int toIndex) {
        if (N.isNullOrEmpty(list)) {
            return;
        }

        sort(list, fromIndex, toIndex, Comparators.NATURAL_ORDER);
    }

    /**
     *
     * @param 
     * @param list
     * @param cmp
     */
    public static  void sort(final List list, final Comparator cmp) {
        if (N.isNullOrEmpty(list)) {
            return;
        }

        sort(list, 0, list.size(), cmp);
    }

    /**
     *
     * @param 
     * @param list
     * @param fromIndex
     * @param toIndex
     * @param cmp
     */
    public static  void sort(final List list, final int fromIndex, final int toIndex, final Comparator cmp) {
        if ((N.isNullOrEmpty(list) && fromIndex == 0 && toIndex == 0) || fromIndex == toIndex) {
            return;
        }

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

        if (a != null) {
            sort(a, fromIndex, toIndex, cmp);

            return;
        }

        final T[] array = (T[]) list.toArray();
        Arrays.sort(array, fromIndex, toIndex, cmp);
        final ListIterator i = (ListIterator) list.listIterator();

        for (T element : array) {
            i.next();
            i.set(element);
        }
    }

    /**
     *
     * @param 
     * @param 
     * @param a
     * @param keyMapper
     */
    public static > void sortBy(final T[] a, final Function keyMapper) {
        sort(a, Comparators.comparingBy(keyMapper));
    }

    /**
     *
     * @param 
     * @param 
     * @param list
     * @param keyMapper
     */
    public static > void sortBy(final List list, final Function keyMapper) {
        sort(list, Comparators.comparingBy(keyMapper));
    }

    /**
     * Sort by int.
     *
     * @param 
     * @param a
     * @param keyMapper
     */
    public static  void sortByInt(final T[] a, final ToIntFunction keyMapper) {
        sort(a, Comparators.comparingInt(keyMapper));
    }

    /**
     * Sort by int.
     *
     * @param 
     * @param list
     * @param keyMapper
     */
    public static  void sortByInt(final List list, final ToIntFunction keyMapper) {
        sort(list, Comparators.comparingInt(keyMapper));
    }

    /**
     * Sort by long.
     *
     * @param 
     * @param a
     * @param keyMapper
     */
    public static  void sortByLong(final T[] a, final ToLongFunction keyMapper) {
        sort(a, Comparators.comparingLong(keyMapper));
    }

    /**
     * Sort by long.
     *
     * @param 
     * @param list
     * @param keyMapper
     */
    public static  void sortByLong(final List list, final ToLongFunction keyMapper) {
        sort(list, Comparators.comparingLong(keyMapper));
    }

    /**
     * Sort by float.
     *
     * @param 
     * @param a
     * @param keyMapper
     */
    public static  void sortByFloat(final T[] a, final ToFloatFunction keyMapper) {
        sort(a, Comparators.comparingFloat(keyMapper));
    }

    /**
     * Sort by float.
     *
     * @param 
     * @param list
     * @param keyMapper
     */
    public static  void sortByFloat(final List list, final ToFloatFunction keyMapper) {
        sort(list, Comparators.comparingFloat(keyMapper));
    }

    /**
     * Sort by double.
     *
     * @param 
     * @param a
     * @param keyMapper
     */
    public static  void sortByDouble(final T[] a, final ToDoubleFunction keyMapper) {
        sort(a, Comparators.comparingDouble(keyMapper));
    }

    /**
     * Sort by double.
     *
     * @param 
     * @param list
     * @param keyMapper
     */
    public static  void sortByDouble(final List list, final ToDoubleFunction keyMapper) {
        sort(list, Comparators.comparingDouble(keyMapper));
    }

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

        parallelSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void parallelSort(final char[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.parallelSort(a, fromIndex, toIndex);
    }

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

        parallelSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void parallelSort(final byte[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.parallelSort(a, fromIndex, toIndex);
    }

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

        parallelSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void parallelSort(final short[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.parallelSort(a, fromIndex, toIndex);
    }

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

        parallelSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void parallelSort(final int[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.parallelSort(a, fromIndex, toIndex);
    }

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

        parallelSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void parallelSort(final long[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.parallelSort(a, fromIndex, toIndex);
    }

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

        parallelSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void parallelSort(final float[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.parallelSort(a, fromIndex, toIndex);
    }

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

        parallelSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void parallelSort(final double[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.parallelSort(a, fromIndex, toIndex);
    }

    /**
     *
     *
     * @param 
     * @param a
     */
    public static > void parallelSort(T[] a) {
        if (N.isNullOrEmpty(a)) {
            return;
        }

        parallelSort(a, 0, a.length);
    }

    /**
     *
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static > void parallelSort(T[] a, int fromIndex, int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.parallelSort(a, fromIndex, toIndex);
    }

    /**
     *
     * @param 
     * @param a
     * @param cmp
     */
    public static  void parallelSort(final T[] a, final Comparator cmp) {
        if (N.isNullOrEmpty(a)) {
            return;
        }

        parallelSort(a, 0, a.length, cmp);
    }

    /**
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param cmp
     */
    public static  void parallelSort(final T[] a, final int fromIndex, final int toIndex, final Comparator cmp) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        Arrays.parallelSort(a, fromIndex, toIndex, cmp);
    }

    /**
     *
     * @param 
     * @param list
     */
    public static > void parallelSort(final List list) {
        if (N.isNullOrEmpty(list)) {
            return;
        }

        parallelSort(list, 0, list.size());
    }

    /**
     *
     * @param 
     * @param list
     * @param fromIndex
     * @param toIndex
     */
    public static > void parallelSort(final List list, final int fromIndex, final int toIndex) {
        parallelSort(list, fromIndex, toIndex, Comparators.NATURAL_ORDER);
    }

    /**
     *
     * @param 
     * @param list
     * @param cmp
     */
    public static  void parallelSort(final List list, final Comparator cmp) {
        if (N.isNullOrEmpty(list)) {
            return;
        }

        parallelSort(list, 0, list.size(), cmp);
    }

    /**
     *
     * @param 
     * @param list
     * @param fromIndex
     * @param toIndex
     * @param cmp
     */
    public static  void parallelSort(final List list, final int fromIndex, final int toIndex, final Comparator cmp) {
        if ((N.isNullOrEmpty(list) && fromIndex == 0 && toIndex == 0) || fromIndex == toIndex) {
            return;
        }

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

        if (a != null) {
            parallelSort(a, fromIndex, toIndex, cmp);

            return;
        }

        final T[] array = (T[]) list.toArray();

        parallelSort(array, fromIndex, toIndex, cmp);

        final ListIterator it = (ListIterator) list.listIterator();

        for (T element : array) {
            it.next();

            it.set(element);
        }
    }

    /**
     * Parallel sort by.
     *
     * @param 
     * @param 
     * @param a
     * @param keyMapper
     */
    public static > void parallelSortBy(final T[] a, final Function keyMapper) {
        parallelSort(a, Comparators.comparingBy(keyMapper));
    }

    /**
     * Parallel sort by.
     *
     * @param 
     * @param 
     * @param list
     * @param keyMapper
     */
    public static > void parallelSortBy(final List list, final Function keyMapper) {
        parallelSort(list, Comparators.comparingBy(keyMapper));
    }

    /**
     * Parallel sort by int.
     *
     * @param 
     * @param a
     * @param keyMapper
     */
    public static  void parallelSortByInt(final T[] a, final ToIntFunction keyMapper) {
        parallelSort(a, Comparators.comparingInt(keyMapper));
    }

    /**
     * Parallel sort by int.
     *
     * @param 
     * @param list
     * @param keyMapper
     */
    public static  void parallelSortByInt(final List list, final ToIntFunction keyMapper) {
        parallelSort(list, Comparators.comparingInt(keyMapper));
    }

    /**
     * Parallel sort by long.
     *
     * @param 
     * @param a
     * @param keyMapper
     */
    public static  void parallelSortByLong(final T[] a, final ToLongFunction keyMapper) {
        parallelSort(a, Comparators.comparingLong(keyMapper));
    }

    /**
     * Parallel sort by long.
     *
     * @param 
     * @param list
     * @param keyMapper
     */
    public static  void parallelSortByLong(final List list, final ToLongFunction keyMapper) {
        parallelSort(list, Comparators.comparingLong(keyMapper));
    }

    /**
     * Parallel sort by float.
     *
     * @param 
     * @param a
     * @param keyMapper
     */
    public static  void parallelSortByFloat(final T[] a, final ToFloatFunction keyMapper) {
        parallelSort(a, Comparators.comparingFloat(keyMapper));
    }

    /**
     * Parallel sort by float.
     *
     * @param 
     * @param list
     * @param keyMapper
     */
    public static  void parallelSortByFloat(final List list, final ToFloatFunction keyMapper) {
        parallelSort(list, Comparators.comparingFloat(keyMapper));
    }

    /**
     * Parallel sort by double.
     *
     * @param 
     * @param a
     * @param keyMapper
     */
    public static  void parallelSortByDouble(final T[] a, final ToDoubleFunction keyMapper) {
        parallelSort(a, Comparators.comparingDouble(keyMapper));
    }

    /**
     * Parallel sort by double.
     *
     * @param 
     * @param list
     * @param keyMapper
     */
    public static  void parallelSortByDouble(final List list, final ToDoubleFunction keyMapper) {
        parallelSort(list, Comparators.comparingDouble(keyMapper));
    }

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

        int numOfTrue = 0;
        for (boolean element : a) {
            if (element) {
                numOfTrue++;
            }
        }

        N.fill(a, 0, numOfTrue, true);
        N.fill(a, numOfTrue, a.length, false);
    }

    /**
     *
     * @param a
     */
    public static void reverseSort(final char[] a) {
        sort(a);
        reverse(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverseSort(final char[] a, final int fromIndex, final int toIndex) {
        sort(a, fromIndex, toIndex);
        reverse(a, fromIndex, toIndex);
    }

    /**
     *
     * @param a
     */
    public static void reverseSort(final byte[] a) {
        sort(a);
        reverse(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverseSort(final byte[] a, final int fromIndex, final int toIndex) {
        sort(a, fromIndex, toIndex);
        reverse(a, fromIndex, toIndex);
    }

    /**
     *
     * @param a
     */
    public static void reverseSort(final short[] a) {
        sort(a);
        reverse(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverseSort(final short[] a, final int fromIndex, final int toIndex) {
        sort(a, fromIndex, toIndex);
        reverse(a, fromIndex, toIndex);
    }

    /**
     *
     * @param a
     */
    public static void reverseSort(final int[] a) {
        sort(a);
        reverse(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverseSort(final int[] a, final int fromIndex, final int toIndex) {
        sort(a, fromIndex, toIndex);
        reverse(a, fromIndex, toIndex);
    }

    /**
     *
     * @param a
     */
    public static void reverseSort(final long[] a) {
        sort(a);
        reverse(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverseSort(final long[] a, final int fromIndex, final int toIndex) {
        sort(a, fromIndex, toIndex);
        reverse(a, fromIndex, toIndex);
    }

    /**
     *
     * @param a
     */
    public static void reverseSort(final float[] a) {
        sort(a);
        reverse(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverseSort(final float[] a, final int fromIndex, final int toIndex) {
        sort(a, fromIndex, toIndex);
        reverse(a, fromIndex, toIndex);
    }

    /**
     *
     * @param a
     */
    public static void reverseSort(final double[] a) {
        sort(a);
        reverse(a);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void reverseSort(final double[] a, final int fromIndex, final int toIndex) {
        sort(a, fromIndex, toIndex);
        reverse(a, fromIndex, toIndex);
    }

    /**
     *
     * @param a
     */
    @SuppressWarnings("rawtypes")
    public static void reverseSort(final Object[] a) {
        sort(a, (Comparator) Fn.reversedOrder());
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    @SuppressWarnings("rawtypes")
    public static void reverseSort(final Object[] a, final int fromIndex, final int toIndex) {
        sort(a, fromIndex, toIndex, (Comparator) Fn.reversedOrder());
    }

    /**
     *
     * @param 
     * @param list
     */
    public static > void reverseSort(final List list) {
        sort(list, Fn. reversedOrder());
    }

    /**
     *
     * @param 
     * @param list
     * @param fromIndex
     * @param toIndex
     */
    public static > void reverseSort(final List list, final int fromIndex, final int toIndex) {
        sort(list, fromIndex, toIndex, Fn. reversedOrder());
    }

    /**
     * Reverse sort by.
     *
     * @param 
     * @param 
     * @param a
     * @param keyMapper
     */
    public static > void reverseSortBy(final T[] a, final Function keyMapper) {
        sort(a, Comparators.reversedComparingBy(keyMapper));
    }

    /**
     * Reverse sort by.
     *
     * @param 
     * @param 
     * @param list
     * @param keyMapper
     */
    public static > void reverseSortBy(final List list, final Function keyMapper) {
        sort(list, Comparators.reversedComparingBy(keyMapper));
    }

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

        bucketSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void bucketSort(final int[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        if (toIndex - fromIndex < 32) {
            sort(a, fromIndex, toIndex);
            return;
        }

        final Multiset multiset = new Multiset<>();

        for (int i = fromIndex; i < toIndex; i++) {
            multiset.add(a[i]);
        }

        final Map m = multiset.toMapSortedBy((a1, b) -> N.compare(a1.getKey().intValue(), a1.getKey().intValue()));
        int idx = fromIndex;

        for (Map.Entry entry : m.entrySet()) {
            N.fill(a, idx, idx + entry.getValue(), entry.getKey());
            idx += entry.getValue();
        }
    }

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

        bucketSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void bucketSort(final long[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        if (toIndex - fromIndex < 32) {
            sort(a, fromIndex, toIndex);
            return;
        }

        final Multiset multiset = new Multiset<>();

        for (int i = fromIndex; i < toIndex; i++) {
            multiset.add(a[i]);
        }

        final Map m = multiset.toMapSortedBy((a1, b) -> N.compare(a1.getKey().longValue(), a1.getKey().longValue()));

        int idx = fromIndex;

        for (Map.Entry entry : m.entrySet()) {
            N.fill(a, idx, idx + entry.getValue(), entry.getKey());
            idx += entry.getValue();
        }
    }

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

        bucketSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void bucketSort(final float[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        if (toIndex - fromIndex < 32) {
            sort(a, fromIndex, toIndex);
            return;
        }

        final Multiset multiset = new Multiset<>();

        for (int i = fromIndex; i < toIndex; i++) {
            multiset.add(a[i]);
        }

        final Map m = multiset.toMapSortedBy((a1, b) -> N.compare(a1.getKey(), a1.getKey()));
        int idx = fromIndex;

        for (Map.Entry entry : m.entrySet()) {
            N.fill(a, idx, idx + entry.getValue(), entry.getKey());
            idx += entry.getValue();
        }
    }

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

        bucketSort(a, 0, a.length);
    }

    /**
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     */
    public static void bucketSort(final double[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        if (toIndex - fromIndex < 32) {
            sort(a, fromIndex, toIndex);
            return;
        }

        final Multiset multiset = new Multiset<>();

        for (int i = fromIndex; i < toIndex; i++) {
            multiset.add(a[i]);
        }

        final Map m = multiset.toMapSortedBy((a1, b) -> N.compare(a1.getKey(), a1.getKey()));
        int idx = fromIndex;

        for (Map.Entry entry : m.entrySet()) {
            N.fill(a, idx, idx + entry.getValue(), entry.getKey());
            idx += entry.getValue();
        }
    }

    /**
     * Note: All the objects with same value will be replaced by first element with the same value.
     *
     * @param a
     */
    public static void bucketSort(final Object[] a) {
        if (N.isNullOrEmpty(a)) {
            return;
        }

        bucketSort(a, 0, a.length);
    }

    /**
     * Note: All the objects with same value will be replaced by first element with the same value.
     *
     * @param a the elements in the array must implements the Comparable interface.
     * @param fromIndex
     * @param toIndex
     */
    public static void bucketSort(final Object[] a, final int fromIndex, final int toIndex) {
        bucketSort(a, fromIndex, toIndex, Comparators.NATURAL_ORDER);
    }

    /**
     *
     * @param 
     * @param a
     * @param cmp
     */
    public static  void bucketSort(final T[] a, final Comparator cmp) {
        if (N.isNullOrEmpty(a)) {
            return;
        }

        bucketSort(a, 0, a.length, cmp);
    }

    /**
     * Note: All the objects with same value will be replaced by first element with the same value.
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param cmp
     */
    public static  void bucketSort(final T[] a, final int fromIndex, final int toIndex, final Comparator cmp) {
        N.checkFromToIndex(fromIndex, toIndex, a == null ? 0 : a.length);

        if (N.isNullOrEmpty(a) || fromIndex == toIndex) {
            return;
        }

        if (toIndex - fromIndex < 32) {
            sort(a, fromIndex, toIndex, cmp);
            return;
        }

        final Comparator comparator = cmp == null ? Comparators.NATURAL_ORDER : cmp;
        final Multiset multiset = new Multiset<>();

        for (int i = fromIndex; i < toIndex; i++) {
            multiset.add(a[i]);
        }

        final Map m = multiset.toMapSortedBy((a1, b) -> comparator.compare(a1.getKey(), a1.getKey()));
        int idx = fromIndex;

        for (Map.Entry entry : m.entrySet()) {
            N.fill(a, idx, idx + entry.getValue(), entry.getKey());
            idx += entry.getValue();
        }
    }

    /**
     * Note: All the objects with same value will be replaced by first element with the same value.
     *
     * @param 
     * @param list
     */
    public static > void bucketSort(final List list) {
        if (N.isNullOrEmpty(list)) {
            return;
        }

        bucketSort(list, 0, list.size());
    }

    /**
     * Note: All the objects with same value will be replaced by first element with the same value.
     *
     * @param 
     * @param list
     * @param fromIndex
     * @param toIndex
     */
    public static > void bucketSort(final List list, final int fromIndex, final int toIndex) {
        bucketSort(list, fromIndex, toIndex, Comparators.NATURAL_ORDER);
    }

    /**
     * Note: All the objects with same value will be replaced by first element with the same value.
     *
     * @param 
     * @param list
     * @param cmp
     */
    public static  void bucketSort(final List list, final Comparator cmp) {
        if (N.isNullOrEmpty(list)) {
            return;
        }

        bucketSort(list, 0, list.size(), cmp);
    }

    /**
     * Note: All the objects with same value will be replaced by first element with the same value.
     *
     * @param 
     * @param list
     * @param fromIndex
     * @param toIndex
     * @param cmp
     */
    public static  void bucketSort(final List list, final int fromIndex, final int toIndex, final Comparator cmp) {
        N.checkFromToIndex(fromIndex, toIndex, list == null ? 0 : list.size());

        if ((N.isNullOrEmpty(list) && fromIndex == 0 && toIndex == 0) || fromIndex == toIndex) {
            return;
        }

        if (toIndex - fromIndex < 32) {
            sort(list, fromIndex, toIndex, cmp);
            return;
        }

        final Comparator comparator = cmp == null ? Comparators.NATURAL_ORDER : cmp;
        final Multiset multiset = new Multiset<>();
        ListIterator itr = (ListIterator) list.listIterator(fromIndex);
        int i = fromIndex;

        while (itr.hasNext()) {
            if (i++ >= toIndex) {
                break;
            }

            multiset.add(itr.next());
        }

        final Map m = multiset.toMapSortedBy((a, b) -> comparator.compare(a.getKey(), a.getKey()));

        itr = (ListIterator) list.listIterator(fromIndex);

        for (Map.Entry entry : m.entrySet()) {
            final T key = entry.getKey();
            for (int j = 0; j < entry.getValue(); j++) {
                itr.next();
                itr.set(key);
            }
        }
    }

    /**
     * Bucket sort by.
     *
     * @param 
     * @param 
     * @param a
     * @param keyMapper
     */
    public static > void bucketSortBy(final T[] a, final Function keyMapper) {
        if (N.isNullOrEmpty(a)) {
            return;
        }

        bucketSort(a, Comparators.comparingBy(keyMapper));
    }

    /**
     * Bucket sort by.
     *
     * @param 
     * @param 
     * @param list
     * @param keyMapper
     */
    public static > void bucketSortBy(final List list, final Function keyMapper) {
        if (N.isNullOrEmpty(list)) {
            return;
        }

        bucketSort(list, Comparators.comparingBy(keyMapper));
    }

    /**
     * {@link Arrays#binarySearch(boolean[], boolean)}.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    static int binarySearch(final boolean[] a, final boolean valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        if (a[0] == valueToFind) {
            return 0;
        } else if (a[a.length - 1] != valueToFind) {
            return N.INDEX_NOT_FOUND;
        }

        int left = 0, right = a.length - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;

            if (a[mid] == valueToFind) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }

    /**
     * {@link Arrays#binarySearch(char[], char)}.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final char[] a, final char valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(char[], int, int, char)}.
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final char[] a, final int fromIndex, final int toIndex, final char valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, fromIndex, toIndex, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(byte[], byte)}.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final byte[] a, final byte valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(byte[], int, int, byte)}.
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final byte[] a, final int fromIndex, final int toIndex, final byte valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, fromIndex, toIndex, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(short[], short)}.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final short[] a, final short valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(short[], int, int, short)}.
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final short[] a, final int fromIndex, final int toIndex, final short valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, fromIndex, toIndex, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(int[], int)}.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final int[] a, final int valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(int[], int, int, int)}.
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final int[] a, final int fromIndex, final int toIndex, final int valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, fromIndex, toIndex, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(long[], long)}.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final long[] a, final long valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(long[], int, int, long)}.
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final long[] a, final int fromIndex, final int toIndex, final long valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, fromIndex, toIndex, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(float[], float)}.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final float[] a, final float valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(float[], int, int, float)}.
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final float[] a, final int fromIndex, final int toIndex, final float valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, fromIndex, toIndex, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(double[], double)}.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final double[] a, final double valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(double[], int, int, double)}.
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final double[] a, final int fromIndex, final int toIndex, final double valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, fromIndex, toIndex, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(Object[], Object)}.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final Object[] a, final Object valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(Object[], int, int, Object)}.
     *
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @return
     */
    public static int binarySearch(final Object[] a, final int fromIndex, final int toIndex, final Object valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, fromIndex, toIndex, valueToFind);
    }

    /**
     * {@link Arrays#binarySearch(Object[], Object, Comparator)}.
     *
     * @param 
     * @param a
     * @param valueToFind
     * @param cmp
     * @return
     */
    public static  int binarySearch(final T[] a, final T valueToFind, final Comparator cmp) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, valueToFind, cmp == null ? Comparators.NATURAL_ORDER : cmp);
    }

    /**
     * {@link Arrays#binarySearch(Object[], int, int, Object, Comparator)}.
     *
     * @param 
     * @param a
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @param cmp
     * @return
     */
    public static  int binarySearch(final T[] a, final int fromIndex, final int toIndex, final T valueToFind, final Comparator cmp) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, fromIndex, toIndex, valueToFind, cmp == null ? Comparators.NATURAL_ORDER : cmp);
    }

    /**
     * {@link Collections#binarySearch(List, Object)}.
     *
     * @param 
     * @param list
     * @param valueToFind
     * @return
     */
    public static > int binarySearch(final List list, final T valueToFind) {
        if (N.isNullOrEmpty(list)) {
            return N.INDEX_NOT_FOUND;
        }

        return binarySearch(list, 0, list.size(), valueToFind);
    }

    /**
     *
     * @param 
     * @param list
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @return
     */
    public static > int binarySearch(final List list, final int fromIndex, final int toIndex,
            final T valueToFind) {
        if (N.isNullOrEmpty(list)) {
            return N.INDEX_NOT_FOUND;
        }

        return binarySearch(list, fromIndex, toIndex, valueToFind, Comparators.NATURAL_ORDER);
    }

    /**
     *
     * @param 
     * @param list
     * @param valueToFind
     * @param cmp
     * @return
     */
    public static  int binarySearch(final List list, final T valueToFind, final Comparator cmp) {
        if (N.isNullOrEmpty(list)) {
            return N.INDEX_NOT_FOUND;
        }

        return binarySearch(list, 0, list.size(), valueToFind, cmp);
    }

    /**
     *
     * @param 
     * @param list
     * @param fromIndex
     * @param toIndex
     * @param valueToFind
     * @param cmp
     * @return
     * @see Collections#binarySearch(List, Object, Comparator)
     */
    public static  int binarySearch(final List list, final int fromIndex, final int toIndex, final T valueToFind,
            final Comparator cmp) {
        if (N.isNullOrEmpty(list)) {
            return N.INDEX_NOT_FOUND;
        }

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

        if (a != null) {
            return binarySearch(a, fromIndex, toIndex, valueToFind, cmp == null ? Comparators.NATURAL_ORDER : cmp);
        }

        if (list instanceof RandomAccess || list.size() < BINARYSEARCH_THRESHOLD) {
            return indexedBinarySearch(list, fromIndex, toIndex, valueToFind, cmp == null ? Comparators.NATURAL_ORDER : cmp);
        } else {
            return iteratorBinarySearch(list, fromIndex, toIndex, valueToFind, cmp == null ? Comparators.NATURAL_ORDER : cmp);
        }
    }

    /**
     * Binary search by.
     *
     * @param 
     * @param 
     * @param a
     * @param valueToFind
     * @param valueToFindMapper
     * @return
     */
    public static > int binarySearchBy(final T[] a, final T valueToFind,
            final Function valueToFindMapper) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        return Arrays.binarySearch(a, valueToFind, Comparators.comparingBy(valueToFindMapper));
    }

    /**
     * Binary search by.
     *
     * @param 
     * @param 
     * @param list
     * @param valueToFind
     * @param valueToFindMapper
     * @return
     */
    public static > int binarySearchBy(final List list, final T valueToFind,
            final Function valueToFindMapper) {
        if (N.isNullOrEmpty(list)) {
            return N.INDEX_NOT_FOUND;
        }

        return binarySearch(list, valueToFind, Comparators.comparingBy(valueToFindMapper));
    }

    private static  int indexedBinarySearch(final List l, final int fromIndex, final int toIndex, final T valueToFind,
            final Comparator cmp) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            T midVal = l.get(mid);

            int res = cmp.compare(midVal, valueToFind);

            if (res < 0) {
                low = mid + 1;
            } else if (res > 0) {
                high = mid - 1;
            } else {
                return mid; // valueToFind found
            }
        }

        return N.INDEX_NOT_FOUND; // valueToFind not found
    }

    private static  int iteratorBinarySearch(final List l, final int fromIndex, final int toIndex, final T valueToFind,
            final Comparator cmp) {
        int low = fromIndex;
        int high = toIndex - 1;

        ListIterator iterator = l.listIterator();

        while (low <= high) {
            int mid = (low + high) >>> 1;
            T midVal = get(iterator, mid);

            int res = cmp.compare(midVal, valueToFind);

            if (res < 0) {
                low = mid + 1;
            } else if (res > 0) {
                high = mid - 1;
            } else {
                return mid; // valueToFind found
            }
        }

        return N.INDEX_NOT_FOUND; // valueToFind not found
    }

    private static  T get(final ListIterator iterator, final int index) {
        T obj = null;
        int pos = iterator.nextIndex();

        if (pos <= index) {
            do {
                obj = iterator.next();
            } while (pos++ < index);
        } else {
            do {
                obj = iterator.previous();
            } while (--pos > index);
        }

        return obj;
    }

    /**
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int indexOf(final boolean[] a, final boolean valueToFind) {
        return indexOf(a, 0, valueToFind);
    }

    /**
     *
     * @param a
     * @param startIndex the index from which to start the search.
     * @param valueToFind
     * @return
     */
    public static int indexOf(final boolean[] a, final int startIndex, final boolean valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.max(startIndex, 0); i < len; i++) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int indexOf(final char[] a, final char valueToFind) {
        return indexOf(a, 0, valueToFind);
    }

    /**
     *
     * @param a
     * @param startIndex the index from which to start the search.
     * @param valueToFind
     * @return
     */
    public static int indexOf(final char[] a, final int startIndex, final char valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.max(startIndex, 0); i < len; i++) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int indexOf(final byte[] a, final byte valueToFind) {
        return indexOf(a, 0, valueToFind);

    }

    /**
     *
     * @param a
     * @param startIndex the index from which to start the search.
     * @param valueToFind
     * @return
     */
    public static int indexOf(final byte[] a, final int startIndex, final byte valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.max(startIndex, 0); i < len; i++) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int indexOf(final short[] a, final short valueToFind) {
        return indexOf(a, 0, valueToFind);
    }

    /**
     *
     * @param a
     * @param startIndex the index from which to start the search.
     * @param valueToFind
     * @return
     */
    public static int indexOf(final short[] a, final int startIndex, final short valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.max(startIndex, 0); i < len; i++) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int indexOf(final int[] a, final int valueToFind) {
        return indexOf(a, 0, valueToFind);
    }

    /**
     *
     * @param a
     * @param startIndex the index from which to start the search.
     * @param valueToFind
     * @return
     */
    public static int indexOf(final int[] a, final int startIndex, final int valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.max(startIndex, 0); i < len; i++) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int indexOf(final long[] a, final long valueToFind) {
        return indexOf(a, 0, valueToFind);
    }

    /**
     *
     * @param a
     * @param startIndex the index from which to start the search.
     * @param valueToFind
     * @return
     */
    public static int indexOf(final long[] a, final int startIndex, final long valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.max(startIndex, 0); i < len; i++) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int indexOf(final float[] a, final float valueToFind) {
        return indexOf(a, 0, valueToFind);
    }

    /**
     *
     * @param a
     * @param startIndex the index from which to start the search.
     * @param valueToFind
     * @return
     */
    public static int indexOf(final float[] a, final int startIndex, final float valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.max(startIndex, 0); i < len; i++) {
            if (Float.compare(a[i], valueToFind) == 0) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int indexOf(final double[] a, final double valueToFind) {
        return indexOf(a, 0, valueToFind);
    }

    /**
     *
     * @param a
     * @param startIndex the index from which to start the search.
     * @param valueToFind
     * @return
     */
    public static int indexOf(final double[] a, final int startIndex, final double valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.max(startIndex, 0); i < len; i++) {
            if (Double.compare(a[i], valueToFind) == 0) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * 
Finds the index of the given value within a given tolerance in the array.
     * This method will return the index of the first value which falls between the region
     * defined by valueToFind - tolerance and valueToFind + tolerance.
     *
     * 
This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.
     *
     * @param a the array to search through for the object, may be {@code null}
     * @param valueToFind
     * @param tolerance tolerance of the search
     * @return the index of the value within the array,
     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
     */
    public static int indexOf(final double[] a, final double valueToFind, final double tolerance) {
        return indexOf(a, 0, valueToFind, tolerance);
    }

    /**
     * 
Finds the index of the given value in the array starting at the given index.
     * This method will return the index of the first value which falls between the region
     * defined by valueToFind - tolerance and valueToFind + tolerance.
     *
     * 
This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.
     *
     * 
A negative startIndex is treated as zero. A startIndex larger than the array
     * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).
     *
     * @param a the array to search through for the object, may be {@code null}
     * @param startIndex the index to start searching at
     * @param valueToFind
     * @param tolerance tolerance of the search
     * @return the index of the value within the array,
     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
     */
    public static int indexOf(final double[] a, int startIndex, final double valueToFind, final double tolerance) {
        final int len = len(a);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        final double min = valueToFind - tolerance;
        final double max = valueToFind + tolerance;

        for (int i = startIndex; i < len; i++) {
            if (a[i] >= min && a[i] <= max) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int indexOf(final Object[] a, final Object valueToFind) {
        return indexOf(a, 0, valueToFind);
    }

    /**
     *
     * @param a
     * @param startIndex the index from which to start the search.
     * @param valueToFind
     * @return
     */
    public static int indexOf(final Object[] a, final int startIndex, final Object valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.max(startIndex, 0); i < len; i++) {
            if (equals(a[i], valueToFind)) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     *
     * @param c
     * @param valueToFind
     * @return
     */
    public static int indexOf(final Collection c, final Object valueToFind) {
        return indexOf(c, 0, valueToFind);
    }

    /**
     *
     *
     * @param c
     * @param startIndex the index from which to start the search.
     * @param valueToFind
     * @return
     */
    public static int indexOf(final Collection c, final int startIndex, final Object valueToFind) {
        final int len = size(c);

        if (len == 0 || startIndex >= len) {
            return INDEX_NOT_FOUND;
        }

        if (c instanceof List && c instanceof RandomAccess) {
            final List list = (List) c;

            for (int i = N.max(startIndex, 0); i < len; i++) {
                if (equals(list.get(i), valueToFind)) {
                    return i;
                }
            }
        } else {
            final Iterator iter = c.iterator();
            int index = 0;

            if (startIndex > 0) {
                while (index < startIndex && iter.hasNext()) {
                    iter.next();
                    index++;
                }

                while (iter.hasNext()) {
                    if (N.equals(iter.hasNext(), valueToFind)) {
                        return index;
                    }

                    index++;
                }
            } else {
                while (iter.hasNext()) {
                    if (N.equals(iter.next(), valueToFind)) {
                        return index;
                    }

                    index++;
                }
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     *
     *
     * @param iter
     * @param valueToFind
     * @return
     */
    public static int indexOf(final Iterator iter, final Object valueToFind) {
        return indexOf(iter, 0, valueToFind);
    }

    /**
     *
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int indexOfIgnoreCase(final String[] a, final String valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        for (int i = 0, len = a.length; i < len; i++) {
            if (N.equalsIgnoreCase(a[i], valueToFind)) {
                return i;
            }
        }

        return N.INDEX_NOT_FOUND;
    }

    /**
     *
     *
     * @param iter
     * @param startIndex
     * @param valueToFind
     * @return
     */
    public static int indexOf(final Iterator iter, final int startIndex, final Object valueToFind) {
        if (iter == null) {
            return INDEX_NOT_FOUND;
        }

        long index = 0;

        if (startIndex > 0) {
            while (index < startIndex && iter.hasNext()) {
                iter.next();
                index++;
            }

            while (iter.hasNext()) {
                if (N.equals(iter.hasNext(), valueToFind)) {
                    return Numbers.toIntExact(index);
                }

                index++;
            }
        } else {
            while (iter.hasNext()) {
                if (N.equals(iter.next(), valueToFind)) {
                    return Numbers.toIntExact(index);
                }

                index++;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * Index of sub list.
     *
     * @param sourceList
     * @param subListToFind
     * @return
     * @see java.util.Collections#indexOfSubList(List, List)
     */
    public static int indexOfSubList(final List sourceList, final List subListToFind) {
        if (isNullOrEmpty(sourceList) || isNullOrEmpty(subListToFind)) {
            return INDEX_NOT_FOUND;
        }

        return Collections.indexOfSubList(sourceList, subListToFind);
    }

    /**
     * Last index of.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final boolean[] a, final boolean valueToFind) {
        return lastIndexOf(a, a.length - 1, valueToFind);
    }

    /**
     * Last index of.
     *
     * @param a
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final boolean[] a, final int startIndexFromBack, final boolean valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.min(startIndexFromBack, len - 1); i >= 0; i--) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * Last index of.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final char[] a, final char valueToFind) {
        if (isNullOrEmpty(a)) {
            return INDEX_NOT_FOUND;
        }

        return lastIndexOf(a, a.length - 1, valueToFind);
    }

    /**
     * Last index of.
     *
     * @param a
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final char[] a, final int startIndexFromBack, final char valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.min(startIndexFromBack, len - 1); i >= 0; i--) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * Last index of.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final byte[] a, final byte valueToFind) {
        if (isNullOrEmpty(a)) {
            return INDEX_NOT_FOUND;
        }

        return lastIndexOf(a, a.length - 1, valueToFind);

    }

    /**
     * Last index of.
     *
     * @param a
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final byte[] a, final int startIndexFromBack, final byte valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.min(startIndexFromBack, len - 1); i >= 0; i--) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * Last index of.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final short[] a, final short valueToFind) {
        if (isNullOrEmpty(a)) {
            return INDEX_NOT_FOUND;
        }

        return lastIndexOf(a, a.length - 1, valueToFind);
    }

    /**
     * Last index of.
     *
     * @param a
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final short[] a, final int startIndexFromBack, final short valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.min(startIndexFromBack, len - 1); i >= 0; i--) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * Last index of.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final int[] a, final int valueToFind) {
        if (isNullOrEmpty(a)) {
            return INDEX_NOT_FOUND;
        }

        return lastIndexOf(a, a.length - 1, valueToFind);
    }

    /**
     * Last index of.
     *
     * @param a
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final int[] a, final int startIndexFromBack, final int valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.min(startIndexFromBack, len - 1); i >= 0; i--) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * Last index of.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final long[] a, final long valueToFind) {
        if (isNullOrEmpty(a)) {
            return INDEX_NOT_FOUND;
        }

        return lastIndexOf(a, a.length - 1, valueToFind);
    }

    /**
     * Last index of.
     *
     * @param a
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final long[] a, final int startIndexFromBack, final long valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.min(startIndexFromBack, len - 1); i >= 0; i--) {
            if (a[i] == valueToFind) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * Last index of.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final float[] a, final float valueToFind) {
        if (isNullOrEmpty(a)) {
            return INDEX_NOT_FOUND;
        }

        return lastIndexOf(a, a.length - 1, valueToFind);
    }

    /**
     * Last index of.
     *
     * @param a
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final float[] a, final int startIndexFromBack, final float valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.min(startIndexFromBack, len - 1); i >= 0; i--) {
            if (Float.compare(a[i], valueToFind) == 0) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * Last index of.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final double[] a, final double valueToFind) {
        if (isNullOrEmpty(a)) {
            return INDEX_NOT_FOUND;
        }

        return lastIndexOf(a, a.length - 1, valueToFind);
    }

    /**
     * Last index of.
     *
     * @param a
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final double[] a, final int startIndexFromBack, final double valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.min(startIndexFromBack, len - 1); i >= 0; i--) {
            if (Double.compare(a[i], valueToFind) == 0) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * 
Finds the last index of the given value within a given tolerance in the array.
     * This method will return the index of the last value which falls between the region
     * defined by valueToFind - tolerance and valueToFind + tolerance.
     *
     * 
This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.
     *
     * @param a the array to search through for the object, may be {@code null}
     * @param valueToFind
     * @param tolerance tolerance of the search
     * @return the index of the value within the array,
     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
     */
    public static int lastIndexOf(final double[] a, final double valueToFind, final double tolerance) {
        return lastIndexOf(a, 0, valueToFind, tolerance);
    }

    /**
     * 
Finds the last index of the given value in the array starting at the given index.
     * This method will return the index of the last value which falls between the region
     * defined by valueToFind - tolerance and valueToFind + tolerance.
     *
     * 
This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.
     *
     * 
A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the
     * array length will search from the end of the array.
     *
     * @param a the array to traverse for looking for the object, may be {@code null}
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @param tolerance search for value within plus/minus this amount
     * @return the last index of the value within the array,
     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
     */
    public static int lastIndexOf(final double[] a, int startIndexFromBack, final double valueToFind, final double tolerance) {
        final int len = len(a);

        if (len == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

        final double min = valueToFind - tolerance;
        final double max = valueToFind + tolerance;

        for (int i = N.min(startIndexFromBack, len - 1); i >= 0; i--) {
            if (a[i] >= min && a[i] <= max) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * Last index of.
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final Object[] a, final Object valueToFind) {
        if (isNullOrEmpty(a)) {
            return INDEX_NOT_FOUND;
        }

        return lastIndexOf(a, a.length - 1, valueToFind);
    }

    /**
     * Last index of.
     *
     * @param a
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final Object[] a, final int startIndexFromBack, final Object valueToFind) {
        final int len = len(a);

        if (len == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

        for (int i = N.min(startIndexFromBack, len - 1); i >= 0; i--) {
            if (equals(a[i], valueToFind)) {
                return i;
            }
        }

        return INDEX_NOT_FOUND;
    }

    /**
     * Last index of.
     *
     * @param c
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final Collection c, final Object valueToFind) {
        if (isNullOrEmpty(c)) {
            return INDEX_NOT_FOUND;
        }

        return lastIndexOf(c, c.size() - 1, valueToFind);
    }

    /**
     * Last index of.
     *
     * @param c
     * @param startIndexFromBack the start index to traverse backwards from
     * @param valueToFind
     * @return
     */
    public static int lastIndexOf(final Collection c, final int startIndexFromBack, final Object valueToFind) {
        final int size = N.size(c);

        if (size == 0 || startIndexFromBack < 0) {
            return INDEX_NOT_FOUND;
        }

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

            if (c instanceof RandomAccess) {
                for (int i = N.min(startIndexFromBack, size - 1); i >= 0; i--) {
                    if (N.equals(list.get(i), valueToFind)) {
                        return i;
                    }
                }
            } else {
                final ListIterator iter = list.listIterator(list.size());

                for (int i = size - 1; iter.hasPrevious(); i--) {
                    if (i > startIndexFromBack) {
                        iter.previous();
                    } else if (N.equals(iter.previous(), valueToFind)) {
                        return i;
                    }
                }
            }

            return INDEX_NOT_FOUND;
        } else if (c instanceof Deque) {
            final Iterator iter = ((Deque) c).descendingIterator();

            for (int i = size - 1; iter.hasNext(); i--) {
                if (i > startIndexFromBack) {
                    iter.next();
                } else if (N.equals(iter.next(), valueToFind)) {
                    return i;
                }
            }

            return INDEX_NOT_FOUND;
        } else {
            try {
                Method m = null;

                if ((m = ClassUtil.getDeclaredMethod(c.getClass(), "descendingIterator")) != null && Modifier.isPublic(m.getModifiers())
                        && Iterator.class.isAssignableFrom(m.getReturnType())) {

                    final Iterator iter = ClassUtil.invokeMethod(c, m);

                    for (int i = size - 1; iter.hasNext(); i--) {
                        if (i > startIndexFromBack) {
                            iter.next();
                        } else if (N.equals(iter.next(), valueToFind)) {
                            return i;
                        }
                    }

                    return INDEX_NOT_FOUND;
                }
            } catch (Exception e2) {
                // continue
            }

            final Object[] a = c.toArray();

            return lastIndexOf(a, startIndexFromBack, valueToFind);
        }
    }

    /**
     *
     *
     * @param a
     * @param valueToFind
     * @return
     */
    public static int lastIndexOfIgnoreCase(final String[] a, final String valueToFind) {
        if (N.isNullOrEmpty(a)) {
            return N.INDEX_NOT_FOUND;
        }

        for (int i = a.length - 1; i >= 0; i--) {
            if (N.equalsIgnoreCase(a[i], valueToFind)) {
                return i;
            }
        }

        return N.INDEX_NOT_FOUND;
    }

    /**
     * Last index of sub list.
     *
     * @param sourceList
     * @param subListToFind
     * @return
     * @see java.util.Collections#lastIndexOfSubList(List, List)
     */
    public static int lastIndexOfSubList(final List sourceList, final List subListToFind) {
        if (isNullOrEmpty(sourceList) || isNullOrEmpty(subListToFind)) {
            return INDEX_NOT_FOUND;
        }

        return Collections.lastIndexOfSubList(sourceList, subListToFind);
    }

    /**
     * Find first index.
     *
     * @param 
     * @param 
     * @param a
     * @param predicate
     * @return the optional int
     * @throws E the e
     */
    public static  OptionalInt findFirstIndex(final T[] a, final Throwables.Predicate predicate) throws E {
        if (N.isNullOrEmpty(a)) {
            return OptionalInt.empty();
        }

        for (int len = a.length, i = 0; i < len; i++) {
            if (predicate.test(a[i])) {
                return OptionalInt.of(i);
            }
        }

        return OptionalInt.empty();
    }

    /**
     * Find first index.
     *
     * @param 
     * @param 
     * @param 
     * @param a
     * @param valueToFind
     * @param predicate
     * @return the optional int
     * @throws E the e
     */
    public static  OptionalInt findFirstIndex(final T[] a, final U valueToFind,
            final Throwables.BiPredicate predicate) throws E {
        if (N.isNullOrEmpty(a)) {
            return OptionalInt.empty();
        }

        for (int len = a.length, i = 0; i < len; i++) {
            if (predicate.test(a[i], valueToFind)) {
                return OptionalInt.of(i);
            }
        }

        return OptionalInt.empty();
    }

    /**
     * Find first index.
     *
     * @param 
     * @param 
     * @param c
     * @param predicate
     * @return the optional int
     * @throws E the e
     */
    public static  OptionalInt findFirstIndex(final Collection c, final Throwables.Predicate predicate)
            throws E {
        if (N.isNullOrEmpty(c)) {
            return OptionalInt.empty();
        }

        int idx = 0;

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

            idx++;
        }

        return OptionalInt.empty();
    }

    /**
     * Find first index.
     *
     * @param 
     * @param 
     * @param 
     * @param c
     * @param valueToFind
     * @param predicate
     * @return the optional int
     * @throws E the e
     */
    public static  OptionalInt findFirstIndex(final Collection c, final U valueToFind,
            final Throwables.BiPredicate predicate) throws E {
        if (N.isNullOrEmpty(c)) {
            return OptionalInt.empty();
        }

        int idx = 0;

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

            idx++;
        }

        return OptionalInt.empty();
    }

    /**
     * Find last index.
     *
     * @param 
     * @param 
     * @param a
     * @param predicate
     * @return the optional int
     * @throws E the e
     */
    public static  OptionalInt findLastIndex(final T[] a, final Throwables.Predicate predicate) throws E {
        if (N.isNullOrEmpty(a)) {
            return OptionalInt.empty();
        }

        for (int i = a.length - 1; i >= 0; i--) {
            if (predicate.test(a[i])) {
                return OptionalInt.of(i);
            }
        }

        return OptionalInt.empty();
    }

    /**
     * Find last index.
     *
     * @param 
     * @param 
     * @param 
     * @param a
     * @param valueToFind
     * @param predicate
     * @return the optional int
     * @throws E the e
     */
    public static  OptionalInt findLastIndex(final T[] a, final U valueToFind,
            final Throwables.BiPredicate predicate) throws E {
        if (N.isNullOrEmpty(a)) {
            return OptionalInt.empty();
        }

        for (int i = a.length - 1; i >= 0; i--) {
            if (predicate.test(a[i], valueToFind)) {
                return OptionalInt.of(i);
            }
        }

        return OptionalInt.empty();
    }

    /**
     * Find last index.
     *
     * @param 
     * @param 
     * @param c
     * @param predicate
     * @return the optional int
     * @throws E the e
     */
    public static  OptionalInt findLastIndex(final Collection c, final Throwables.Predicate predicate)
            throws E {
        if (N.isNullOrEmpty(c)) {
            return OptionalInt.empty();
        }

        final int size = c.size();

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

            if (c 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 if (c instanceof Deque) {
            final Iterator iter = ((Deque) c).descendingIterator();

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

            return OptionalInt.empty();
        } else {
            try {
                Method m = null;

                if ((m = ClassUtil.getDeclaredMethod(c.getClass(), "descendingIterator")) != null && Modifier.isPublic(m.getModifiers())
                        && Iterator.class.isAssignableFrom(m.getReturnType())) {

                    final Iterator iter = ClassUtil.invokeMethod(c, m);

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

                    return OptionalInt.empty();
                }
            } catch (Exception e) {
                // continue
            }

            final T[] a = (T[]) c.toArray();

            for (int i = a.length - 1; i >= 0; i--) {
                if (predicate.test(a[i])) {
                    return OptionalInt.of(i);
                }
            }

            return OptionalInt.empty();
        }
    }

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param c
     * @param valueToFind
     * @param predicate
     * @return
     * @throws E
     */
    public static  OptionalInt findLastIndex(final Collection c, final U valueToFind,
            final Throwables.BiPredicate predicate) throws E {
        if (N.isNullOrEmpty(c)) {
            return OptionalInt.empty();
        }

        final Throwables.Predicate predicate2 = t -> predicate.test(t, valueToFind);

        return findLastIndex(c, predicate2);
    }

    /**
     * Creates the mask.
     *
     * @param 
     * @param interfaceClass
     * @return
     */
    static  T createMask(final Class interfaceClass) {
        InvocationHandler h = (proxy, method, args) -> {
            throw new UnsupportedOperationException("It's a mask");
        };

        return newProxyInstance(interfaceClass, h);
    }

    /**
     * The Class NullMask.
     */
    static class NullMask implements Serializable {

        /** The Constant serialVersionUID. */
        private static final long serialVersionUID = 5887875956120266479L;

        /**
         * Instantiates a new null mask.
         */
        private NullMask() {
        }

        /**
         *
         * @return
         */
        @Override
        public String toString() {
            return "NULL";
        }

        /**
         *
         * @return
         */
        protected Object readResolve() {
            return NULL_MASK;
        }
    }
}
 















© 2015 - 2024 Weber Informatics LLC | Privacy Policy