前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Java工具集-数组(ArrayUtil)

Java工具集-数组(ArrayUtil)

作者头像
cwl_java
发布2019-10-28 11:29:07
1.3K0
发布2019-10-28 11:29:07
举报
文章被收录于专栏:cwl_Java

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。

本文链接:https://blog.csdn.net/weixin_42528266/article/details/102618972

简单工具类

写作初衷:由于日常开发经常需要用到很多工具类,经常根据需求自己写也比较麻烦 网上好了一些工具类例如commom.lang3或者hutool或者Jodd这样的开源工具,但是 发现他们之中虽然设计不错,但是如果我想要使用,就必须要引入依赖并且去维护依赖,有些 甚至会有存在版本编译不通过问题,故此想要写作一个每个类都可以作为独立工具类使用 每个使用者只需要复制该类,到任何项目当中都可以使用,所以需要尊从以下两个原则才能 做到.在此诚邀各位大佬参与.可以把各自用过的工具,整合成只依赖JDK,每个类都能够单独 使用的工具.每个人当遇到业务需求需要使用的时候,只需要到这里单独拷贝一个即可使用. 抛弃传统的需要引入依赖的烦恼.让大家一起来解决你所面临的业务问题吧!

介绍

遵从两大原则

  • 1.绝不依赖JDK以外的源码
  • 2.牺牲代码复用性,每个类都必须是单独的组件,绝不互相引用,做到完全解耦
代码语言:javascript
复制
import com.sun.xml.internal.ws.util.UtilException;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
import java.util.*;

/**
 * @program: myutil
 * @description:
 * @author: ChenWenLong
 * @create: 2019-05-21 16:40
 **/
public class ArrayUtil {

    /** 数组中元素未找到的下标,值为-1 */
    public static final int INDEX_NOT_FOUND = -1;

    //======================isEmpty=========================
    /**
     * 功能描述:
     * 〈判断数组是否为空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:44
     */
    @SuppressWarnings("unchecked")
    public static <T> boolean isEmpty(final T... array) {
        return array == null || array.length == 0;
    }

    /**
     * 功能描述:
     * 〈数组是否为空:此方法会匹配单一对象,如果此对象为null,则返回true
     * 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回false
     * 如果此对象为数组对象,数组长度大于0情况下返回false,否则返回true〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:44
     */
    public static boolean isEmpty(Object array) {
        if (null == array) {
            return true;
        } else if (isArray(array)) {
            return 0 == Array.getLength(array);
        }
        throw new UtilException("Object to provide is not a Array !");
    }

    /**
     * 功能描述:
     * 〈long数组是否为空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:46
     */
    public static boolean isEmpty(final long... array) {
        return array == null || array.length == 0;
    }

    /**
     * 功能描述:
     * 〈int数组是否为空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:46
     */
    public static boolean isEmpty(final int... array) {
        return array == null || array.length == 0;
    }

    /**
     * 功能描述:
     * 〈short数组是否为空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:47
     */
    public static boolean isEmpty(final short... array) {
        return array == null || array.length == 0;
    }

    /**
     * 功能描述:
     * 〈char数组是否为空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:47
     */
    public static boolean isEmpty(final char... array) {
        return array == null || array.length == 0;
    }

    /**
     * 功能描述:
     * 〈byte数组是否为空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:47
     */
    public static boolean isEmpty(final byte... array) {
        return array == null || array.length == 0;
    }

    /**
     * 功能描述:
     * 〈double数组是否为空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:48
     */
    public static boolean isEmpty(final double... array) {
        return array == null || array.length == 0;
    }

    /**
     * 功能描述:
     * 〈float数组是否为空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:48
     */
    public static boolean isEmpty(final float... array) {
        return array == null || array.length == 0;
    }

    /**
     * 数组是否为空
     *
     * @param array 数组
     * @return 是否为空
     */
    public static boolean isEmpty(final boolean... array) {
        return array == null || array.length == 0;
    }

    //======================isNotEmpty=========================
    /**
     * 功能描述:
     * 〈判断数组是否为非空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:49
     */
    @SuppressWarnings("unchecked")
    public static <T> boolean isNotEmpty(final T... array) {
        return (array != null && array.length != 0);
    }

    /**
     * 功能描述:
     * 〈数组是否为非空〉
     *  此方法会匹配单一对象,如果此对象为null,则返回false
     *  如果此对象为非数组,理解为此对象为数组的第一个元素,则返回true
     *  如果此对象为数组对象,数组长度大于0情况下返回true,否则返回false
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:49
     */
    public static boolean isNotEmpty(final Object array) {
        return false == isEmpty((Object) array);
    }

    /**
     * 功能描述:
     * 〈long数组为非空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:50
     */
    public static boolean isNotEmpty(final long... array) {
        return (array != null && array.length != 0);
    }

    /**
     * 功能描述:
     * 〈int数组为非空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:50
     */
    public static boolean isNotEmpty(final int... array) {
        return (array != null && array.length != 0);
    }

    /**
     * 功能描述:
     * 〈short数组为非空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:51
     */
    public static boolean isNotEmpty(final short... array) {
        return (array != null && array.length != 0);
    }

    /**
     * 功能描述:
     * 〈char数组非空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:57
     */
    public static boolean isNotEmpty(final char... array) {
        return (array != null && array.length != 0);
    }

    /**
     * 功能描述:
     * 〈byte数组非空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:57
     */
    public static boolean isNotEmpty(final byte... array) {
        return (array != null && array.length != 0);
    }

    /**
     * 功能描述:
     * 〈double数组非空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:57
     */
    public static boolean isNotEmpty(final double... array) {
        return (array != null && array.length != 0);
    }

    /**
     * 功能描述:
     * 〈float数组非空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:58
     */
    public static boolean isNotEmpty(final float... array) {
        return (array != null && array.length != 0);
    }

    /*
     * 功能描述:
     * 〈boolean数组非空〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:58
     */
    public static boolean isNotEmpty(final boolean... array) {
        return (array != null && array.length != 0);
    }

    /**
     * 功能描述:
     * 〈数组是否包含null〉
     *
     * @params : [array]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/21 16:59
     */
    @SuppressWarnings("unchecked")
    public static <T> boolean hasNull(T... array) {
        if (isNotEmpty(array)) {
            for (T element : array) {
                if (null == element) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 功能描述:
     * 〈返回数组的第一个元素〉
     *
     * @params : [array]
     * @return : T
     * @author : cwl
     * @date : 2019/5/21 17:00
     */
    @SuppressWarnings("unchecked")
    public static <T> T firstNonNull(T... array) {
        if (isNotEmpty(array)) {
            for (final T val : array) {
                if (null != val) {
                    return val;
                }
            }
        }
        return null;
    }

    /**
     * 功能描述:
     * 〈指定类型和大小,新建一个空数组〉
     *
     * @params : [componentType, newSize]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/21 17:01
     */
    @SuppressWarnings("unchecked")
    public static <T> T[] newArray(Class<?> componentType, int newSize) {
        return (T[]) Array.newInstance(componentType, newSize);
    }

    /**
     * 功能描述:
     * 〈指定大小创建一个空数组〉
     *
     * @params : [newSize]
     * @return : java.lang.Object[]
     * @author : cwl
     * @date : 2019/5/21 17:02
     */
    public static Object[] newArray(int newSize) {
        return new Object[newSize];
    }

    /**
     * 功能描述:
     * 〈根据数组对象获取数组对象的元素类型〉
     *
     * @params : [array]
     * @return : java.lang.Class<?>
     * @author : cwl
     * @date : 2019/5/21 17:03
     */
    public static Class<?> getComponentType(Object array) {
        return null == array ? null : array.getClass().getComponentType();
    }

    /**
     * 功能描述:
     * 〈根据数组字节码获取数组类型〉
     *
     * @params : [arrayClass]
     * @return : java.lang.Class<?>
     * @author : cwl
     * @date : 2019/5/21 17:04
     */
    public static Class<?> getComponentType(Class<?> arrayClass) {
        return null == arrayClass ? null : arrayClass.getComponentType();
    }

    /**
     * 功能描述:
     * 〈根据数组元素类型,获取数组类型〉
     *
     * @params : [componentType]
     * @return : java.lang.Class<?>
     * @author : cwl
     * @date : 2019/5/21 17:05
     */
    public static Class<?> getArrayType(Class<?> componentType) {
        return Array.newInstance(componentType, 0).getClass();
    }

    /**
     * 功能描述:
     * 〈强转数组类型,前提是数组元素类型是可被强制转换〉
     *
     * @params : [type, arrayObj]
     * @return : java.lang.Object[]
     * @author : cwl
     * @date : 2019/5/22 9:07
     */
    public static Object[] cast(Class<?> type, Object arrayObj) throws NullPointerException, IllegalArgumentException {
        if (null == arrayObj) {
            throw new NullPointerException("Argument [arrayObj] is null !");
        }
        if (false == arrayObj.getClass().isArray()) {
            throw new IllegalArgumentException("Argument [arrayObj] is not array !");
        }
        if (null == type) {
            return (Object[]) arrayObj;
        }

        final Class<?> componentType = type.isArray() ? type.getComponentType() : type;
        final Object[] array = (Object[]) arrayObj;
        final Object[] result = ArrayUtil.newArray(componentType, array.length);
        System.arraycopy(array, 0, result, 0, array.length);
        return result;
    }

    /**
     * 功能描述:
     * 〈将新元素添加到数组当中〉
     *
     * @params : [buffer, newElements]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 9:10
     */
    @SafeVarargs
    public static <T> T[] append(T[] buffer, T... newElements) {
        if(isEmpty(buffer)) {
            return newElements;
        }
        return insert(buffer, buffer.length, newElements);
    }

    /**
     * 功能描述:
     * 〈将新元素添加到数组当中〉
     *
     * @params : [array, newElements]
     * @return : java.lang.Object
     * @author : cwl
     * @date : 2019/5/22 9:11
     */
    @SafeVarargs
    public static <T> Object append(Object array, T... newElements) {
        if(isEmpty(array)) {
            return newElements;
        }
        return insert(array, length(array), newElements);
    }

    /**
     * 功能描述:
     * 〈将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加〉
     *
     * @params : [buffer, index, value]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 9:12
     */
    public static <T> T[] setOrAppend(T[] buffer, int index, T value) {
        if(index < buffer.length) {
            Array.set(buffer, index, value);
            return buffer;
        }else {
            return append(buffer, value);
        }
    }

    /**
     * 功能描述:
     * 〈将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加〉
     *
     * @params : [array, index, value]
     * @return : java.lang.Object
     * @author : cwl
     * @date : 2019/5/22 9:12
     */
    public static Object setOrAppend(Object array, int index, Object value) {
        if(index < length(array)) {
            Array.set(array, index, value);
            return array;
        }else {
            return append(array, value);
        }
    }

    /**
     * 功能描述:
     * 〈将新元素插入到到已有数组中的某个位置,添加新元素会生成一个新的数组,不影响原数组,
     * 如果插入位置为为负数,从原数组从后向前计数,若大于原数组长度,则空白处用null填充〉
     *
     * @params : [buffer, index, newElements]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 9:13
     */
    @SuppressWarnings("unchecked")
    public static <T> T[] insert(T[] buffer, int index, T... newElements) {
        return (T[]) insert((Object)buffer, index, newElements);
    }

    /**
     * 功能描述:
     * 〈将新元素插入到到已有数组中的某个位置,添加新元素会生成一个新的数组,不影响原数组,
     * 如果插入位置为为负数,从原数组从后向前计数,若大于原数组长度,则空白处用null填充〉
     *
     * @params : [buffer, index, newElements]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 9:13
     */
    @SuppressWarnings("unchecked")
    public static <T> Object insert(Object array, int index, T... newElements) {
        if (isEmpty(newElements)) {
            return array;
        }
        if(isEmpty(array)) {
            return newElements;
        }

        final int len = length(array);
        if (index < 0) {
            index = (index % len) + len;
        }

        final T[] result = newArray(array.getClass().getComponentType(), Math.max(len, index) + newElements.length);
        System.arraycopy(array, 0, result, 0, Math.min(len, index));
        System.arraycopy(newElements, 0, result, index, newElements.length);
        if (index < len) {
            System.arraycopy(array, index, result, index + newElements.length, len - index);
        }
        return result;
    }

    /**
     * 功能描述:
     * 〈生成一个新的重新设置大小的数组,调整大小后拷贝原数组到新数组下。扩大则占位前N个位置,缩小则截断〉
     *
     * @params : [buffer, newSize, componentType]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 9:14
     */
    public static <T> T[] resize(T[] buffer, int newSize, Class<?> componentType) {
        T[] newArray = newArray(componentType, newSize);
        if (isNotEmpty(buffer)) {
            System.arraycopy(buffer, 0, newArray, 0, Math.min(buffer.length, newSize));
        }
        return newArray;
    }

    /**
     * 功能描述:
     * 〈生成一个新的重新设置大小的数组,新数组的类型为原数组的类型,调整大小后拷贝原数组到新数组下。扩大则占位前N个位置,缩小则截断〉
     *
     * @params : [buffer, newSize]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 9:15
     */
    public static <T> T[] resize(T[] buffer, int newSize) {
        return resize(buffer, newSize, buffer.getClass().getComponentType());
    }

    /**
     * 功能描述:
     * 〈将多个数组合并在一起,忽略null的数组〉
     *
     * @params : [arrays]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 9:15
     */
    @SafeVarargs
    public static <T> T[] addAll(T[]... arrays) {
        if (arrays.length == 1) {
            return arrays[0];
        }

        int length = 0;
        for (T[] array : arrays) {
            if (array == null) {
                continue;
            }
            length += array.length;
        }
        T[] result = newArray(arrays.getClass().getComponentType().getComponentType(), length);

        length = 0;
        for (T[] array : arrays) {
            if (array == null) {
                continue;
            }
            System.arraycopy(array, 0, result, length, array.length);
            length += array.length;
        }
        return result;
    }

    /**
     * 功能描述:
     * 〈数组复制〉
     *
     * @params : [src源数组, srcPos源数组开始位置, dest目标数组, destPos目标数组开始位置, length拷贝数组长度]
     * @return : java.lang.Object
     * @author : cwl
     * @date : 2019/5/22 9:17
     */
    public static Object copy(Object src, int srcPos, Object dest, int destPos, int length) {
        System.arraycopy(src, srcPos, dest, destPos, length);
        return dest;
    }

    /**
     * 功能描述:
     * 〈数组复制,缘数组和目标数组都是从位置0开始复制〉
     *
     * @params : [src, dest, length]
     * @return : java.lang.Object
     * @author : cwl
     * @date : 2019/5/22 9:18
     */
    public static Object copy(Object src, Object dest, int length) {
        System.arraycopy(src, 0, dest, 0, length);
        return dest;
    }

    /**
     * 功能描述:
     * 〈克隆数组〉
     *
     * @params : [array]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 9:18
     */
    public static <T> T[] clone(T[] array) {
        if (array == null) {
            return null;
        }
        return array.clone();
    }

    /**
     * 功能描述:
     * 〈克隆数组,如果非数组返回null〉
     *
     * @params : [obj]
     * @return : T
     * @author : cwl
     * @date : 2019/5/22 9:20
     */
    @SuppressWarnings("unchecked")
    public static <T> T clone(final T obj) {
        if (null == obj) {
            return null;
        }
        if (isArray(obj)) {
            final Object result;
            final Class<?> componentType = obj.getClass().getComponentType();
            if (componentType.isPrimitive()) {// 原始类型
                int length = Array.getLength(obj);
                result = Array.newInstance(componentType, length);
                while (length-- > 0) {
                    Array.set(result, length, Array.get(obj, length));
                }
            } else {
                result = ((Object[]) obj).clone();
            }
            return (T) result;
        }
        return null;
    }

    /**
     * 功能描述:
     * 〈生成一个从0开始的数字列表〉
     *
     * @params : [excludedEnd]
     * @return : int[]
     * @author : cwl
     * @date : 2019/5/22 9:20
     */
    public static int[] range(int excludedEnd) {
        return range(0, excludedEnd, 1);
    }

    /**
     * 功能描述:
     * 〈自动生成一个数字列表,自动判定正序反序〉
     *
     * @params : [includedStart包含开始数, excludedEnd不包含结尾数]
     * @return : int[]
     * @author : cwl
     * @date : 2019/5/22 9:21
     */
    public static int[] range(int includedStart, int excludedEnd) {
        return range(includedStart, excludedEnd, 1);
    }

    /**
     * 功能描述:
     * 〈自动生成一个数字列表,自动判定正序反序,可以根据要求生成步进〉
     *
     * @params : [includedStart, excludedEnd, step每步前进多少]
     * @return : int[]
     * @author : cwl
     * @date : 2019/5/22 9:23
     */
    public static int[] range(int includedStart, int excludedEnd, int step) {
        if (includedStart > excludedEnd) {
            int tmp = includedStart;
            includedStart = excludedEnd;
            excludedEnd = tmp;
        }

        if (step <= 0) {
            step = 1;
        }

        int deviation = excludedEnd - includedStart;
        int length = deviation / step;
        if (deviation % step != 0) {
            length += 1;
        }
        int[] range = new int[length];
        for (int i = 0; i < length; i++) {
            range[i] = includedStart;
            includedStart += step;
        }
        return range;
    }

    /**
     * 功能描述:
     * 〈按照要求拆分byte[]〉
     *
     * @params : [array, len]
     * @return : byte[][]
     * @author : cwl
     * @date : 2019/5/22 9:24
     */
    public static byte[][] split(byte[] array, int len) {
        int x = array.length / len;
        int y = array.length % len;
        int z = 0;
        if (y != 0) {
            z = 1;
        }
        byte[][] arrays = new byte[x + z][];
        byte[] arr;
        for (int i = 0; i < x + z; i++) {
            arr = new byte[len];
            if (i == x + z - 1 && y != 0) {
                System.arraycopy(array, i * len, arr, 0, y);
            } else {
                System.arraycopy(array, i * len, arr, 0, len);
            }
            arrays[i] = arr;
        }
        return arrays;
    }


    /**
     * 映射键值(参考Python的zip()函数)<br>
     * 例如:<br>
     * keys = [a,b,c,d]<br>
     * values = [1,2,3,4]<br>
     * 则得到的Map是 {a=1, b=2, c=3, d=4}<br>
     * 如果两个数组长度不同,则只对应最短部分
     *
     * @param <K> Key类型
     * @param <V> Value类型
     * @param keys 键列表
     * @param values 值列表
     * @param isOrder 是否有序
     * @return Map
     */
    public static final float DEFAULT_LOAD_FACTOR = 0.75f;
    public static <K, V> Map<K, V> zip(K[] keys, V[] values, boolean isOrder) {
        if (isEmpty(keys) || isEmpty(values)) {
            return null;
        }

        final int size = Math.min(keys.length, values.length);
        int initialCapacity = (int) (size / DEFAULT_LOAD_FACTOR);
        final Map<K, V> map = isOrder ? new LinkedHashMap<K, V>(initialCapacity) : new HashMap<K, V>(initialCapacity);
        for (int i = 0; i < size; i++) {
            map.put(keys[i], values[i]);
        }

        return map;
    }

    /**
     * 映射键值(参考Python的zip()函数),返回Map无序<br>
     * 例如:<br>
     * keys = [a,b,c,d]<br>
     * values = [1,2,3,4]<br>
     * 则得到的Map是 {a=1, b=2, c=3, d=4}<br>
     * 如果两个数组长度不同,则只对应最短部分
     *
     * @param <K> Key类型
     * @param <V> Value类型
     * @param keys 键列表
     * @param values 值列表
     * @return Map
     */
    public static <K, V> Map<K, V> zip(K[] keys, V[] values) {
        return zip(keys, values, false);
    }

    /**
     * 功能描述:
     * 〈返回数组中指定元素所在位置,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 9:36
     */
    public static <T> int indexOf(T[] array, Object value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if ((value == array[i]) || (value != null && value.equals(array[i]))) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈返回数组中指定元素所在位置,忽略大小写,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:24
     */
    public static int indexOfIgnoreCase(CharSequence[] array, CharSequence value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if (equalsIgnoreCase(array[i], value,true)) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈是否忽略大小写的比值〉
     *
     * @params : [charSequence, value, ignoreCase]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 9:43
     */
    private static boolean equalsIgnoreCase(CharSequence charSequence, CharSequence value ,boolean ignoreCase) {
        if (null == charSequence) {
            // 只有两个都为null才判断相等
            return value == null;
        }
        if (null == value) {
            // 字符串2空,字符串1非空,直接false
            return false;
        }

        if (ignoreCase) {
            return charSequence.toString().equalsIgnoreCase(value.toString());
        } else {
            return charSequence.equals(value);
        }
    }

    /**
     * 功能描述:
     * 〈返回数组中指定元素所在最后的位置,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:25
     */
    public static <T> int lastIndexOf(T[] array, Object value) {
        if (null != array) {
            for (int i = array.length - 1; i >= 0; i--) {
                if ((value == array[i]) || (value != null && value.equals(array[i]))) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈数组中是否包含元素〉
     *
     * @params : [array, value]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 11:25
     */
    public static <T> boolean contains(T[] array, T value) {
        return indexOf(array, value) > INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈数组中是否包含指定元素中的任意一个〉
     *
     * @params : [array, values]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 11:25
     */
    @SuppressWarnings("unchecked")
    public static <T> boolean containsAny(T[] array, T... values) {
        for (T value : values) {
            if(contains(array, value)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 功能描述:
     * 〈数组中是否包含元素,忽略大小写〉
     *
     * @params : [array, value]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 11:26
     */
    public static boolean containsIgnoreCase(CharSequence[] array, CharSequence value) {
        return indexOfIgnoreCase(array, value) > INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈从long数组前面找指定元素,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:26
     */
    public static int indexOf(long[] array, long value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈从long数组后面找数组中的指定元素,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:26
     */
    public static int lastIndexOf(long[] array, long value) {
        if (null != array) {
            for (int i = array.length - 1; i >= 0; i--) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈long数组中是否包含元素〉
     *
     * @params : [array, value]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 11:27
     */
    public static boolean contains(long[] array, long value) {
        return indexOf(array, value) > INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈从int数组前面开始找数组中的指定元素,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:27
     */
    public static int indexOf(int[] array, int value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈从int数组后面开始找数组中的指定元素,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:28
     */
    public static int lastIndexOf(int[] array, int value) {
        if (null != array) {
            for (int i = array.length - 1; i >= 0; i--) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * int数组中是否包含元素
     *
     * @param array 数组
     * @param value 被检查的元素
     * @return 是否包含
     * @since 3.0.7
     */
    public static boolean contains(int[] array, int value) {
        return indexOf(array, value) > INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈从short数组前面开始开始找指定元素所在位置,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:33
     */
    public static int indexOf(short[] array, short value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈从short数组后面开始找指定元素,未找到则返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:34
     */
    public static int lastIndexOf(short[] array, short value) {
        if (null != array) {
            for (int i = array.length - 1; i >= 0; i--) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈short数组中是否包含元素〉
     *
     * @params : [array, value]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 11:35
     */
    public static boolean contains(short[] array, short value) {
        return indexOf(array, value) > INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈从char数组前面开始找指定元素所在位置,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:35
     */
    public static int indexOf(char[] array, char value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈从char数组后面开始找指定元素所在的位置,未找到则返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:36
     */
    public static int lastIndexOf(char[] array, char value) {
        if (null != array) {
            for (int i = array.length - 1; i >= 0; i--) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈char数组中是否包含元素〉
     *
     * @params : [array, value]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 11:37
     */
    public static boolean contains(char[] array, char value) {
        return indexOf(array, value) > INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈找到byte数组当中第一次出现的位置,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:37
     */
    public static int indexOf(byte[] array, byte value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈找到byte数组中指定元素最后出现的位置,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:38
     */
    public static int lastIndexOf(byte[] array, byte value) {
        if (null != array) {
            for (int i = array.length - 1; i >= 0; i--) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈byte数组是否包含元素〉
     *
     * @params : [array, value]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 11:39
     */
    public static boolean contains(byte[] array, byte value) {
        return indexOf(array, value) > INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈double数组中指定元素第一次出现的位置,未找到则返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:39
     */
    public static int indexOf(double[] array, double value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈找到double数组中指定元素最后出现的位置,未找到则返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:40
     */
    public static int lastIndexOf(double[] array, double value) {
        if (null != array) {
            for (int i = array.length - 1; i >= 0; i--) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈double数组中是否包含元素〉
     *
     * @params : [array, value]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 11:40
     */
    public static boolean contains(double[] array, double value) {
        return indexOf(array, value) > INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈返回float数组中指定元素所在位置,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:49
     */
    public static int indexOf(float[] array, float value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈返回float数组中指定的元素所在最后的位置,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 11:50
     */
    public static int lastIndexOf(float[] array, float value) {
        if (null != array) {
            for (int i = array.length - 1; i >= 0; i--) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈float数组中是否包含元素〉
     *
     * @params : [array, value]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 12:00
     */
    public static boolean contains(float[] array, float value) {
        return indexOf(array, value) > INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈返回boolean数组中指定元素所在位置,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 13:45
     */
    public static int indexOf(boolean[] array, boolean value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈返回boolean数组中指定元素所在最后的位置,未找到返回-1〉
     *
     * @params : [array, value]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 13:46
     */
    public static int lastIndexOf(boolean[] array, boolean value) {
        if (null != array) {
            for (int i = array.length - 1; i >= 0; i--) {
                if (value == array[i]) {
                    return i;
                }
            }
        }
        return INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈boolean数组中是否包含元素〉
     *
     * @params : [array, value]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 13:46
     */
    public static boolean contains(boolean[] array, boolean value) {
        return indexOf(array, value) > INDEX_NOT_FOUND;
    }

    /**
     * 功能描述:
     * 〈将原始类型数组包装为包装类型〉
     *
     * @params : [values]
     * @return : java.lang.Integer[]
     * @author : cwl
     * @date : 2019/5/22 13:47
     */
    public static Integer[] wrap(int... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new Integer[0];
        }

        final Integer[] array = new Integer[length];
        for (int i = 0; i < length; i++) {
            array[i] = Integer.valueOf(values[i]);
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈包装类数组转为原始类型数组〉
     *
     * @params : [values]
     * @return : int[]
     * @author : cwl
     * @date : 2019/5/22 13:47
     */
    public static int[] unWrap(Integer... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new int[0];
        }

        final int[] array = new int[length];
        for (int i = 0; i < length; i++) {
            array[i] = values[i].intValue();
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈将原始类型数组包装为包装类型〉
     *
     * @params : [values]
     * @return : java.lang.Long[]
     * @author : cwl
     * @date : 2019/5/22 13:48
     */
    public static Long[] wrap(long... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new Long[0];
        }

        final Long[] array = new Long[length];
        for (int i = 0; i < length; i++) {
            array[i] = Long.valueOf(values[i]);
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈包装类数组转为原始类型数组〉
     *
     * @params : [values]
     * @return : long[]
     * @author : cwl
     * @date : 2019/5/22 13:48
     */
    public static long[] unWrap(Long... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new long[0];
        }

        final long[] array = new long[length];
        for (int i = 0; i < length; i++) {
            array[i] = values[i].longValue();
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈将原始类型数组包装为包装类型〉
     *
     * @params : [values]
     * @return : java.lang.Character[]
     * @author : cwl
     * @date : 2019/5/22 13:48
     */
    public static Character[] wrap(char... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new Character[0];
        }

        final Character[] array = new Character[length];
        for (int i = 0; i < length; i++) {
            array[i] = Character.valueOf(values[i]);
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈包装类数组转为原始类型数组〉
     *
     * @params : [values]
     * @return : char[]
     * @author : cwl
     * @date : 2019/5/22 13:48
     */
    public static char[] unWrap(Character... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new char[0];
        }

        char[] array = new char[length];
        for (int i = 0; i < length; i++) {
            array[i] = values[i].charValue();
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈将原始类型数组包装为包装类型〉
     *
     * @params : [values]
     * @return : java.lang.Byte[]
     * @author : cwl
     * @date : 2019/5/22 13:48
     */
    public static Byte[] wrap(byte... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new Byte[0];
        }

        final Byte[] array = new Byte[length];
        for (int i = 0; i < length; i++) {
            array[i] = Byte.valueOf(values[i]);
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈包装类数组转为原始类型数组〉
     *
     * @params : [values]
     * @return : byte[]
     * @author : cwl
     * @date : 2019/5/22 13:49
     */
    public static byte[] unWrap(Byte... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new byte[0];
        }

        final byte[] array = new byte[length];
        for (int i = 0; i < length; i++) {
            array[i] = values[i].byteValue();
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈将原始类型数组包装为包装类型〉
     *
     * @params : [values]
     * @return : java.lang.Short[]
     * @author : cwl
     * @date : 2019/5/22 13:49
     */
    public static Short[] wrap(short... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new Short[0];
        }

        final Short[] array = new Short[length];
        for (int i = 0; i < length; i++) {
            array[i] = Short.valueOf(values[i]);
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈包装类数组转为原始类型数组〉
     *
     * @params : [values]
     * @return : short[]
     * @author : cwl
     * @date : 2019/5/22 13:50
     */
    public static short[] unWrap(Short... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new short[0];
        }

        final short[] array = new short[length];
        for (int i = 0; i < length; i++) {
            array[i] = values[i].shortValue();
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈将原始类型数组包装为包装类型〉
     *
     * @params : [values]
     * @return : java.lang.Float[]
     * @author : cwl
     * @date : 2019/5/22 13:50
     */
    public static Float[] wrap(float... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new Float[0];
        }

        final Float[] array = new Float[length];
        for (int i = 0; i < length; i++) {
            array[i] = Float.valueOf(values[i]);
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈包装类数组转为原始类型数组〉
     *
     * @params : [values]
     * @return : float[]
     * @author : cwl
     * @date : 2019/5/22 13:50
     */
    public static float[] unWrap(Float... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new float[0];
        }

        final float[] array = new float[length];
        for (int i = 0; i < length; i++) {
            array[i] = values[i].floatValue();
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈将原始类型数组包装为包装类型〉
     *
     * @params : [values]
     * @return : java.lang.Double[]
     * @author : cwl
     * @date : 2019/5/22 13:51
     */
    public static Double[] wrap(double... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new Double[0];
        }

        final Double[] array = new Double[length];
        for (int i = 0; i < length; i++) {
            array[i] = Double.valueOf(values[i]);
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈包装类数组转为原始类型数组〉
     *
     * @params : [values]
     * @return : double[]
     * @author : cwl
     * @date : 2019/5/22 13:51
     */
    public static double[] unWrap(Double... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new double[0];
        }

        final double[] array = new double[length];
        for (int i = 0; i < length; i++) {
            array[i] = values[i].doubleValue();
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈将原始类型数组包装为包装类型〉
     *
     * @params : [values]
     * @return : java.lang.Boolean[]
     * @author : cwl
     * @date : 2019/5/22 13:52
     */
    public static Boolean[] wrap(boolean... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new Boolean[0];
        }

        final Boolean[] array = new Boolean[length];
        for (int i = 0; i < length; i++) {
            array[i] = Boolean.valueOf(values[i]);
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈包装类数组转为原始类型数组〉
     *
     * @params : [values]
     * @return : boolean[]
     * @author : cwl
     * @date : 2019/5/22 13:52
     */
    public static boolean[] unWrap(Boolean... values) {
        if (null == values) {
            return null;
        }
        final int length = values.length;
        if (0 == length) {
            return new boolean[0];
        }

        final boolean[] array = new boolean[length];
        for (int i = 0; i < length; i++) {
            array[i] = values[i].booleanValue();
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈包装数组对象〉
     *
     * @params : [obj]
     * @return : java.lang.Object[]
     * @author : cwl
     * @date : 2019/5/22 13:52
     */
    public static Object[] wrap(Object obj) {
        if (null == obj) {
            return null;
        }
        if (isArray(obj)) {
            try {
                return (Object[]) obj;
            } catch (Exception e) {
                final String className = obj.getClass().getComponentType().getName();
                switch (className) {
                    case "long":
                        return wrap((long[]) obj);
                    case "int":
                        return wrap((int[]) obj);
                    case "short":
                        return wrap((short[]) obj);
                    case "char":
                        return wrap((char[]) obj);
                    case "byte":
                        return wrap((byte[]) obj);
                    case "boolean":
                        return wrap((boolean[]) obj);
                    case "float":
                        return wrap((float[]) obj);
                    case "double":
                        return wrap((double[]) obj);
                    default:
                        throw new UtilException(e);
                }
            }
        }
        throw new UtilException("Argument is not Array!", obj.getClass());
    }

    /**
     * 功能描述:
     * 〈对象是否为数组对象〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/5/22 13:53
     */
    public static boolean isArray(Object obj) {
        if (null == obj) {
            // throw new NullPointerException("Object check for isArray is null");
            return false;
        }
        return obj.getClass().isArray();
    }

    /**
     * 功能描述:
     * 〈获取数组对象中指定index的值,支持负数,例如-1表示倒数第一个值,如果数组下标越界,返回null〉
     *
     * @params : [array, index]
     * @return : T
     * @author : cwl
     * @date : 2019/5/22 13:53
     */
    @SuppressWarnings("unchecked")
    public static <T> T get(Object array, int index) {
        if(null == array) {
            return null;
        }

        if (index < 0) {
            index += Array.getLength(array);
        }
        try {
            return (T) Array.get(array, index);
        } catch (ArrayIndexOutOfBoundsException e) {
            return null;
        }
    }

    /**
     * 功能描述:
     * 〈获取数组中指定多个下标元素值,组成新数组〉
     *
     * @params : [array, indexes]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 13:53
     */
    public static <T> T[] getAny(Object array, int... indexes) {
        if(null == array) {
            return null;
        }

        final T[] result = newArray(array.getClass().getComponentType(), indexes.length);
        for (int i : indexes) {
            result[i] = get(array, i);
        }
        return result;
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 13:54
     */
    public static <T> T[] sub(T[] array, int start, int end) {
        int length = length(array);
        if (start < 0) {
            start += length;
        }
        if (end < 0) {
            end += length;
        }
        if (start == length) {
            return newArray(array.getClass().getComponentType(), 0);
        }
        if (start > end) {
            int tmp = start;
            start = end;
            end = tmp;
        }
        if (end > length) {
            if (start >= length) {
                return newArray(array.getClass().getComponentType(), 0);
            }
            end = length;
        }
        return Arrays.copyOfRange(array, start, end);
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end]
     * @return : byte[]
     * @author : cwl
     * @date : 2019/5/22 13:54
     */
    public static byte[] sub(byte[] array, int start, int end) {
        int length = length(array);
        if (start < 0) {
            start += length;
        }
        if (end < 0) {
            end += length;
        }
        if (start == length) {
            return new byte[0];
        }
        if (start > end) {
            int tmp = start;
            start = end;
            end = tmp;
        }
        if (end > length) {
            if (start >= length) {
                return new byte[0];
            }
            end = length;
        }
        return Arrays.copyOfRange(array, start, end);
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end]
     * @return : int[]
     * @author : cwl
     * @date : 2019/5/22 13:54
     */
    public static int[] sub(int[] array, int start, int end) {
        int length = length(array);
        if (start < 0) {
            start += length;
        }
        if (end < 0) {
            end += length;
        }
        if (start == length) {
            return new int[0];
        }
        if (start > end) {
            int tmp = start;
            start = end;
            end = tmp;
        }
        if (end > length) {
            if (start >= length) {
                return new int[0];
            }
            end = length;
        }
        return Arrays.copyOfRange(array, start, end);
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end]
     * @return : long[]
     * @author : cwl
     * @date : 2019/5/22 13:54
     */
    public static long[] sub(long[] array, int start, int end) {
        int length = length(array);
        if (start < 0) {
            start += length;
        }
        if (end < 0) {
            end += length;
        }
        if (start == length) {
            return new long[0];
        }
        if (start > end) {
            int tmp = start;
            start = end;
            end = tmp;
        }
        if (end > length) {
            if (start >= length) {
                return new long[0];
            }
            end = length;
        }
        return Arrays.copyOfRange(array, start, end);
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end]
     * @return : short[]
     * @author : cwl
     * @date : 2019/5/22 13:55
     */
    public static short[] sub(short[] array, int start, int end) {
        int length = length(array);
        if (start < 0) {
            start += length;
        }
        if (end < 0) {
            end += length;
        }
        if (start == length) {
            return new short[0];
        }
        if (start > end) {
            int tmp = start;
            start = end;
            end = tmp;
        }
        if (end > length) {
            if (start >= length) {
                return new short[0];
            }
            end = length;
        }
        return Arrays.copyOfRange(array, start, end);
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end]
     * @return : char[]
     * @author : cwl
     * @date : 2019/5/22 13:55
     */
    public static char[] sub(char[] array, int start, int end) {
        int length = length(array);
        if (start < 0) {
            start += length;
        }
        if (end < 0) {
            end += length;
        }
        if (start == length) {
            return new char[0];
        }
        if (start > end) {
            int tmp = start;
            start = end;
            end = tmp;
        }
        if (end > length) {
            if (start >= length) {
                return new char[0];
            }
            end = length;
        }
        return Arrays.copyOfRange(array, start, end);
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end]
     * @return : double[]
     * @author : cwl
     * @date : 2019/5/22 13:55
     */
    public static double[] sub(double[] array, int start, int end) {
        int length = length(array);
        if (start < 0) {
            start += length;
        }
        if (end < 0) {
            end += length;
        }
        if (start == length) {
            return new double[0];
        }
        if (start > end) {
            int tmp = start;
            start = end;
            end = tmp;
        }
        if (end > length) {
            if (start >= length) {
                return new double[0];
            }
            end = length;
        }
        return Arrays.copyOfRange(array, start, end);
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end]
     * @return : float[]
     * @author : cwl
     * @date : 2019/5/22 13:55
     */
    public static float[] sub(float[] array, int start, int end) {
        int length = length(array);
        if (start < 0) {
            start += length;
        }
        if (end < 0) {
            end += length;
        }
        if (start == length) {
            return new float[0];
        }
        if (start > end) {
            int tmp = start;
            start = end;
            end = tmp;
        }
        if (end > length) {
            if (start >= length) {
                return new float[0];
            }
            end = length;
        }
        return Arrays.copyOfRange(array, start, end);
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end]
     * @return : boolean[]
     * @author : cwl
     * @date : 2019/5/22 13:55
     */
    public static boolean[] sub(boolean[] array, int start, int end) {
        int length = length(array);
        if (start < 0) {
            start += length;
        }
        if (end < 0) {
            end += length;
        }
        if (start == length) {
            return new boolean[0];
        }
        if (start > end) {
            int tmp = start;
            start = end;
            end = tmp;
        }
        if (end > length) {
            if (start >= length) {
                return new boolean[0];
            }
            end = length;
        }
        return Arrays.copyOfRange(array, start, end);
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end]
     * @return : java.lang.Object[]
     * @author : cwl
     * @date : 2019/5/22 13:55
     */
    public static Object[] sub(Object array, int start, int end) {
        return sub(array, start, end, 1);
    }

    /**
     * 功能描述:
     * 〈获取子数组〉
     *
     * @params : [array, start, end, step]
     * @return : java.lang.Object[]
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static Object[] sub(Object array, int start, int end, int step) {
        int length = length(array);
        if (start < 0) {
            start += length;
        }
        if (end < 0) {
            end += length;
        }
        if (start == length) {
            return new Object[0];
        }
        if (start > end) {
            int tmp = start;
            start = end;
            end = tmp;
        }
        if (end > length) {
            if (start >= length) {
                return new Object[0];
            }
            end = length;
        }

        if (step <= 1) {
            step = 1;
        }

        final ArrayList<Object> list = new ArrayList<>();
        for (int i = start; i < end; i += step) {
            list.add(get(array, i));
        }

        return list.toArray();
    }

    /**
     * 功能描述:
     * 〈数组或集合转String〉
     *
     * @params : [obj]
     * @return : java.lang.String
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static String toString(Object obj) {
        if (null == obj) {
            return null;
        }
        if (ArrayUtil.isArray(obj)) {
            try {
                return Arrays.deepToString((Object[]) obj);
            } catch (Exception e) {
                final String className = obj.getClass().getComponentType().getName();
                switch (className) {
                    case "long":
                        return Arrays.toString((long[]) obj);
                    case "int":
                        return Arrays.toString((int[]) obj);
                    case "short":
                        return Arrays.toString((short[]) obj);
                    case "char":
                        return Arrays.toString((char[]) obj);
                    case "byte":
                        return Arrays.toString((byte[]) obj);
                    case "boolean":
                        return Arrays.toString((boolean[]) obj);
                    case "float":
                        return Arrays.toString((float[]) obj);
                    case "double":
                        return Arrays.toString((double[]) obj);
                    default:
                        throw new UtilException(e);
                }
            }
        }
        return obj.toString();
    }

    /**
     * 功能描述:
     * 〈获取数组长度〉
     *
     * @params : [array]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static int length(Object array) throws IllegalArgumentException {
        if (null == array) {
            return 0;
        }
        return Array.getLength(array);
    }

    /**
     * 功能描述:
     * 〈以 conjunction 为分隔符将数组转换为字符串〉
     *
     * @params : [array, conjunction]
     * @return : java.lang.String
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static String join(long[] array, CharSequence conjunction) {
        if (null == array) {
            return null;
        }

        final StringBuilder sb = new StringBuilder();
        boolean isFirst = true;
        for (long item : array) {
            if (isFirst) {
                isFirst = false;
            } else {
                sb.append(conjunction);
            }
            sb.append(item);
        }
        return sb.toString();
    }

    /**
     * 功能描述:
     * 〈以 conjunction 为分隔符将数组转换为字符串〉
     *
     * @params : [array, conjunction]
     * @return : java.lang.String
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static String join(int[] array, CharSequence conjunction) {
        if (null == array) {
            return null;
        }

        final StringBuilder sb = new StringBuilder();
        boolean isFirst = true;
        for (int item : array) {
            if (isFirst) {
                isFirst = false;
            } else {
                sb.append(conjunction);
            }
            sb.append(item);
        }
        return sb.toString();
    }

    /**
     * 功能描述:
     * 〈以 conjunction 为分隔符将数组转换为字符串〉
     *
     * @params : [array, conjunction]
     * @return : java.lang.String
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static String join(short[] array, CharSequence conjunction) {
        if (null == array) {
            return null;
        }

        final StringBuilder sb = new StringBuilder();
        boolean isFirst = true;
        for (short item : array) {
            if (isFirst) {
                isFirst = false;
            } else {
                sb.append(conjunction);
            }
            sb.append(item);
        }
        return sb.toString();
    }

    /**
     * 功能描述:
     * 〈以 conjunction 为分隔符将数组转换为字符串〉
     *
     * @params : [array, conjunction]
     * @return : java.lang.String
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static String join(char[] array, CharSequence conjunction) {
        if (null == array) {
            return null;
        }

        final StringBuilder sb = new StringBuilder();
        boolean isFirst = true;
        for (char item : array) {
            if (isFirst) {
                isFirst = false;
            } else {
                sb.append(conjunction);
            }
            sb.append(item);
        }
        return sb.toString();
    }

    /**
     * 功能描述:
     * 〈以 conjunction 为分隔符将数组转换为字符串〉
     *
     * @params : [array, conjunction]
     * @return : java.lang.String
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static String join(byte[] array, CharSequence conjunction) {
        if (null == array) {
            return null;
        }

        final StringBuilder sb = new StringBuilder();
        boolean isFirst = true;
        for (byte item : array) {
            if (isFirst) {
                isFirst = false;
            } else {
                sb.append(conjunction);
            }
            sb.append(item);
        }
        return sb.toString();
    }

    /**
     * 功能描述:
     * 〈以 conjunction 为分隔符将数组转换为字符串〉
     *
     * @params : [array, conjunction]
     * @return : java.lang.String
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static String join(boolean[] array, CharSequence conjunction) {
        if (null == array) {
            return null;
        }

        final StringBuilder sb = new StringBuilder();
        boolean isFirst = true;
        for (boolean item : array) {
            if (isFirst) {
                isFirst = false;
            } else {
                sb.append(conjunction);
            }
            sb.append(item);
        }
        return sb.toString();
    }

    /**
     * 功能描述:
     * 〈以 conjunction 为分隔符将数组转换为字符串〉
     *
     * @params : [array, conjunction]
     * @return : java.lang.String
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static String join(float[] array, CharSequence conjunction) {
        if (null == array) {
            return null;
        }

        final StringBuilder sb = new StringBuilder();
        boolean isFirst = true;
        for (float item : array) {
            if (isFirst) {
                isFirst = false;
            } else {
                sb.append(conjunction);
            }
            sb.append(item);
        }
        return sb.toString();
    }

    /**
     * 功能描述:
     * 〈以 conjunction 为分隔符将数组转换为字符串〉
     *
     * @params : [array, conjunction]
     * @return : java.lang.String
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static String join(double[] array, CharSequence conjunction) {
        if (null == array) {
            return null;
        }

        final StringBuilder sb = new StringBuilder();
        boolean isFirst = true;
        for (double item : array) {
            if (isFirst) {
                isFirst = false;
            } else {
                sb.append(conjunction);
            }
            sb.append(item);
        }
        return sb.toString();
    }

    /**
     * 功能描述:
     * 〈以 conjunction 为分隔符将数组转换为字符串〉
     *
     * @params : [array, conjunction]
     * @return : java.lang.String
     * @author : cwl
     * @date : 2019/5/22 13:56
     */
    public static String join(Object array, CharSequence conjunction) {
        if (isArray(array)) {
            final Class<?> componentType = array.getClass().getComponentType();
            if (componentType.isPrimitive()) {
                final String componentTypeName = componentType.getName();
                switch (componentTypeName) {
                    case "long":
                        return join((long[]) array, conjunction);
                    case "int":
                        return join((int[]) array, conjunction);
                    case "short":
                        return join((short[]) array, conjunction);
                    case "char":
                        return join((char[]) array, conjunction);
                    case "byte":
                        return join((byte[]) array, conjunction);
                    case "boolean":
                        return join((boolean[]) array, conjunction);
                    case "float":
                        return join((float[]) array, conjunction);
                    case "double":
                        return join((double[]) array, conjunction);
                    default:
                        throw new UtilException("Unknown primitive type: [{}]", componentTypeName);
                }
            } else {
                return join((Object[]) array, conjunction);
            }
        }
        throw new UtilException("Argument is not a Array!", array.getClass());
    }

    /**
     * 功能描述:
     * 〈ByteBuffer转byte数组〉
     *
     * @params : [bytebuffer]
     * @return : byte[]
     * @author : cwl
     * @date : 2019/5/22 13:58
     */
    public static byte[] toArray(ByteBuffer bytebuffer) {
        if (false == bytebuffer.hasArray()) {
            int oldPosition = bytebuffer.position();
            bytebuffer.position(0);
            int size = bytebuffer.limit();
            byte[] buffers = new byte[size];
            bytebuffer.get(buffers);
            bytebuffer.position(oldPosition);
            return buffers;
        } else {
            return Arrays.copyOfRange(bytebuffer.array(), bytebuffer.position(), bytebuffer.limit());
        }
    }

    /**
     * 功能描述:
     * 〈将集合转为数组〉
     *
     * @params : [collection, componentType]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 13:59
     */
    public static <T> T[] toArray(Collection<T> collection, Class<T> componentType) {
        final T[] array = newArray(componentType, collection.size());
        return collection.toArray(array);
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素〉
     *
     * @params : [array, index]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 17:25
     */
    @SuppressWarnings("unchecked")
    public static <T> T[] remove(T[] array, int index) throws IllegalArgumentException {
        return (T[]) remove((Object) array, index);
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素〉
     *
     * @params : [array, index]
     * @return : long[]
     * @author : cwl
     * @date : 2019/5/22 17:26
     */
    public static long[] remove(long[] array, int index) throws IllegalArgumentException {
        return (long[]) remove((Object) array, index);
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素〉
     *
     * @params : [array, index]
     * @return : int[]
     * @author : cwl
     * @date : 2019/5/22 17:26
     */
    public static int[] remove(int[] array, int index) throws IllegalArgumentException {
        return (int[]) remove((Object) array, index);
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素〉
     *
     * @params : [array, index]
     * @return : short[]
     * @author : cwl
     * @date : 2019/5/22 17:26
     */
    public static short[] remove(short[] array, int index) throws IllegalArgumentException {
        return (short[]) remove((Object) array, index);
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素〉
     *
     * @params : [array, index]
     * @return : char[]
     * @author : cwl
     * @date : 2019/5/22 17:27
     */
    public static char[] remove(char[] array, int index) throws IllegalArgumentException {
        return (char[]) remove((Object) array, index);
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素〉
     *
     * @params : [array, index]
     * @return : byte[]
     * @author : cwl
     * @date : 2019/5/22 17:27
     */
    public static byte[] remove(byte[] array, int index) throws IllegalArgumentException {
        return (byte[]) remove((Object) array, index);
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素〉
     *
     * @params : [array, index]
     * @return : double[]
     * @author : cwl
     * @date : 2019/5/22 17:27
     */
    public static double[] remove(double[] array, int index) throws IllegalArgumentException {
        return (double[]) remove((Object) array, index);
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素〉
     *
     * @params : [array, index]
     * @return : float[]
     * @author : cwl
     * @date : 2019/5/22 17:27
     */
    public static float[] remove(float[] array, int index) throws IllegalArgumentException {
        return (float[]) remove((Object) array, index);
    }

    /**
     * 移除数组中对应位置的元素<br>
     * copy from commons-lang
     *
     * @param array 数组对象,可以是对象数组,也可以原始类型数组
     * @param index 位置,如果位置小于0或者大于长度,返回原数组
     * @return 去掉指定元素后的新数组或原数组
     * @throws IllegalArgumentException 参数对象不为数组对象
     * @since 3.0.8
     */
    public static boolean[] remove(boolean[] array, int index) throws IllegalArgumentException {
        return (boolean[]) remove((Object) array, index);
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素〉
     *
     * @params : [array, index]
     * @return : java.lang.Object
     * @author : cwl
     * @date : 2019/5/22 17:28
     */
    public static Object remove(Object array, int index) throws IllegalArgumentException {
        if (null == array) {
            return array;
        }
        int length = length(array);
        if (index < 0 || index >= length) {
            return array;
        }

        final Object result = Array.newInstance(array.getClass().getComponentType(), length - 1);
        System.arraycopy(array, 0, result, 0, index);
        if (index < length - 1) {
            // 后半部分
            System.arraycopy(array, index + 1, result, index, length - index - 1);
        }

        return result;
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素.只会移除匹配到的第一个元素〉
     *
     * @params : [array, element]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 17:28
     */
    public static <T> T[] removeEle(T[] array, T element) throws IllegalArgumentException {
        return remove(array, indexOf(array, element));
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素.只会移除匹配到的第一个元素〉
     *
     * @params : [array, element]
     * @return : long[]
     * @author : cwl
     * @date : 2019/5/22 17:28
     */
    public static long[] removeEle(long[] array, long element) throws IllegalArgumentException {
        return remove(array, indexOf(array, element));
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素.只会移除匹配到的第一个元素〉
     *
     * @params : [array, element]
     * @return : int[]
     * @author : cwl
     * @date : 2019/5/22 17:48
     */
    public static int[] removeEle(int[] array, int element) throws IllegalArgumentException {
        return remove(array, indexOf(array, element));
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素.只会移除匹配到的第一个元素〉
     *
     * @params : [array, element]
     * @return : short[]
     * @author : cwl
     * @date : 2019/5/22 17:49
     */
    public static short[] removeEle(short[] array, short element) throws IllegalArgumentException {
        return remove(array, indexOf(array, element));
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素.只会移除匹配到的第一个元素〉
     *
     * @params : [array, element]
     * @return : char[]
     * @author : cwl
     * @date : 2019/5/22 17:49
     */
    public static char[] removeEle(char[] array, char element) throws IllegalArgumentException {
        return remove(array, indexOf(array, element));
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素.只会移除匹配到的第一个元素〉
     *
     * @params : [array, element]
     * @return : byte[]
     * @author : cwl
     * @date : 2019/5/22 17:49
     */
    public static byte[] removeEle(byte[] array, byte element) throws IllegalArgumentException {
        return remove(array, indexOf(array, element));
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素.只会移除匹配到的第一个元素〉
     *
     * @params : [array, element]
     * @return : double[]
     * @author : cwl
     * @date : 2019/5/22 17:49
     */
    public static double[] removeEle(double[] array, double element) throws IllegalArgumentException {
        return remove(array, indexOf(array, element));
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素.只会移除匹配到的第一个元素〉
     *
     * @params : [array, element]
     * @return : float[]
     * @author : cwl
     * @date : 2019/5/22 17:49
     */
    public static float[] removeEle(float[] array, float element) throws IllegalArgumentException {
        return remove(array, indexOf(array, element));
    }

    /**
     * 功能描述:
     * 〈移除数组中对应位置的元素.只会移除匹配到的第一个元素〉
     *
     * @params : [array, element]
     * @return : boolean[]
     * @author : cwl
     * @date : 2019/5/22 17:49
     */
    public static boolean[] removeEle(boolean[] array, boolean element) throws IllegalArgumentException {
        return remove(array, indexOf(array, element));
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array, startIndexInclusive, endIndexExclusive]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 17:50
     */
    public static <T> T[] reverse(final T[] array, final int startIndexInclusive, final int endIndexExclusive) {
        if (isEmpty(array)) {
            return array;
        }
        int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
        int j = Math.min(array.length, endIndexExclusive) - 1;
        T tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/22 17:50
     */
    public static <T> T[] reverse(final T[] array) {
        return reverse(array, 0, array.length);
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array, startIndexInclusive, endIndexExclusive]
     * @return : long[]
     * @author : cwl
     * @date : 2019/5/22 17:51
     */
    public static long[] reverse(final long[] array, final int startIndexInclusive, final int endIndexExclusive) {
        if (isEmpty(array)) {
            return array;
        }
        int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
        int j = Math.min(array.length, endIndexExclusive) - 1;
        long tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array]
     * @return : long[]
     * @author : cwl
     * @date : 2019/5/22 17:51
     */
    public static long[] reverse(final long[] array) {
        return reverse(array, 0, array.length);
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array, startIndexInclusive, endIndexExclusive]
     * @return : int[]
     * @author : cwl
     * @date : 2019/5/22 17:51
     */
    public static int[] reverse(final int[] array, final int startIndexInclusive, final int endIndexExclusive) {
        if (isEmpty(array)) {
            return array;
        }
        int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
        int j = Math.min(array.length, endIndexExclusive) - 1;
        int tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array]
     * @return : int[]
     * @author : cwl
     * @date : 2019/5/22 17:51
     */
    public static int[] reverse(final int[] array) {
        return reverse(array, 0, array.length);
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array, startIndexInclusive, endIndexExclusive]
     * @return : short[]
     * @author : cwl
     * @date : 2019/5/22 17:51
     */
    public static short[] reverse(final short[] array, final int startIndexInclusive, final int endIndexExclusive) {
        if (isEmpty(array)) {
            return array;
        }
        int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
        int j = Math.min(array.length, endIndexExclusive) - 1;
        short tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array]
     * @return : short[]
     * @author : cwl
     * @date : 2019/5/22 17:51
     */
    public static short[] reverse(final short[] array) {
        return reverse(array, 0, array.length);
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array, startIndexInclusive, endIndexExclusive]
     * @return : char[]
     * @author : cwl
     * @date : 2019/5/22 17:51
     */
    public static char[] reverse(final char[] array, final int startIndexInclusive, final int endIndexExclusive) {
        if (isEmpty(array)) {
            return array;
        }
        int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
        int j = Math.min(array.length, endIndexExclusive) - 1;
        char tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array]
     * @return : char[]
     * @author : cwl
     * @date : 2019/5/22 17:52
     */
    public static char[] reverse(final char[] array) {
        return reverse(array, 0, array.length);
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array, startIndexInclusive, endIndexExclusive]
     * @return : byte[]
     * @author : cwl
     * @date : 2019/5/22 17:52
     */
    public static byte[] reverse(final byte[] array, final int startIndexInclusive, final int endIndexExclusive) {
        if (isEmpty(array)) {
            return array;
        }
        int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
        int j = Math.min(array.length, endIndexExclusive) - 1;
        byte tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array]
     * @return : byte[]
     * @author : cwl
     * @date : 2019/5/22 17:52
     */
    public static byte[] reverse(final byte[] array) {
        return reverse(array, 0, array.length);
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array, startIndexInclusive, endIndexExclusive]
     * @return : double[]
     * @author : cwl
     * @date : 2019/5/22 17:52
     */
    public static double[] reverse(final double[] array, final int startIndexInclusive, final int endIndexExclusive) {
        if (isEmpty(array)) {
            return array;
        }
        int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
        int j = Math.min(array.length, endIndexExclusive) - 1;
        double tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array]
     * @return : double[]
     * @author : cwl
     * @date : 2019/5/22 17:52
     */
    public static double[] reverse(final double[] array) {
        return reverse(array, 0, array.length);
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array, startIndexInclusive, endIndexExclusive]
     * @return : float[]
     * @author : cwl
     * @date : 2019/5/22 17:52
     */
    public static float[] reverse(final float[] array, final int startIndexInclusive, final int endIndexExclusive) {
        if (isEmpty(array)) {
            return array;
        }
        int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
        int j = Math.min(array.length, endIndexExclusive) - 1;
        float tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array]
     * @return : float[]
     * @author : cwl
     * @date : 2019/5/22 17:53
     */
    public static float[] reverse(final float[] array) {
        return reverse(array, 0, array.length);
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array, startIndexInclusive, endIndexExclusive]
     * @return : boolean[]
     * @author : cwl
     * @date : 2019/5/22 17:53
     */
    public static boolean[] reverse(final boolean[] array, final int startIndexInclusive, final int endIndexExclusive) {
        if (isEmpty(array)) {
            return array;
        }
        int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
        int j = Math.min(array.length, endIndexExclusive) - 1;
        boolean tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }
        return array;
    }

    /**
     * 功能描述:
     * 〈反转数组,会变更原数组〉
     *
     * @params : [array]
     * @return : boolean[]
     * @author : cwl
     * @date : 2019/5/22 17:53
     */
    public static boolean[] reverse(final boolean[] array) {
        return reverse(array, 0, array.length);
    }

    /**
     * 功能描述:
     * 〈取最小值〉
     *
     * @params : [numberArray]
     * @return : T
     * @author : cwl
     * @date : 2019/5/22 17:55
     */
    public static <T extends Comparable<? super T>> T min(T[] numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        T min = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (min.compareTo(numberArray[i]) > 0) {
                min = numberArray[i];
            }
        }
        return min;
    }

    /**
     * 功能描述:
     * 〈取最小值〉
     *
     * @params : [numberArray]
     * @return : long
     * @author : cwl
     * @date : 2019/5/22 17:55
     */
    public static long min(long... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        long min = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (min > numberArray[i]) {
                min = numberArray[i];
            }
        }
        return min;
    }

    /**
     * 功能描述:
     * 〈取最小值〉
     *
     * @params : [numberArray]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 17:55
     */
    public static int min(int... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        int min = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (min > numberArray[i]) {
                min = numberArray[i];
            }
        }
        return min;
    }

    /**
     * 功能描述:
     * 〈取最小值〉
     *
     * @params : [numberArray]
     * @return : short
     * @author : cwl
     * @date : 2019/5/22 17:56
     */
    public static short min(short... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        short min = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (min > numberArray[i]) {
                min = numberArray[i];
            }
        }
        return min;
    }

    /**
     * 功能描述:
     * 〈取最小值〉
     *
     * @params : [numberArray]
     * @return : char
     * @author : cwl
     * @date : 2019/5/22 17:57
     */
    public static char min(char... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        char min = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (min > numberArray[i]) {
                min = numberArray[i];
            }
        }
        return min;
    }

    /**
     * 功能描述:
     * 〈取最小值〉
     *
     * @params : [numberArray]
     * @return : byte
     * @author : cwl
     * @date : 2019/5/22 17:58
     */
    public static byte min(byte... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        byte min = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (min > numberArray[i]) {
                min = numberArray[i];
            }
        }
        return min;
    }

    /**
     * 功能描述:
     * 〈取最小值〉
     *
     * @params : [numberArray]
     * @return : double
     * @author : cwl
     * @date : 2019/5/22 17:58
     */
    public static double min(double... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        double min = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (min > numberArray[i]) {
                min = numberArray[i];
            }
        }
        return min;
    }

    /**
     * 功能描述:
     * 〈取最小值〉
     *
     * @params : [numberArray]
     * @return : float
     * @author : cwl
     * @date : 2019/5/22 17:58
     */
    public static float min(float... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        float min = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (min > numberArray[i]) {
                min = numberArray[i];
            }
        }
        return min;
    }

    /**
     * 功能描述:
     * 〈取最大值〉
     *
     * @params : [numberArray]
     * @return : T
     * @author : cwl
     * @date : 2019/5/22 17:58
     */
    public static <T extends Comparable<? super T>> T max(T[] numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        T max = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (max.compareTo(numberArray[i])< 0) {
                max = numberArray[i];
            }
        }
        return max;
    }

    /**
     * 功能描述:
     * 〈取最大值〉
     *
     * @params : [numberArray]
     * @return : long
     * @author : cwl
     * @date : 2019/5/22 17:58
     */
    public static long max(long... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        long max = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (max < numberArray[i]) {
                max = numberArray[i];
            }
        }
        return max;
    }

    /**
     * 功能描述:
     * 〈取最大值〉
     *
     * @params : [numberArray]
     * @return : int
     * @author : cwl
     * @date : 2019/5/22 17:59
     */
    public static int max(int... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        int max = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (max < numberArray[i]) {
                max = numberArray[i];
            }
        }
        return max;
    }

    /**
     * 功能描述:
     * 〈取最大值〉
     *
     * @params : [numberArray]
     * @return : short
     * @author : cwl
     * @date : 2019/5/22 17:59
     */
    public static short max(short... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        short max = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (max < numberArray[i]) {
                max = numberArray[i];
            }
        }
        return max;
    }

    /**
     * 功能描述:
     * 〈取最大值〉
     *
     * @params : [numberArray]
     * @return : char
     * @author : cwl
     * @date : 2019/5/22 17:59
     */
    public static char max(char... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        char max = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (max < numberArray[i]) {
                max = numberArray[i];
            }
        }
        return max;
    }

    /**
     * 功能描述:
     * 〈取最大值〉
     *
     * @params : [numberArray]
     * @return : byte
     * @author : cwl
     * @date : 2019/5/22 17:59
     */
    public static byte max(byte... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        byte max = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (max < numberArray[i]) {
                max = numberArray[i];
            }
        }
        return max;
    }

    /**
     * 功能描述:
     * 〈取最大值〉
     *
     * @params : [numberArray]
     * @return : double
     * @author : cwl
     * @date : 2019/5/23 15:12
     */
    public static double max(double... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        double max = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (max < numberArray[i]) {
                max = numberArray[i];
            }
        }
        return max;
    }

    /**
     * 功能描述:
     * 〈取最大值〉
     *
     * @params : [numberArray]
     * @return : float
     * @author : cwl
     * @date : 2019/5/23 15:12
     */
    public static float max(float... numberArray) {
        if (isEmpty(numberArray)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        float max = numberArray[0];
        for (int i = 0; i < numberArray.length; i++) {
            if (max < numberArray[i]) {
                max = numberArray[i];
            }
        }
        return max;
    }

    /**
     * 功能描述:
     * 〈交换数组中两个位置的值〉
     *
     * @params : [array, index1, index2]
     * @return : int[]
     * @author : cwl
     * @date : 2019/5/23 15:13
     */
    public static int[] swap(int[] array, int index1, int index2) {
        if (isEmpty(array)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        int tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
        return array;
    }

    /**
     * 功能描述:
     * 〈交换数组中两个位置的值〉
     *
     * @params : [array, index1, index2]
     * @return : long[]
     * @author : cwl
     * @date : 2019/5/23 15:14
     */
    public static long[] swap(long[] array, int index1, int index2) {
        if (isEmpty(array)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        long tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
        return array;
    }

    /**
     * 功能描述:
     * 〈交换数组中两个位置的值〉
     *
     * @params : [array, index1, index2]
     * @return : double[]
     * @author : cwl
     * @date : 2019/5/23 15:14
     */
    public static double[] swap(double[] array, int index1, int index2) {
        if (isEmpty(array)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        double tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
        return array;
    }

    /**
     * 功能描述:
     * 〈交换数组中两个位置的值〉
     *
     * @params : [array, index1, index2]
     * @return : float[]
     * @author : cwl
     * @date : 2019/5/23 15:14
     */
    public static float[] swap(float[] array, int index1, int index2) {
        if (isEmpty(array)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        float tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
        return array;
    }

    /**
     * 功能描述:
     * 〈交换数组中两个位置的值〉
     *
     * @params : [array, index1, index2]
     * @return : boolean[]
     * @author : cwl
     * @date : 2019/5/23 15:15
     */
    public static boolean[] swap(boolean[] array, int index1, int index2) {
        if (isEmpty(array)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        boolean tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
        return array;
    }

    /**
     * 功能描述:
     * 〈交换数组中两个位置的值〉
     *
     * @params : [array, index1, index2]
     * @return : byte[]
     * @author : cwl
     * @date : 2019/5/23 15:15
     */
    public static byte[] swap(byte[] array, int index1, int index2) {
        if (isEmpty(array)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        byte tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
        return array;
    }

    /**
     * 功能描述:
     * 〈交换数组中两个位置的值〉
     *
     * @params : [array, index1, index2]
     * @return : char[]
     * @author : cwl
     * @date : 2019/5/23 15:15
     */
    public static char[] swap(char[] array, int index1, int index2) {
        if (isEmpty(array)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        char tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
        return array;
    }

    /**
     * 功能描述:
     * 〈交换数组中两个位置的值〉
     *
     * @params : [array, index1, index2]
     * @return : short[]
     * @author : cwl
     * @date : 2019/5/23 15:15
     */
    public static short[] swap(short[] array, int index1, int index2) {
        if (isEmpty(array)) {
            throw new IllegalArgumentException("Number array must not empty !");
        }
        short tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
        return array;
    }

    /**
     * 功能描述:
     * 〈交换数组中两个位置的值〉
     *
     * @params : [array, index1, index2]
     * @return : T[]
     * @author : cwl
     * @date : 2019/5/23 15:15
     */
    public static <T> T[] swap(T[] array, int index1, int index2) {
        if (isEmpty(array)) {
            throw new IllegalArgumentException("Array must not empty !");
        }
        T tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
        return array;
    }

    /**
     * 功能描述:
     * 〈交换数组中两个位置的值〉
     *
     * @params : [array, index1, index2]
     * @return : java.lang.Object
     * @author : cwl
     * @date : 2019/5/23 15:16
     */
    public static Object swap(Object array, int index1, int index2) {
        if (isEmpty(array)) {
            throw new IllegalArgumentException("Array must not empty !");
        }
        Object tmp = get(array, index1);
        Array.set(array, index1, Array.get(array, index2));
        Array.set(array, index2, tmp);
        return array;
    }
}
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2019/10/18 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 简单工具类
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档