Package org.aoju.bus.core.toolkit

Class ArrayKit

java.lang.Object
org.aoju.bus.core.toolkit.ArrayKit
public class ArrayKit extends Object
数组工具类
Since:
Java 17+
Author:
Kimi Liu

  • Constructor Summary

    Constructors
    Constructor
    Description
    ArrayKit()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static boolean[]
    add(boolean[] array, boolean element)
    复制给定数组并在新数组的末尾添加给定元素.
    static boolean[]
    add(boolean[] array, int index, boolean element)
    复制给定数组并在新数组的末尾添加给定元素.
    static byte[]
    add(byte[] array, byte element)
    复制给定数组并在新数组的末尾添加给定元素.
    static byte[]
    add(byte[] array, int index, byte element)
    复制给定数组并在新数组的末尾添加给定元素.
    static char[]
    add(char[] array, char element)
    复制给定数组并在新数组的末尾添加给定元素.
    static char[]
    add(char[] array, int index, char element)
    复制给定数组并在新数组的末尾添加给定元素.
    static double[]
    add(double[] array, double element)
    复制给定数组并在新数组的末尾添加给定元素.
    static double[]
    add(double[] array, int index, double element)
    复制给定数组并在新数组的末尾添加给定元素.
    static float[]
    add(float[] array, float element)
    复制给定数组并在新数组的末尾添加给定元素.
    static float[]
    add(float[] array, int index, float element)
    复制给定数组并在新数组的末尾添加给定元素.
    static int[]
    add(int[] array, int element)
    复制给定数组并在新数组的末尾添加给定元素.
    static int[]
    add(int[] array, int index, int element)
    复制给定数组并在新数组的末尾添加给定元素.
    static long[]
    add(long[] array, int index, long element)
    复制给定数组并在新数组的末尾添加给定元素.
    static long[]
    add(long[] array, long element)
    复制给定数组并在新数组的末尾添加给定元素.
    static short[]
    add(short[] array, int index, short element)
    复制给定数组并在新数组的末尾添加给定元素.
    static short[]
    add(short[] array, short element)
    复制给定数组并在新数组的末尾添加给定元素.
    static <T> T[]
    add(T[] array, int index, T element)
    复制给定数组并在新数组的末尾添加给定元素.
    static <T> T[]
    add(T[] array, T element)
    复制给定数组并在新数组的末尾添加给定元素.
    static boolean[]
    addAll(boolean[]... arrays)
    将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素
    static byte[]
    addAll(byte[]... arrays)
    将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素
    static char[]
    addAll(char[]... arrays)
    将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素
    static double[]
    addAll(double[]... arrays)
    将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素
    static float[]
    addAll(float[]... arrays)
    将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素
    static int[]
    addAll(int[]... arrays)
    将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素
    static long[]
    addAll(long[]... arrays)
    将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素
    static short[]
    addAll(short[]... arrays)
    将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素
    static <T> T[]
    addAll(T[]... arrays)
    将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素
    static <T> Object
    append(Object array, T... newElements)
    将新元素添加到已有数组中 添加新元素会生成一个新的数组，不影响原数组
    static <T> T[]
    append(T[] buffer, T... newElements)
    将新元素添加到已有数组中 添加新元素会生成一个新的数组，不影响原数组
    static Object[]
    cast(Class<?> type, Object arrayObj)
    强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组
    static boolean[]
    clone(boolean[] array)
    克隆数组
    static byte[]
    clone(byte[] array)
    克隆数组
    static char[]
    clone(char[] array)
    克隆数组
    static double[]
    clone(double[] array)
    克隆数组
    static float[]
    clone(float[] array)
    克隆数组
    static int[]
    clone(int[] array)
    克隆数组
    static long[]
    clone(long[] array)
    克隆数组
    static short[]
    clone(short[] array)
    克隆数组
    static <T> T
    clone(T object)
    克隆数组,如果非数组返回null
    static <T> T[]
    clone(T[] array)
    克隆数组
    static boolean
    contains(boolean[] array, boolean value)
    数组中是否包含元素
    static boolean
    contains(byte[] array, byte value)
    数组中是否包含元素
    static boolean
    contains(char[] array, char value)
    数组中是否包含元素
    static boolean
    contains(double[] array, double value)
    数组中是否包含元素
    static boolean
    contains(double[] array, double value, double tolerance)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static boolean
    contains(float[] array, float value)
    数组中是否包含元素
    static boolean
    contains(int[] array, int value)
    数组中是否包含元素
    static boolean
    contains(long[] array, long value)
    数组中是否包含元素
    static boolean
    contains(short[] array, short value)
    数组中是否包含元素
    static boolean
    contains(Object[] array, Object value)
    数组中是否包含元素
    static <T> boolean
    containsAll(T[] array, T... values)
    数组中是否包含指定元素中的全部
    static <T> boolean
    containsAny(T[] array, T... values)
    数组中是否包含指定元素中的任意一个
    static boolean
    containsIgnoreCase(CharSequence[] array, CharSequence value)
    数组中是否包含元素,忽略大小写
    static Object
    copy(Object src, int srcPos, Object dest, int destPos, int length)
    包装 System.arraycopy(Object, int, Object, int, int) 数组复制
    static Object
    copy(Object src, Object dest, int length)
    包装 System.arraycopy(Object, int, Object, int, int) 数组复制,缘数组和目标数组都是从位置0开始复制
    static boolean
    equals(Object array1, Object array2)
    判断两个数组是否相等，判断依据包括数组长度和每个元素都相等
    static <T> T[]
    filter(T[] array, Editor<T> editor)
    过滤 过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能：
    static <T> T[]
    filter(T[] array, Filter<T> filter)
    过滤 过滤过程通过传入的Filter实现来过滤返回需要的元素内容,这个Editor实现可以实现以下功能：
    static <T> int
    firstNonAll(Matcher<T> matcher, int beginIndexInclude, T... array)
    返回数组中第一个匹配规则的值的位置
    static <T> int
    firstNonAll(Matcher<T> matcher, T... array)
    返回数组中第一个匹配规则的值的位置
    static <T> T
    firstNonNull(Matcher<T> matcher, T... array)
    返回数组中第一个匹配规则的值
    static <T> T
    firstNonNull(T... array)
    返回数组中第一个非空元素
    static Optional<Object>
    firstNotNull(Object[] objects)
    找到第一个不为 null 的元素
    static <T> T
    get(Object array, int index)
    获取数组对象中指定index的值,支持负数,例如-1表示倒数第一个值
    static <T> T[]
    get(Object array, int... indexes)
    获取数组中指定多个下标元素值,组成新数组
    static Class<?>
    getArrayType(Class<?> componentType)
    根据数组元素类型,获取数组的类型 方法是通过创建一个空数组从而获取其类型
    static Class<?>
    getComponentType(Class<?> arrayClass)
    获取数组对象的元素类型
    static Class<?>
    getComponentType(Object array)
    获取数组对象的元素类型
    static int
    getLength(Object array)
    返回指定数组的长度
    static boolean
    hasEmpty(Object... args)
    是否存在null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
    static int
    hashCode(Object array)
    获得一个数组哈希码,用于正确处理多维数组 多维基元数组也可以用该方法正确处理
    static <T> boolean
    hasNull(T... array)
    是否包含null元素
    static int
    indexOf(boolean[] array, boolean value)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(boolean[] array, boolean value, int index)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(byte[] array, byte value)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(byte[] array, byte value, int index)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(char[] array, char value)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(char[] array, char value, int index)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(double[] array, double value)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(double[] array, double value, double tolerance)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(double[] array, double value, int index)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(double[] array, double value, int index, double tolerance)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(float[] array, float value)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(float[] array, float value, int index)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(int[] array, int value)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(int[] array, int value, int index)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(long[] array, long value)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(long[] array, long value, int index)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(short[] array, short value)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(short[] array, short value, int index)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(Object[] array, Object value)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOf(Object[] array, Object value, int index)
    返回数组中指定元素所在位置,未找到返回Normal.__1
    static int
    indexOfIgnoreCase(CharSequence[] array, CharSequence value)
    返回数组中指定元素所在位置,忽略大小写,未找到返回Normal.__1
    static <T> int
    indexOfSub(T[] array, T[] subArray)
    查找子数组的位置
    static boolean[]
    insert(int index, boolean[] array, boolean... values)
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
    static byte[]
    insert(int index, byte[] array, byte... values)
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
    static char[]
    insert(int index, char[] array, char... values)
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
    static double[]
    insert(int index, double[] array, double... values)
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
    static float[]
    insert(int index, float[] array, float... values)
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
    static int[]
    insert(int index, int[] array, int... values)
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
    static long[]
    insert(int index, long[] array, long... values)
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
    static short[]
    insert(int index, short[] array, short... values)
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
    static <T> T[]
    insert(int index, T[] array, T... values)
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
    static <T> Object
    insert(Object array, int index, T... newElements)
    将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
    static <T> T[]
    insert(T[] buffer, int index, T... newElements)
    将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
    static boolean
    isAllEmpty(Object... args)
    是否存都为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
    static boolean
    isAllNotEmpty(Object... args)
    是否存都不为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
    static <T> boolean
    isAllNotNull(T... array)
    多个字段是否全部不为null
    static <T> boolean
    isAllNull(T... array)
    多个字段是否全为null
    static boolean
    isArray(Object object)
    对象是否为数组对象
    static <T> boolean
    isArrayIndexValid(T[] array, int index)
    返回是否可以在给定索引处安全地访问给定数组
    static boolean
    isEmpty(boolean[] array)
    数组是否为空
    static boolean
    isEmpty(byte[] array)
    数组是否为空
    static boolean
    isEmpty(char[] array)
    数组是否为空
    static boolean
    isEmpty(double[] array)
    数组是否为空
    static boolean
    isEmpty(float[] array)
    数组是否为空
    static boolean
    isEmpty(int[] array)
    数组是否为空
    static boolean
    isEmpty(long[] array)
    数组是否为空
    static boolean
    isEmpty(short[] array)
    数组是否为空
    static boolean
    isEmpty(Object array)
    数组是否为空 此方法会匹配单一对象,如果此对象为null则返回true 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回false 如果此对象为数组对象,数组长度大于0情况下返回false,否则返回true
    static <T> boolean
    isEmpty(T[] array)
    数组是否为空
    static boolean
    isNotEmpty(boolean[] array)
    数组是否为非空
    static boolean
    isNotEmpty(byte[] array)
    数组是否为非空
    static boolean
    isNotEmpty(char[] array)
    数组是否为非空
    static boolean
    isNotEmpty(double[] array)
    数组是否为非空
    static boolean
    isNotEmpty(float[] array)
    数组是否为非空
    static boolean
    isNotEmpty(int[] array)
    数组是否为非空
    static boolean
    isNotEmpty(long[] array)
    数组是否为非空
    static boolean
    isNotEmpty(short[] array)
    数组是否为非空
    static <T> boolean
    isNotEmpty(T[] array)
    数组是否为非空 此方法会匹配单一对象,如果此对象为null则返回false 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回true 如果此对象为数组对象,数组长度大于0情况下返回true,否则返回false
    static boolean
    isSameLength(boolean[] array1, boolean[] array2)
    检查两个数组是否相同长度
    static boolean
    isSameLength(byte[] array1, byte[] array2)
    检查两个数组是否相同长度
    static boolean
    isSameLength(char[] array1, char[] array2)
    检查两个数组是否相同长度
    static boolean
    isSameLength(double[] array1, double[] array2)
    检查两个数组是否相同长度
    static boolean
    isSameLength(float[] array1, float[] array2)
    检查两个数组是否相同长度
    static boolean
    isSameLength(int[] array1, int[] array2)
    检查两个数组是否相同长度
    static boolean
    isSameLength(long[] array1, long[] array2)
    检查两个数组是否相同长度
    static boolean
    isSameLength(short[] array1, short[] array2)
    检查两个数组是否相同长度
    static boolean
    isSameLength(Object[] array1, Object[] array2)
    检查两个数组是否相同长度
    static boolean
    isSameType(Object array1, Object array2)
    检查两个数组是否为同一类型
    static boolean
    isSorted(boolean[] array)
    该方法检查提供的数组是否按照提供的Comparator排序.
    static boolean
    isSorted(byte[] array)
    该方法检查提供的数组是否按照提供的Comparator排序.
    static boolean
    isSorted(char[] array)
    该方法检查提供的数组是否按照提供的Comparator排序.
    static boolean
    isSorted(double[] array)
    该方法检查提供的数组是否按照提供的Comparator排序.
    static boolean
    isSorted(float[] array)
    该方法检查提供的数组是否按照提供的Comparator排序.
    static boolean
    isSorted(int[] array)
    该方法检查提供的数组是否按照提供的Comparator排序.
    static boolean
    isSorted(long[] array)
    该方法检查提供的数组是否按照提供的Comparator排序.
    static boolean
    isSorted(short[] array)
    该方法检查提供的数组是否按照提供的Comparator排序.
    static <T extends Comparable<? super T>>
    boolean
    isSorted(T[] array)
    该方法检查提供的数组是否按照类的compareTo方法排序.
    static <T> boolean
    isSorted(T[] array, Comparator<T> comparator)
    该方法检查提供的数组是否按照提供的Comparator排序.
    static <T> boolean
    isSub(T[] array, T[] subArray)
    查找子数组的位置
    static String
    join(CharSequence conjunction, Object... args)
    以 conjunction 为分隔符将多个对象转换为字符串
    static <T> String
    join(T[] array, CharSequence conjunction)
    以 conjunction 为分隔符将数组转换为字符串
    static <T> String
    join(T[] array, CharSequence delimiter, String prefix, String suffix)
    以 conjunction 为分隔符将数组转换为字符串
    static <T> String
    join(T[] array, CharSequence conjunction, Editor<T> editor)
    以 conjunction 为分隔符将数组转换为字符串
    static int
    lastIndexOf(boolean[] array, boolean value)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(boolean[] array, boolean value, int index)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(byte[] array, byte value)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(byte[] array, byte value, int index)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(char[] array, char value)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(char[] array, char value, int index)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(double[] array, double value)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(double[] array, double value, double tolerance)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(double[] array, double value, int index)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(double[] array, double value, int index, double tolerance)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(float[] array, float value)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(float[] array, float value, int index)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(int[] array, int value)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(int[] array, int value, int index)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(long[] array, long value)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(long[] array, long value, int index)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(short[] array, short value)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(short[] array, short value, int index)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(Object[] array, Object value)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static int
    lastIndexOf(Object[] array, Object value, int index)
    返回数组中指定元素所在最后的位置,未找到返回Normal.__1
    static <T> int
    lastIndexOfSub(T[] array, T[] subArray)
    查找最后一个子数组的开始位置
    static int
    length(Object array)
    获取数组长度 如果参数为null，返回0
    static <T, R> R[]
    map(Object array, Class<R> targetComponentType, Function<? super T,? extends R> func)
    按照指定规则，将一种类型的数组转换为另一种类型
    static <T, R> R[]
    map(T[] array, Class<R> componentType, Function<? super T,? extends R> func)
    按照指定规则，将一种类型的数组转换为另一种类型
    static <T, R> List<R>
    map(T[] array, Function<? super T,? extends R> func)
    按照指定规则，将一种类型的数组元素提取后转换为List
    static <T, R> Set<R>
    mapToSet(T[] array, Function<? super T,? extends R> func)
    按照指定规则，将一种类型的数组元素提取后转换为Set
    static byte
    max(byte... numberArray)
    取最大值
    static char
    max(char... numberArray)
    取最大值
    static double
    max(double... numberArray)
    取最大值
    static float
    max(float... numberArray)
    取最大值
    static int
    max(int... numberArray)
    取最大值
    static long
    max(long... numberArray)
    取最大值
    static short
    max(short... numberArray)
    取最大值
    static <T extends Comparable<? super T>>
    T
    max(T[] numberArray)
    取最大值
    static <T extends Comparable<? super T>>
    T
    max(T[] numberArray, Comparator<T> comparator)
    取最大值
    static byte
    min(byte... numberArray)
    取最小值
    static char
    min(char... numberArray)
    取最小值
    static double
    min(double... numberArray)
    取最小值
    static float
    min(float... numberArray)
    取最小值
    static int
    min(int... numberArray)
    取最小值
    static long
    min(long... numberArray)
    取最小值
    static short
    min(short... numberArray)
    取最小值
    static <T extends Comparable<? super T>>
    T
    min(T[] numberArray)
    取最小值
    static <T> T[]
    newArray(int newSize)
    新建一个空数组
    static <T> T[]
    newArray(Class<?> componentType, int newSize)
    新建一个空数组
    static Object[]
    newArray(Class<?> type, Object arrayObj)
    强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组
    static boolean[]
    nullToEmpty(boolean[] array)
    输入数组返回一个空数组或原始数组
    static byte[]
    nullToEmpty(byte[] array)
    输入数组返回一个空数组或原始数组
    static char[]
    nullToEmpty(char[] array)
    输入数组返回一个空数组或原始数组
    static double[]
    nullToEmpty(double[] array)
    输入数组返回一个空数组或原始数组
    static float[]
    nullToEmpty(float[] array)
    输入数组返回一个空数组或原始数组
    static int[]
    nullToEmpty(int[] array)
    输入数组返回一个空数组或原始数组
    static long[]
    nullToEmpty(long[] array)
    输入数组返回一个空数组或原始数组
    static short[]
    nullToEmpty(short[] array)
    输入数组返回一个空数组或原始数组
    static Boolean[]
    nullToEmpty(Boolean[] array)
    输入数组返回一个空数组或原始数组
    static Byte[]
    nullToEmpty(Byte[] array)
    输入数组返回一个空数组或原始数组
    static Character[]
    nullToEmpty(Character[] array)
    输入数组返回一个空数组或原始数组
    static Class<?>[]
    nullToEmpty(Class<?>[] array)
    输入数组返回一个空数组或原始数组
    static Double[]
    nullToEmpty(Double[] array)
    输入数组返回一个空数组或原始数组
    static Float[]
    nullToEmpty(Float[] array)
    输入数组返回一个空数组或原始数组
    static Integer[]
    nullToEmpty(Integer[] array)
    输入数组返回一个空数组或原始数组
    static Long[]
    nullToEmpty(Long[] array)
    输入数组返回一个空数组或原始数组
    static Object[]
    nullToEmpty(Object[] array)
    输入数组返回一个空数组或原始数组
    static Short[]
    nullToEmpty(Short[] array)
    输入数组返回一个空数组或原始数组
    static String[]
    nullToEmpty(String[] array)
    输入数组返回一个空数组或原始数组
    static <T> T[]
    nullToEmpty(T[] array, Class<T[]> type)
    输入数组返回一个空数组或原始数组
    static int[]
    range(int excludedEnd)
    生成一个从0开始的数字列表
    static int[]
    range(int includedStart, int excludedEnd)
    生成一个数字列表 自动判定正序反序
    static int[]
    range(int includedStart, int excludedEnd, int step)
    生成一个数字列表 自动判定正序反序
    static boolean[]
    remove(boolean[] array, int index)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static byte[]
    remove(byte[] array, int index)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static char[]
    remove(char[] array, int index)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static double[]
    remove(double[] array, int index)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static float[]
    remove(float[] array, int index)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static int[]
    remove(int[] array, int index)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static long[]
    remove(long[] array, int index)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static short[]
    remove(short[] array, int index)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static <T> T[]
    remove(T[] array)
    去重数组中的元素，去重后生成新的数组，原数组不变 此方法通过LinkedHashSet 去重
    static <T> T[]
    remove(T[] array, int index)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static <T, K> T[]
    remove(T[] array, Function<T,K> uniqueGenerator, boolean override)
    去重数组中的元素，去重后生成新的数组，原数组不变 此方法通过LinkedHashSet 去重
    static boolean[]
    removeAll(boolean[] array, int... indices)
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素
    static byte[]
    removeAll(byte[] array, int... indices)
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素
    static char[]
    removeAll(char[] array, int... indices)
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素
    static double[]
    removeAll(double[] array, int... indices)
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素
    static float[]
    removeAll(float[] array, int... indices)
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素
    static int[]
    removeAll(int[] array, int... indices)
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素
    static long[]
    removeAll(long[] array, int... indices)
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素
    static short[]
    removeAll(short[] array, int... indices)
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素
    static <T> T[]
    removeAll(T[] array, int... indices)
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素
    static boolean[]
    removeAllOccurences(boolean[] array, boolean element)
    从指定的布尔数组中移除指定元素.
    static byte[]
    removeAllOccurences(byte[] array, byte element)
    从指定的布尔数组中移除指定元素.
    static char[]
    removeAllOccurences(char[] array, char element)
    从指定的布尔数组中移除指定元素.
    static double[]
    removeAllOccurences(double[] array, double element)
    从指定的布尔数组中移除指定元素.
    static float[]
    removeAllOccurences(float[] array, float element)
    从指定的布尔数组中移除指定元素.
    static int[]
    removeAllOccurences(int[] array, int element)
    从指定的布尔数组中移除指定元素.
    static long[]
    removeAllOccurences(long[] array, long element)
    从指定的布尔数组中移除指定元素.
    static short[]
    removeAllOccurences(short[] array, short element)
    从指定的布尔数组中移除指定元素.
    static <T> T[]
    removeAllOccurences(T[] array, T element)
    从指定的布尔数组中移除指定元素.
    static <T extends CharSequence>
    T[]
    removeBlank(T[] array)
    去除null或者""或者空白字符串 元素
    static boolean[]
    removeElement(boolean[] array, boolean element)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static byte[]
    removeElement(byte[] array, byte element)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static char[]
    removeElement(char[] array, char element)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static double[]
    removeElement(double[] array, double element)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static float[]
    removeElement(float[] array, float element)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static int[]
    removeElement(int[] array, int element)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static long[]
    removeElement(long[] array, long element)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static short[]
    removeElement(short[] array, short element)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static <T> T[]
    removeElement(T[] array, Object element)
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
    static boolean[]
    removeElements(boolean[] array, boolean... values)
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改.
    static byte[]
    removeElements(byte[] array, byte... values)
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同.
    static char[]
    removeElements(char[] array, char... values)
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改.
    static double[]
    removeElements(double[] array, double... values)
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改.
    static float[]
    removeElements(float[] array, float... values)
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同
    static int[]
    removeElements(int[] array, int... values)
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移.
    static long[]
    removeElements(long[] array, long... values)
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同
    static short[]
    removeElements(short[] array, short... values)
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改.
    static <T> T[]
    removeElements(T[] array, T... values)
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同.
    static <T extends CharSequence>
    T[]
    removeEmpty(T[] array)
    去除null或者"" 元素
    static <T> T[]
    replace(T[] buffer, int index, T... values)
    将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新数组或原有数组 如果插入位置为为负数，那么生成一个由插入元素顺序加已有数组顺序的新数组
    static byte[]
    resize(byte[] bytes, int newSize)
    生成一个新的重新设置大小的数组 调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,其它位置补充0,缩小则截断
    static <T> T[]
    resize(T[] buffer, int newSize)
    生成一个新的重新设置大小的数组 新数组的类型为原数组的类型,调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,缩小则截断
    static <T> T[]
    resize(T[] buffer, int newSize, Class<?> componentType)
    生成一个新的重新设置大小的数组 调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,缩小则截断
    static boolean[]
    reverse(boolean[] array)
    反转数组，会变更原数组
    static boolean[]
    reverse(boolean[] array, int startIndex, int endIndex)
    反转数组，会变更原数组
    static byte[]
    reverse(byte[] array)
    反转数组，会变更原数组
    static byte[]
    reverse(byte[] array, int startIndex, int endIndex)
    反转数组，会变更原数组
    static char[]
    reverse(char[] array)
    反转数组，会变更原数组
    static char[]
    reverse(char[] array, int startIndex, int endIndex)
    反转数组，会变更原数组
    static double[]
    reverse(double[] array)
    反转数组，会变更原数组
    static double[]
    reverse(double[] array, int startIndex, int endIndex)
    反转数组，会变更原数组
    static float[]
    reverse(float[] array)
    反转数组，会变更原数组
    static float[]
    reverse(float[] array, int startIndex, int endIndex)
    反转数组，会变更原数组
    static int[]
    reverse(int[] array)
    反转数组，会变更原数组
    static int[]
    reverse(int[] array, int startIndex, int endIndex)
    反转数组，会变更原数组
    static long[]
    reverse(long[] array)
    反转数组，会变更原数组
    static long[]
    reverse(long[] array, int startIndex, int endIndex)
    反转数组，会变更原数组
    static short[]
    reverse(short[] array)
    反转数组，会变更原数组
    static short[]
    reverse(short[] array, int startIndex, int endIndex)
    反转数组，会变更原数组
    static Object
    setOrAppend(Object array, int index, Object value)
    将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加
    static <T> T[]
    setOrAppend(T[] buffer, int index, T value)
    将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加
    static void
    shift(boolean[] array, int offset)
    改变数组的顺序
    static void
    shift(boolean[] array, int startIndex, int endIndex, int offset)
    改变数组的顺序
    static void
    shift(byte[] array, int offset)
    改变数组的顺序
    static void
    shift(byte[] array, int startIndex, int endIndex, int offset)
    改变数组的顺序
    static void
    shift(char[] array, int offset)
    改变数组的顺序
    static void
    shift(char[] array, int startIndex, int endIndex, int offset)
    改变数组的顺序
    static void
    shift(double[] array, int offset)
    改变数组的顺序
    static void
    shift(double[] array, int startIndex, int endIndex, int offset)
    改变数组的顺序
    static void
    shift(float[] array, int offset)
    改变数组的顺序
    static void
    shift(float[] array, int startIndex, int endIndex, int offset)
    改变数组的顺序
    static void
    shift(int[] array, int offset)
    移位给定int数组的顺序
    static void
    shift(int[] array, int startIndex, int endIndex, int offset)
    改变数组的顺序
    static void
    shift(long[] array, int offset)
    移位给定长数组的顺序
    static void
    shift(long[] array, int startIndex, int endIndex, int offset)
    改变数组的顺序
    static void
    shift(short[] array, int offset)
    改变数组的顺序
    static void
    shift(short[] array, int startIndex, int endIndex, int offset)
    改变数组的顺序
    static void
    shift(Object[] array, int offset)
    移位给定数组的顺序
    static void
    shift(Object[] array, int startIndex, int endIndex, int offset)
    改变数组的顺序
    static void
    shuffle(boolean[] array)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(boolean[] array, Random random)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(byte[] array)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(byte[] array, Random random)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(char[] array)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(char[] array, Random random)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(double[] array)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(double[] array, Random random)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(float[] array)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(float[] array, Random random)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(int[] array)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(int[] array, Random random)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(long[] array)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(long[] array, Random random)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(short[] array)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(short[] array, Random random)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(Object[] array)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static void
    shuffle(Object[] array, Random random)
    使用Fisher-Yates算法随机遍历指定数组的元素.
    static boolean[]
    sub(boolean[] array, int start, int end)
    获取子数组
    static byte[]
    sub(byte[] array, int start, int end)
    获取子数组
    static char[]
    sub(char[] array, int start, int end)
    获取子数组
    static double[]
    sub(double[] array, int start, int end)
    获取子数组
    static float[]
    sub(float[] array, int start, int end)
    获取子数组
    static int[]
    sub(int[] array, int start, int end)
    获取子数组
    static long[]
    sub(long[] array, int start, int end)
    获取子数组
    static short[]
    sub(short[] array, int start, int end)
    获取子数组
    static Object[]
    sub(Object array, int start, int end)
    获取子数组
    static Object[]
    sub(Object array, int start, int end, int step)
    获取子数组
    static <T> T[]
    sub(T[] array, int start, int end)
    获取子数组
    static boolean[]
    subarray(boolean[] array, int startIndex, int endIndex)
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
    static byte[]
    subarray(byte[] array, int startIndex, int endIndex)
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
    static char[]
    subarray(char[] array, int startIndex, int endIndex)
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
    static double[]
    subarray(double[] array, int startIndex, int endIndex)
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
    static float[]
    subarray(float[] array, int startIndex, int endIndex)
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
    static int[]
    subarray(int[] array, int startIndex, int endIndex)
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
    static long[]
    subarray(long[] array, int startIndex, int endIndex)
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
    static short[]
    subarray(short[] array, int startIndex, int endIndex)
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
    static <T> T[]
    subarray(T[] array, int startIndex, int endIndex)
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
    static void
    swap(boolean[] array, int offset1, int offset2)
    交换数组中连个位置的值
    static void
    swap(boolean[] array, int offset1, int offset2, int len)
    交换数组中连个位置的值
    static void
    swap(byte[] array, int offset1, int offset2)
    交换数组中连个位置的值
    static void
    swap(byte[] array, int offset1, int offset2, int len)
    交换数组中连个位置的值
    static void
    swap(char[] array, int offset1, int offset2)
    交换数组中连个位置的值
    static void
    swap(char[] array, int offset1, int offset2, int len)
    交换数组中连个位置的值
    static void
    swap(double[] array, int offset1, int offset2)
    交换数组中连个位置的值
    static void
    swap(double[] array, int offset1, int offset2, int len)
    交换数组中连个位置的值
    static void
    swap(float[] array, int offset1, int offset2)
    交换数组中连个位置的值
    static void
    swap(float[] array, int offset1, int offset2, int len)
    交换数组中连个位置的值
    static void
    swap(int[] array, int offset1, int offset2)
    交换数组中连个位置的值
    static void
    swap(int[] array, int offset1, int offset2, int len)
    交换数组中连个位置的值
    static void
    swap(long[] array, int offset1, int offset2)
    交换数组中连个位置的值
    static void
    swap(long[] array, int offset1, int offset2, int len)
    交换数组中连个位置的值
    static void
    swap(short[] array, int offset1, int offset2)
    交换数组中连个位置的值
    static void
    swap(short[] array, int offset1, int offset2, int len)
    交换数组中连个位置的值
    static void
    swap(Object[] array, int offset1, int offset2)
    交换数组中连个位置的值
    static void
    swap(Object[] array, int offset1, int offset2, int len)
    交换数组中连个位置的值
    static <T> T[]
    toArray(Iterable<T> iterable, Class<T> componentType)
    将集合转为数组
    static byte[]
    toArray(ByteBuffer bytebuffer)
    ByteBuffer 转byte数组
    static <T> T[]
    toArray(Collection<T> collection, Class<T> componentType)
    将集合转为数组
    static String[]
    toArray(Enumeration<String> enumeration)
    将给定的枚举复制到String数组中 枚举必须只包含String元素
    static <T> T[]
    toArray(Iterator<T> iterator, Class<T> componentType)
    将集合转为数组
    static String[]
    toArray(List<String> list)
    将集合转数组
    static Boolean[]
    toObject(boolean[] array)
    将原始布尔值数组转换为对象 此方法为null输入数组返回null
    static Byte[]
    toObject(byte[] array)
    将对象byte数组转换为处理null的原始对象 此方法为null输入数组返回null
    static Character[]
    toObject(char[] array)
    将对象char数组转换为处理null的原始对象 此方法为null输入数组返回null
    static Double[]
    toObject(double[] array)
    将对象double数组转换为处理null的原始对象 此方法为null输入数组返回null
    static Float[]
    toObject(float[] array)
    将基元float组转换为对象 此方法为null输入数组返回null
    static Integer[]
    toObject(int[] array)
    将对象int数组转换为处理null的原始对象 此方法为null输入数组返回null
    static Long[]
    toObject(long[] array)
    将对象long数组转换为处理null的原始对象 此方法为null输入数组返回null
    static Short[]
    toObject(short[] array)
    将对象short数组转换为处理null的原始对象 此方法为null输入数组返回null
    static boolean[]
    toPrimitive(Boolean[] array)
    将对象布尔值数组转换为处理null的原始的类型 此方法为null输入数组返回null
    static boolean[]
    toPrimitive(Boolean[] array, boolean valueForNull)
    将对象布尔值数组转换为处理null的原始的类型 此方法为null输入数组返回null
    static byte[]
    toPrimitive(Byte[] array)
    将对象Byte数组转换为处理null的原始对象 此方法为null输入数组返回null
    static byte[]
    toPrimitive(Byte[] array, byte valueForNull)
    将对象Byte数组转换为处理null的原始对象 此方法为null输入数组返回null
    static char[]
    toPrimitive(Character[] array)
    将对象Character数组转换为处理null的原始对象 此方法为null输入数组返回null
    static char[]
    toPrimitive(Character[] array, char valueForNull)
    将对象Character数组转换为处理null的原始对象 此方法为null输入数组返回null
    static double[]
    toPrimitive(Double[] array)
    将对象Double数组转换为处理null的原始对象 此方法为null输入数组返回null
    static double[]
    toPrimitive(Double[] array, double valueForNull)
    将对象Double数组转换为处理null的原始对象 此方法为null输入数组返回null
    static float[]
    toPrimitive(Float[] array)
    将对象Float数组转换为处理null的原始对象 此方法为null输入数组返回null
    static float[]
    toPrimitive(Float[] array, float valueForNull)
    将对象Float数组转换为处理null的原始对象 此方法为null输入数组返回null
    static int[]
    toPrimitive(Integer[] array)
    将对象Integer数组转换为处理null的原始对象 此方法为null输入数组返回null
    static int[]
    toPrimitive(Integer[] array, int valueForNull)
    将对象Integer数组转换为处理null的原始对象 此方法为null输入数组返回null
    static long[]
    toPrimitive(Long[] array)
    将对象Long数组转换为处理null的原始对象 此方法为null输入数组返回null
    static long[]
    toPrimitive(Long[] array, long valueForNull)
    将对象Long数组转换为处理null的原始对象 此方法为null输入数组返回null
    static Object
    toPrimitive(Object array)
    从包装器类型数组创建基元类型数组 该方法为一个null输入数组返回null
    static short[]
    toPrimitive(Short[] array)
    将对象Short数组转换为处理null的原始对象 此方法为null输入数组返回null
    static short[]
    toPrimitive(Short[] array, short valueForNull)
    将对象Short数组转换为处理null的原始对象 此方法为null输入数组返回null
    static String
    toString(Object object)
    数组或集合转String
    static String
    toString(Object array, String stringIfNull)
    数组或集合转String
    static String[]
    toStringArray(Object[] array)
    返回一个数组，该数组包含参数数组中每个元素的字符串表示形式.
    static String[]
    toStringArray(Object[] array, String valueForNullElements)
    返回一个数组，该数组包含处理null元素的参数数组中每个元素的字符串表示形式 该方法为一个null输入数组返回null
    static boolean[]
    unWrap(Boolean... values)
    包装类数组转为原始类型数组
    static byte[]
    unWrap(Byte... values)
    包装类数组转为原始类型数组
    static char[]
    unWrap(Character... values)
    包装类数组转为原始类型数组
    static double[]
    unWrap(Double... values)
    包装类数组转为原始类型数组
    static float[]
    unWrap(Float... values)
    包装类数组转为原始类型数组
    static int[]
    unWrap(Integer... values)
    包装类数组转为原始类型数组
    static long[]
    unWrap(Long... values)
    包装类数组转为原始类型数组
    static short[]
    unWrap(Short... values)
    包装类数组转为原始类型数组
    static Boolean[]
    wrap(boolean... values)
    将原始类型数组包装为包装类型
    static Byte[]
    wrap(byte... values)
    将原始类型数组包装为包装类型
    static Character[]
    wrap(char... values)
    将原始类型数组包装为包装类型
    static Double[]
    wrap(double... values)
    将原始类型数组包装为包装类型
    static Float[]
    wrap(float... values)
    将原始类型数组包装为包装类型
    static Long[]
    wrap(long... values)
    将原始类型数组包装为包装类型
    static Short[]
    wrap(short... values)
    将原始类型数组包装为包装类型
    static Object[]
    wrap(Object object)
    包装数组对象
    static <K, V> Map<K,V>
    zip(K[] keys, V[] values)
    映射键值(参考Python的zip()函数)，返回Map无序 例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分
    static <K, V> Map<K,V>
    zip(K[] keys, V[] values, boolean isOrder)
    映射键值(参考Python的zip()函数) 例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Constructor Details

    • ArrayKit

      public ArrayKit()

  • Method Details

    • isArray

      public static boolean isArray(Object object)
      对象是否为数组对象
      Parameters:
      object - 对象
      Returns:
      是否为数组对象, 如果为null 返回false

    • isEmpty

      public static boolean isEmpty(Object array)
      数组是否为空 此方法会匹配单一对象,如果此对象为null则返回true 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回false 如果此对象为数组对象,数组长度大于0情况下返回false,否则返回true
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static <T> boolean isEmpty(T[] array)
      数组是否为空
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(long[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(int[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(short[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(char[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(byte[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(double[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(float[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(boolean[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isNotEmpty

      public static <T> boolean isNotEmpty(T[] array)
      数组是否为非空 此方法会匹配单一对象,如果此对象为null则返回false 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回true 如果此对象为数组对象,数组长度大于0情况下返回true,否则返回false
      Type Parameters:
      T - 对象
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(long[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(int[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(short[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(char[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(byte[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(double[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(float[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(boolean[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isAllEmpty

      public static boolean isAllEmpty(Object... args)
      是否存都为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
      Parameters:
      args - 被检查的对象,一个或者多个
      Returns:
      是否都为空

    • isAllNotEmpty

      public static boolean isAllNotEmpty(Object... args)
      是否存都不为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
      Parameters:
      args - 被检查的对象,一个或者多个
      Returns:
      是否都不为空

    • nullToEmpty

      public static <T> T[] nullToEmpty(T[] array, Class<T[]> type)
      输入数组返回一个空数组或原始数组
      Type Parameters:
      T - class 类型
      Parameters:
      array - 要检查null或为空的数组
      type - 所需数组的类表示形式
      Returns:
      如果null
      Throws:
      IllegalArgumentException - 如果类型参数为空

    • nullToEmpty

      public static Object[] nullToEmpty(Object[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static Class<?>[] nullToEmpty(Class<?>[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static String[] nullToEmpty(String[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static long[] nullToEmpty(long[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static int[] nullToEmpty(int[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static short[] nullToEmpty(short[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static char[] nullToEmpty(char[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static byte[] nullToEmpty(byte[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static double[] nullToEmpty(double[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static float[] nullToEmpty(float[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static boolean[] nullToEmpty(boolean[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static Long[] nullToEmpty(Long[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static Integer[] nullToEmpty(Integer[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static Short[] nullToEmpty(Short[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static Character[] nullToEmpty(Character[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static Byte[] nullToEmpty(Byte[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static Double[] nullToEmpty(Double[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static Float[] nullToEmpty(Float[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • nullToEmpty

      public static Boolean[] nullToEmpty(Boolean[] array)
      输入数组返回一个空数组或原始数组
      Parameters:
      array - 数组
      Returns:
      空数组或原始数组

    • hasEmpty

      public static boolean hasEmpty(Object... args)
      是否存在null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
      Parameters:
      args - 被检查对象
      Returns:
      是否存在

    • hasNull

      public static <T> boolean hasNull(T... array)
      是否包含null元素
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 被检查的数组
      Returns:
      是否包含null元素

    • isAllNull

      public static <T> boolean isAllNull(T... array)
      多个字段是否全为null
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 被检查的数组
      Returns:
      多个字段是否全为null

    • isAllNotNull

      public static <T> boolean isAllNotNull(T... array)
      多个字段是否全部不为null
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 被检查的数组
      Returns:
      多个字段是否全部不为null

    • firstNonNull

      public static <T> T firstNonNull(T... array)
      返回数组中第一个非空元素
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      Returns:
      非空元素，如果不存在非空元素或数组为空，返回null

    • firstNonNull

      public static <T> T firstNonNull(Matcher<T> matcher, T... array)
      返回数组中第一个匹配规则的值
      Type Parameters:
      T - 数组元素类型
      Parameters:
      matcher - 匹配接口，实现此接口自定义匹配规则
      array - 数组
      Returns:
      匹配元素，如果不存在匹配元素或数组为空，返回null

    • firstNonAll

      public static <T> int firstNonAll(Matcher<T> matcher, T... array)
      返回数组中第一个匹配规则的值的位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      matcher - 匹配接口，实现此接口自定义匹配规则
      array - 数组
      Returns:
      匹配到元素的位置，-1表示未匹配到

    • firstNonAll

      public static <T> int firstNonAll(Matcher<T> matcher, int beginIndexInclude, T... array)
      返回数组中第一个匹配规则的值的位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      matcher - 匹配接口，实现此接口自定义匹配规则
      beginIndexInclude - 检索开始的位置
      array - 数组
      Returns:
      匹配到元素的位置，-1表示未匹配到

    • firstNotNull

      public static Optional<Object> firstNotNull(Object[] objects)
      找到第一个不为 null 的元素
      Parameters:
      objects - 对象
      Returns:
      不为 null 的元素

    • removeEmpty

      public static <T extends CharSequence> T[] removeEmpty(T[] array)
      去除null或者"" 元素
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      Returns:
      处理后的数组

    • removeBlank

      public static <T extends CharSequence> T[] removeBlank(T[] array)
      去除null或者""或者空白字符串 元素
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      Returns:
      处理后的数组

    • toString

      public static String toString(Object object)
      数组或集合转String
      Parameters:
      object - 集合或数组对象
      Returns:
      数组字符串, 与集合转字符串格式相同

    • toString

      public static String toString(Object array, String stringIfNull)
      数组或集合转String
      Parameters:
      array - 集合或数组对象
      stringIfNull - 是否null
      Returns:
      数组字符串, 与集合转字符串格式相同

    • toArray

      public static String[] toArray(List<String> list)
      将集合转数组
      Parameters:
      list - 需要转换的集合信息
      Returns:
      转换后的数组

    • toArray

      public static String[] toArray(Enumeration<String> enumeration)
      将给定的枚举复制到String数组中 枚举必须只包含String元素
      Parameters:
      enumeration - 要复制的枚举 Enumeration
      Returns:
      String 数组

    • toArray

      public static byte[] toArray(ByteBuffer bytebuffer)
      ByteBuffer 转byte数组
      Parameters:
      bytebuffer - ByteBuffer
      Returns:
      byte数组

    • toArray

      public static <T> T[] toArray(Iterator<T> iterator, Class<T> componentType)
      将集合转为数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      iterator - Iterator
      componentType - 集合元素类型
      Returns:
      数组

    • toArray

      public static <T> T[] toArray(Iterable<T> iterable, Class<T> componentType)
      将集合转为数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      iterable - Iterable
      componentType - 集合元素类型
      Returns:
      数组

    • toArray

      public static <T> T[] toArray(Collection<T> collection, Class<T> componentType)
      将集合转为数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      collection - 集合
      componentType - 集合元素类型
      Returns:
      数组

    • clone

      public static <T> T[] clone(T[] array)
      克隆数组
      Type Parameters:
      T - 对象
      Parameters:
      array - 被克隆的数组
      Returns:
      新数组

    • clone

      public static <T> T clone(T object)
      克隆数组,如果非数组返回null
      Type Parameters:
      T - 数组元素类型
      Parameters:
      object - 数组对象
      Returns:
      克隆后的数组对象

    • clone

      public static long[] clone(long[] array)
      克隆数组
      Parameters:
      array - 被克隆的数组
      Returns:
      新数组

    • clone

      public static int[] clone(int[] array)
      克隆数组
      Parameters:
      array - 被克隆的数组
      Returns:
      新数组

    • clone

      public static short[] clone(short[] array)
      克隆数组
      Parameters:
      array - 被克隆的数组
      Returns:
      新数组

    • clone

      public static char[] clone(char[] array)
      克隆数组
      Parameters:
      array - 被克隆的数组
      Returns:
      新数组

    • clone

      public static byte[] clone(byte[] array)
      克隆数组
      Parameters:
      array - 被克隆的数组
      Returns:
      新数组

    • clone

      public static double[] clone(double[] array)
      克隆数组
      Parameters:
      array - 被克隆的数组
      Returns:
      新数组

    • clone

      public static float[] clone(float[] array)
      克隆数组
      Parameters:
      array - 被克隆的数组
      Returns:
      新数组

    • clone

      public static boolean[] clone(boolean[] array)
      克隆数组
      Parameters:
      array - 被克隆的数组
      Returns:
      新数组

    • subarray

      public static <T> T[] subarray(T[] array, int startIndex, int endIndex)
      生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
      Type Parameters:
      T - 对象
      Parameters:
      array - 对象数组
      startIndex - 开始索引
      endIndex - 结束索引
      Returns:
      新数组

    • subarray

      public static long[] subarray(long[] array, int startIndex, int endIndex)
      生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
      Parameters:
      array - 对象数组
      startIndex - 开始索引
      endIndex - 结束索引
      Returns:
      新数组

    • subarray

      public static int[] subarray(int[] array, int startIndex, int endIndex)
      生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
      Parameters:
      array - 对象数组
      startIndex - 开始索引
      endIndex - 结束索引
      Returns:
      新数组

    • subarray

      public static short[] subarray(short[] array, int startIndex, int endIndex)
      生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
      Parameters:
      array - 对象数组
      startIndex - 开始索引
      endIndex - 结束索引
      Returns:
      新数组

    • subarray

      public static char[] subarray(char[] array, int startIndex, int endIndex)
      生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
      Parameters:
      array - 对象数组
      startIndex - 开始索引
      endIndex - 结束索引
      Returns:
      新数组

    • subarray

      public static byte[] subarray(byte[] array, int startIndex, int endIndex)
      生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
      Parameters:
      array - 对象数组
      startIndex - 开始索引
      endIndex - 结束索引
      Returns:
      新数组

    • subarray

      public static double[] subarray(double[] array, int startIndex, int endIndex)
      生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
      Parameters:
      array - 对象数组
      startIndex - 开始索引
      endIndex - 结束索引
      Returns:
      新数组

    • subarray

      public static float[] subarray(float[] array, int startIndex, int endIndex)
      生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
      Parameters:
      array - 对象数组
      startIndex - 开始索引
      endIndex - 结束索引
      Returns:
      新数组

    • subarray

      public static boolean[] subarray(boolean[] array, int startIndex, int endIndex)
      生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出
      Parameters:
      array - 对象数组
      startIndex - 开始索引
      endIndex - 结束索引
      Returns:
      新数组

    • isSameLength

      public static boolean isSameLength(Object[] array1, Object[] array2)
      检查两个数组是否相同长度
      Parameters:
      array1 - 参数1
      array2 - 参数2
      Returns:
      如果长度匹配返回true否则false

    • isSameLength

      public static boolean isSameLength(long[] array1, long[] array2)
      检查两个数组是否相同长度
      Parameters:
      array1 - 参数1
      array2 - 参数2
      Returns:
      如果长度匹配返回true否则false

    • isSameLength

      public static boolean isSameLength(int[] array1, int[] array2)
      检查两个数组是否相同长度
      Parameters:
      array1 - 参数1
      array2 - 参数2
      Returns:
      如果长度匹配返回true否则false

    • isSameLength

      public static boolean isSameLength(short[] array1, short[] array2)
      检查两个数组是否相同长度
      Parameters:
      array1 - 参数1
      array2 - 参数2
      Returns:
      如果长度匹配返回true否则false

    • isSameLength

      public static boolean isSameLength(char[] array1, char[] array2)
      检查两个数组是否相同长度
      Parameters:
      array1 - 参数1
      array2 - 参数2
      Returns:
      如果长度匹配返回true否则false

    • isSameLength

      public static boolean isSameLength(byte[] array1, byte[] array2)
      检查两个数组是否相同长度
      Parameters:
      array1 - 参数1
      array2 - 参数2
      Returns:
      如果长度匹配返回true否则false

    • isSameLength

      public static boolean isSameLength(double[] array1, double[] array2)
      检查两个数组是否相同长度
      Parameters:
      array1 - 参数1
      array2 - 参数2
      Returns:
      如果长度匹配返回true否则false

    • isSameLength

      public static boolean isSameLength(float[] array1, float[] array2)
      检查两个数组是否相同长度
      Parameters:
      array1 - 参数1
      array2 - 参数2
      Returns:
      如果长度匹配返回true否则false

    • isSameLength

      public static boolean isSameLength(boolean[] array1, boolean[] array2)
      检查两个数组是否相同长度
      Parameters:
      array1 - 参数1
      array2 - 参数2
      Returns:
      如果长度匹配返回true否则false

    • reverse

      public static long[] reverse(long[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static long[] reverse(long[] array, int startIndex, int endIndex)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndex - 其实位置（包含）
      endIndex - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static int[] reverse(int[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static int[] reverse(int[] array, int startIndex, int endIndex)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndex - 其实位置（包含）
      endIndex - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static short[] reverse(short[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static short[] reverse(short[] array, int startIndex, int endIndex)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndex - 其实位置（包含）
      endIndex - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static char[] reverse(char[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static char[] reverse(char[] array, int startIndex, int endIndex)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndex - 其实位置（包含）
      endIndex - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static byte[] reverse(byte[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static byte[] reverse(byte[] array, int startIndex, int endIndex)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndex - 其实位置（包含）
      endIndex - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static double[] reverse(double[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static double[] reverse(double[] array, int startIndex, int endIndex)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndex - 其实位置（包含）
      endIndex - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static float[] reverse(float[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static float[] reverse(float[] array, int startIndex, int endIndex)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndex - 其实位置（包含）
      endIndex - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static boolean[] reverse(boolean[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static boolean[] reverse(boolean[] array, int startIndex, int endIndex)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndex - 其实位置（包含）
      endIndex - 结束位置（不包含）
      Returns:
      变更后的原数组

    • swap

      public static void swap(Object[] array, int offset1, int offset2)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2

    • swap

      public static void swap(long[] array, int offset1, int offset2)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2

    • swap

      public static void swap(int[] array, int offset1, int offset2)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2

    • swap

      public static void swap(short[] array, int offset1, int offset2)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2

    • swap

      public static void swap(char[] array, int offset1, int offset2)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2

    • swap

      public static void swap(byte[] array, int offset1, int offset2)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2

    • swap

      public static void swap(double[] array, int offset1, int offset2)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2

    • swap

      public static void swap(float[] array, int offset1, int offset2)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2

    • swap

      public static void swap(boolean[] array, int offset1, int offset2)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2

    • swap

      public static void swap(boolean[] array, int offset1, int offset2, int len)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2
      len - 从给定索引开始交换的元素数量

    • swap

      public static void swap(byte[] array, int offset1, int offset2, int len)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2
      len - 从给定索引开始交换的元素数量

    • swap

      public static void swap(char[] array, int offset1, int offset2, int len)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2
      len - 从给定索引开始交换的元素数量

    • swap

      public static void swap(double[] array, int offset1, int offset2, int len)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2
      len - 从给定索引开始交换的元素数量

    • swap

      public static void swap(float[] array, int offset1, int offset2, int len)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2
      len - 从给定索引开始交换的元素数量

    • swap

      public static void swap(int[] array, int offset1, int offset2, int len)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2
      len - 从给定索引开始交换的元素数量

    • swap

      public static void swap(long[] array, int offset1, int offset2, int len)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2
      len - 从给定索引开始交换的元素数量

    • swap

      public static void swap(Object[] array, int offset1, int offset2, int len)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2
      len - 从给定索引开始交换的元素数量

    • swap

      public static void swap(short[] array, int offset1, int offset2, int len)
      交换数组中连个位置的值
      Parameters:
      array - 数组
      offset1 - 位置1
      offset2 - 位置2
      len - 从给定索引开始交换的元素数量

    • shift

      public static void shift(Object[] array, int offset)
      移位给定数组的顺序
      Parameters:
      array - 要移动的数组，可以为null
      offset - 旋转元素的位置数。如果偏移量大于*旋转的元素数，则有效偏移量将等于旋转的元素数

    • shift

      public static void shift(long[] array, int offset)
      移位给定长数组的顺序
      Parameters:
      array - 要移动的数组，可以为null
      offset - 旋转元素的位置数。如果偏移量大于*旋转的元素数，则有效偏移量将等于旋转的元素数

    • shift

      public static void shift(int[] array, int offset)
      移位给定int数组的顺序
      Parameters:
      array - 要移动的数组，可以为null
      offset - 旋转元素的位置数。如果偏移量大于*旋转的元素数，则有效偏移量将等于旋转的元素数

    • shift

      public static void shift(short[] array, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      offset - 偏移量

    • shift

      public static void shift(char[] array, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      offset - 偏移量

    • shift

      public static void shift(byte[] array, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      offset - 偏移量

    • shift

      public static void shift(double[] array, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      offset - 偏移量

    • shift

      public static void shift(float[] array, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      offset - 偏移量

    • shift

      public static void shift(boolean[] array, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      offset - 偏移量

    • shift

      public static void shift(boolean[] array, int startIndex, int endIndex, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      startIndex - 开始索引
      endIndex - 结束索引
      offset - 偏移量

    • shift

      public static void shift(byte[] array, int startIndex, int endIndex, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      startIndex - 开始索引
      endIndex - 结束索引
      offset - 偏移量

    • shift

      public static void shift(char[] array, int startIndex, int endIndex, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      startIndex - 开始索引
      endIndex - 结束索引
      offset - 偏移量

    • shift

      public static void shift(double[] array, int startIndex, int endIndex, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      startIndex - 开始索引
      endIndex - 结束索引
      offset - 偏移量

    • shift

      public static void shift(float[] array, int startIndex, int endIndex, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      startIndex - 开始索引
      endIndex - 结束索引
      offset - 偏移量

    • shift

      public static void shift(int[] array, int startIndex, int endIndex, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      startIndex - 开始索引
      endIndex - 结束索引
      offset - 偏移量

    • shift

      public static void shift(long[] array, int startIndex, int endIndex, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      startIndex - 开始索引
      endIndex - 结束索引
      offset - 偏移量

    • shift

      public static void shift(Object[] array, int startIndex, int endIndex, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      startIndex - 开始索引
      endIndex - 结束索引
      offset - 偏移量

    • shift

      public static void shift(short[] array, int startIndex, int endIndex, int offset)
      改变数组的顺序
      Parameters:
      array - 原数组
      startIndex - 开始索引
      endIndex - 结束索引
      offset - 偏移量

    • indexOf

      public static int indexOf(Object[] array, Object value)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(Object[] array, Object value, int index)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(Object[] array, Object value)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(Object[] array, Object value, int index)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • contains

      public static boolean contains(Object[] array, Object value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(long[] array, long value)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(long[] array, long value, int index)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(long[] array, long value)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(long[] array, long value, int index)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • contains

      public static boolean contains(long[] array, long value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(int[] array, int value)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(int[] array, int value, int index)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(int[] array, int value)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(int[] array, int value, int index)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • contains

      public static boolean contains(int[] array, int value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(short[] array, short value)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(short[] array, short value, int index)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(short[] array, short value)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(short[] array, short value, int index)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • contains

      public static boolean contains(short[] array, short value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(char[] array, char value)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(char[] array, char value, int index)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(char[] array, char value)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(char[] array, char value, int index)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • contains

      public static boolean contains(char[] array, char value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(byte[] array, byte value)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(byte[] array, byte value, int index)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(byte[] array, byte value)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(byte[] array, byte value, int index)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • contains

      public static boolean contains(byte[] array, byte value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(double[] array, double value)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(double[] array, double value, double tolerance)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      tolerance - 容差
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(double[] array, double value, int index)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(double[] array, double value, int index, double tolerance)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      tolerance - 容差
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(double[] array, double value)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(double[] array, double value, double tolerance)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      tolerance - 容差
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(double[] array, double value, int index)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(double[] array, double value, int index, double tolerance)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      tolerance - 容差
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • contains

      public static boolean contains(double[] array, double value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • contains

      public static boolean contains(double[] array, double value, double tolerance)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      tolerance - 容差
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(float[] array, float value)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(float[] array, float value, int index)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(float[] array, float value)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(float[] array, float value, int index)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • contains

      public static boolean contains(float[] array, float value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(boolean[] array, boolean value)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • indexOf

      public static int indexOf(boolean[] array, boolean value, int index)
      返回数组中指定元素所在位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(boolean[] array, boolean value)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(boolean[] array, boolean value, int index)
      返回数组中指定元素所在最后的位置,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      index - 索引
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • contains

      public static boolean contains(boolean[] array, boolean value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • toPrimitive

      public static char[] toPrimitive(Character[] array)
      将对象Character数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Character数组，可以是null
      Returns:
      char数组，null如果为空数组输入
      Throws:
      NullPointerException - 如果数组内容是null

    • toPrimitive

      public static char[] toPrimitive(Character[] array, char valueForNull)
      将对象Character数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Character数组，可以是null
      valueForNull - 找到null时要插入的值
      Returns:
      Character数组，null如果为空数组输入

    • toObject

      public static Character[] toObject(char[] array)
      将对象char数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - char数组，可以是null
      Returns:
      Character数组，null如果为空数组输入

    • toPrimitive

      public static long[] toPrimitive(Long[] array)
      将对象Long数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Long数组，可以是null
      Returns:
      long数组，null如果为空数组输入

    • toPrimitive

      public static long[] toPrimitive(Long[] array, long valueForNull)
      将对象Long数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Long数组，可以是null
      valueForNull - 找到null时要插入的值
      Returns:
      Long数组，null如果为空数组输入

    • toObject

      public static Long[] toObject(long[] array)
      将对象long数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - long数组，可以是null
      Returns:
      Long数组，null如果为空数组输入

    • toPrimitive

      public static int[] toPrimitive(Integer[] array)
      将对象Integer数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Integer数组，可以是null
      Returns:
      int数组，null如果为空数组输入
      Throws:
      NullPointerException - 如果数组内容是null

    • toPrimitive

      public static int[] toPrimitive(Integer[] array, int valueForNull)
      将对象Integer数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Integer数组，可以是null
      valueForNull - 找到null时要插入的值
      Returns:
      Integer数组，null如果为空数组输入

    • toObject

      public static Integer[] toObject(int[] array)
      将对象int数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - int数组，可以是null
      Returns:
      Integer数组，null如果为空数组输入

    • toPrimitive

      public static short[] toPrimitive(Short[] array)
      将对象Short数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Short数组，可以是null
      Returns:
      short数组，null如果为空数组输入

    • toPrimitive

      public static short[] toPrimitive(Short[] array, short valueForNull)
      将对象Short数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Short数组，可以是null
      valueForNull - 找到null时要插入的值
      Returns:
      Short数组，null如果为空数组输入

    • toObject

      public static Short[] toObject(short[] array)
      将对象short数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - short数组，可以是null
      Returns:
      Short数组，null如果为空数组输入

    • toPrimitive

      public static byte[] toPrimitive(Byte[] array)
      将对象Byte数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Byte数组，可以是null
      Returns:
      byte数组，null如果为空数组输入
      Throws:
      NullPointerException - 如果数组内容是null

    • toPrimitive

      public static byte[] toPrimitive(Byte[] array, byte valueForNull)
      将对象Byte数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Byte数组，可以是null
      valueForNull - 找到null时要插入的值
      Returns:
      Byte数组，null如果为空数组输入

    • toObject

      public static Byte[] toObject(byte[] array)
      将对象byte数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - byte数组，可以是null
      Returns:
      Byte数组，null如果为空数组输入

    • toPrimitive

      public static double[] toPrimitive(Double[] array)
      将对象Double数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Double数组，可以是null
      Returns:
      double数组，null如果为空数组输入
      Throws:
      NullPointerException - 如果数组内容是null

    • toPrimitive

      public static double[] toPrimitive(Double[] array, double valueForNull)
      将对象Double数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Double数组，可以是null
      valueForNull - 找到null时要插入的值
      Returns:
      Double数组，null如果为空数组输入

    • toObject

      public static Double[] toObject(double[] array)
      将对象double数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - double数组，可以是null
      Returns:
      double数组，null如果为空数组输入

    • toPrimitive

      public static float[] toPrimitive(Float[] array)
      将对象Float数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Float数组，可以是null
      Returns:
      float数组，null如果为空数组输入
      Throws:
      NullPointerException - 如果数组内容是null

    • toPrimitive

      public static float[] toPrimitive(Float[] array, float valueForNull)
      将对象Float数组转换为处理null的原始对象 此方法为null输入数组返回null
      Parameters:
      array - Float数组，可以是null
      valueForNull - 找到null时要插入的值
      Returns:
      float数组，null如果为空数组输入

    • toObject

      public static Float[] toObject(float[] array)
      将基元float组转换为对象 此方法为null输入数组返回null
      Parameters:
      array - float数组
      Returns:
      Float数组，null如果为空数组输入

    • toPrimitive

      public static Object toPrimitive(Object array)
      从包装器类型数组创建基元类型数组 该方法为一个null输入数组返回null
      Parameters:
      array - 包装器对象的数组
      Returns:
      对应基元类型的数组，或原始数组

    • toPrimitive

      public static boolean[] toPrimitive(Boolean[] array)
      将对象布尔值数组转换为处理null的原始的类型 此方法为null输入数组返回null
      Parameters:
      array - Boolean数组，可以是null
      Returns:
      返回boolean数组, 如果输入为null则为null
      Throws:
      NullPointerException - 如果数组内容是null

    • toPrimitive

      public static boolean[] toPrimitive(Boolean[] array, boolean valueForNull)
      将对象布尔值数组转换为处理null的原始的类型 此方法为null输入数组返回null
      Parameters:
      array - Boolean数组，可以是null
      valueForNull - 找到null时要插入的值
      Returns:
      返回boolean数组, 如果输入为null则为null

    • toObject

      public static Boolean[] toObject(boolean[] array)
      将原始布尔值数组转换为对象 此方法为null输入数组返回null
      Parameters:
      array - boolean数组
      Returns:
      返回boolean数组, 如果输入为null则为null

    • addAll

      public static <T> T[] addAll(T[]... arrays)
      将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素 
       ArrayKit.addAll(null, null)     = null
 ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
 ArrayKit.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]
      Type Parameters:
      T - 数组元素类型
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的新数组 T[]

    • addAll

      public static byte[] addAll(byte[]... arrays)
      将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素 
       ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的新数组 byte[]

    • addAll

      public static boolean[] addAll(boolean[]... arrays)
      将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素 
       ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的新数组 boolean[]

    • addAll

      public static char[] addAll(char[]... arrays)
      将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素 
       ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的新数组 char[]

    • addAll

      public static short[] addAll(short[]... arrays)
      将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素 
       ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的新数组 short[]

    • addAll

      public static int[] addAll(int[]... arrays)
      将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素 
       ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的新数组 int[]

    • addAll

      public static long[] addAll(long[]... arrays)
      将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素 
       ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的新数组 long[]

    • addAll

      public static float[] addAll(float[]... arrays)
      将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素 
       ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的新数组 float[]

    • addAll

      public static double[] addAll(double[]... arrays)
      将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素 
       ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的新数组 double[]

    • add

      public static <T> T[] add(T[] array, T element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组， 其组件类型与元素相同，除非元素本身为空，否则返回类型为Object[] 
       ArrayKit.add(null, null)      = IllegalArgumentException
 ArrayKit.add(null, "a")       = ["a"]
 ArrayKit.add(["a"], null)     = ["a", null]
 ArrayKit.add(["a"], "b")      = ["a", "b"]
 ArrayKit.add(["a", "b"], "c") = ["a", "b", "c"]
      Type Parameters:
      T - 数组的组件类型
      Parameters:
      array - 要“add”元素的数组可以是null
      element - 要添加的对象可以是null
      Returns:
      包含现有元素的新数组加上返回的新元素数组类型将是输入数组的类型(除非为空)， 在这种情况下，它将具有与元素相同的类型。如果两者都为空，则抛出IllegalArgumentException
      Throws:
      IllegalArgumentException - 如果两个参数都为空

    • add

      public static boolean[] add(boolean[] array, boolean element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, true)          = [true]
 ArrayKit.add([true], false)       = [true, false]
 ArrayKit.add([true, false], true) = [true, false, true]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static byte[] add(byte[] array, byte element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static char[] add(char[] array, char element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, '0')       = ['0']
 ArrayKit.add(['1'], '0')      = ['1', '0']
 ArrayKit.add(['1', '0'], '1') = ['1', '0', '1']
      Parameters:
      array - 要复制并添加元素的数组可以是null
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static double[] add(double[] array, double element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static float[] add(float[] array, float element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static int[] add(int[] array, int element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static long[] add(long[] array, long element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static short[] add(short[] array, short element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static <T> T[] add(T[] array, int index, T element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, 0, null)      = IllegalArgumentException
 ArrayKit.add(null, 0, "a")       = ["a"]
 ArrayKit.add(["a"], 1, null)     = ["a", null]
 ArrayKit.add(["a"], 1, "b")      = ["a", "b"]
 ArrayKit.add(["a", "b"], 3, "c") = ["a", "b", "c"]
      Type Parameters:
      T - 数组的组件类型
      Parameters:
      array - 要复制并添加元素的数组可以是null
      index - 新对象的位置
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static boolean[] add(boolean[] array, int index, boolean element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, 0, true)          = [true]
 ArrayKit.add([true], 0, false)       = [false, true]
 ArrayKit.add([false], 1, true)       = [false, true]
 ArrayKit.add([true, false], 1, true) = [true, true, false]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      index - 新对象的位置
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static char[] add(char[] array, int index, char element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add(null, 0, 'a')            = ['a']
 ArrayKit.add(['a'], 0, 'b')           = ['b', 'a']
 ArrayKit.add(['a', 'b'], 0, 'c')      = ['c', 'a', 'b']
 ArrayKit.add(['a', 'b'], 1, 'k')      = ['a', 'k', 'b']
 ArrayKit.add(['a', 'b', 'c'], 1, 't') = ['a', 't', 'b', 'c']
      Parameters:
      array - 要复制并添加元素的数组可以是null
      index - 新对象的位置
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static byte[] add(byte[] array, int index, byte element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add([1], 0, 2)         = [2, 1]
 ArrayKit.add([2, 6], 2, 3)      = [2, 6, 3]
 ArrayKit.add([2, 6], 0, 1)      = [1, 2, 6]
 ArrayKit.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      index - 新对象的位置
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static short[] add(short[] array, int index, short element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add([1], 0, 2)         = [2, 1]
 ArrayKit.add([2, 6], 2, 10)     = [2, 6, 10]
 ArrayKit.add([2, 6], 0, -4)     = [-4, 2, 6]
 ArrayKit.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      index - 新对象的位置
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static int[] add(int[] array, int index, int element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add([1], 0, 2)         = [2, 1]
 ArrayKit.add([2, 6], 2, 10)     = [2, 6, 10]
 ArrayKit.add([2, 6], 0, -4)     = [-4, 2, 6]
 ArrayKit.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      index - 新对象的位置
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static long[] add(long[] array, int index, long element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add([1L], 0, 2L)           = [2L, 1L]
 ArrayKit.add([2L, 6L], 2, 10L)      = [2L, 6L, 10L]
 ArrayKit.add([2L, 6L], 0, -4L)      = [-4L, 2L, 6L]
 ArrayKit.add([2L, 6L, 3L], 2, 1L)   = [2L, 6L, 1L, 3L]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      index - 新对象的位置
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static float[] add(float[] array, int index, float element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add([1.1f], 0, 2.2f)               = [2.2f, 1.1f]
 ArrayKit.add([2.3f, 6.4f], 2, 10.5f)        = [2.3f, 6.4f, 10.5f]
 ArrayKit.add([2.6f, 6.7f], 0, -4.8f)        = [-4.8f, 2.6f, 6.7f]
 ArrayKit.add([2.9f, 6.0f, 0.3f], 2, 1.0f)   = [2.9f, 6.0f, 1.0f, 0.3f]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      index - 新对象的位置
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • add

      public static double[] add(double[] array, int index, double element)
      复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同. 
       ArrayKit.add([1.1], 0, 2.2)              = [2.2, 1.1]
 ArrayKit.add([2.3, 6.4], 2, 10.5)        = [2.3, 6.4, 10.5]
 ArrayKit.add([2.6, 6.7], 0, -4.8)        = [-4.8, 2.6, 6.7]
 ArrayKit.add([2.9, 6.0, 0.3], 2, 1.0)    = [2.9, 6.0, 1.0, 0.3]
      Parameters:
      array - 要复制并添加元素的数组可以是null
      index - 新对象的位置
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      包含现有元素和新元素的新数组

    • remove

      public static <T> T[] remove(T[] array)
      去重数组中的元素，去重后生成新的数组，原数组不变 此方法通过LinkedHashSet 去重
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      Returns:
      去重后的数组

    • remove

      public static <T> T[] remove(T[] array, int index)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.remove(["a"], 0)           = []
 ArrayKit.remove(["a", "b"], 0)      = ["b"]
 ArrayKit.remove(["a", "b"], 1)      = ["a"]
 ArrayKit.remove(["a", "b", "c"], 1) = ["a", "c"]
      Type Parameters:
      T - 数组的组件类型
      Parameters:
      array - 要从中删除的元素
      index - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • remove

      public static <T, K> T[] remove(T[] array, Function<T,K> uniqueGenerator, boolean override)
      去重数组中的元素，去重后生成新的数组，原数组不变 此方法通过LinkedHashSet 去重
      Type Parameters:
      T - 数组元素类型
      K - 唯一键类型
      Parameters:
      array - 数组
      uniqueGenerator - 唯一键生成器
      override - 是否覆盖模式，如果为true，加入的新值会覆盖相同key的旧值，否则会忽略新加值
      Returns:
      去重后的数组

    • removeElement

      public static <T> T[] removeElement(T[] array, Object element)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.removeElement(null, "a")            = null
 ArrayKit.removeElement([], "a")              = []
 ArrayKit.removeElement(["a"], "b")           = ["a"]
 ArrayKit.removeElement(["a", "b"], "a")      = ["b"]
 ArrayKit.removeElement(["a", "b", "a"], "a") = ["b", "a"]
      Type Parameters:
      T - 数组的组件类型
      Parameters:
      array - 要复制并添加元素的数组可以是null
      element - 要在新数组的最后一个索引处添加的对象
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • remove

      public static boolean[] remove(boolean[] array, int index)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.remove([true], 0)              = []
 ArrayKit.remove([true, false], 0)       = [false]
 ArrayKit.remove([true, false], 1)       = [true]
 ArrayKit.remove([true, true, false], 1) = [true, false]
      Parameters:
      array - 要从中删除的元素
      index - 要删除的元素
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • removeElement

      public static boolean[] removeElement(boolean[] array, boolean element)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.removeElement(null, true)                = null
 ArrayKit.removeElement([], true)                  = []
 ArrayKit.removeElement([true], false)             = [true]
 ArrayKit.removeElement([true, false], false)      = [true]
 ArrayKit.removeElement([true, false, true], true) = [false, true]
      Parameters:
      array - 要从中移除元素的数组
      element - 要删除的元素
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • remove

      public static byte[] remove(byte[] array, int index)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.remove([1], 0)          = []
 ArrayKit.remove([1, 0], 0)       = [0]
 ArrayKit.remove([1, 0], 1)       = [1]
 ArrayKit.remove([1, 0, 1], 1)    = [1, 1]
      Parameters:
      array - 要从中移除元素的数组
      index - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • removeElement

      public static byte[] removeElement(byte[] array, byte element)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.removeElement(null, 1)        = null
 ArrayKit.removeElement([], 1)          = []
 ArrayKit.removeElement([1], 0)         = [1]
 ArrayKit.removeElement([1, 0], 0)      = [1]
 ArrayKit.removeElement([1, 0, 1], 1)   = [0, 1]
      Parameters:
      array - 要从中移除元素的数组
      element - 要删除的元素
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • remove

      public static char[] remove(char[] array, int index)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.remove(['a'], 0)           = []
 ArrayKit.remove(['a', 'b'], 0)      = ['b']
 ArrayKit.remove(['a', 'b'], 1)      = ['a']
 ArrayKit.remove(['a', 'b', 'c'], 1) = ['a', 'c']
      Parameters:
      array - 要从中移除元素的数组
      index - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素..

    • removeElement

      public static char[] removeElement(char[] array, char element)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.removeElement(null, 'a')            = null
 ArrayKit.removeElement([], 'a')              = []
 ArrayKit.removeElement(['a'], 'b')           = ['a']
 ArrayKit.removeElement(['a', 'b'], 'a')      = ['b']
 ArrayKit.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a']
      Parameters:
      array - 要从中移除元素的数组
      element - 要删除的元素
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • remove

      public static double[] remove(double[] array, int index)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.remove([1.1], 0)           = []
 ArrayKit.remove([2.5, 6.0], 0)      = [6.0]
 ArrayKit.remove([2.5, 6.0], 1)      = [2.5]
 ArrayKit.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
      Parameters:
      array - 要从中移除元素的数组
      index - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • removeElement

      public static double[] removeElement(double[] array, double element)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.removeElement(null, 1.1)            = null
 ArrayKit.removeElement([], 1.1)              = []
 ArrayKit.removeElement([1.1], 1.2)           = [1.1]
 ArrayKit.removeElement([1.1, 2.3], 1.1)      = [2.3]
 ArrayKit.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
      Parameters:
      array - 要从中移除元素的数组
      element - 要删除的元素
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • remove

      public static float[] remove(float[] array, int index)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.remove([1.1], 0)           = []
 ArrayKit.remove([2.5, 6.0], 0)      = [6.0]
 ArrayKit.remove([2.5, 6.0], 1)      = [2.5]
 ArrayKit.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
      Parameters:
      array - 要从中移除元素的数组
      index - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • removeElement

      public static float[] removeElement(float[] array, float element)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.removeElement(null, 1.1)            = null
 ArrayKit.removeElement([], 1.1)              = []
 ArrayKit.removeElement([1.1], 1.2)           = [1.1]
 ArrayKit.removeElement([1.1, 2.3], 1.1)      = [2.3]
 ArrayKit.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
      Parameters:
      array - 要从中移除元素的数组
      element - 要删除的元素
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • remove

      public static int[] remove(int[] array, int index)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.remove([1], 0)         = []
 ArrayKit.remove([2, 6], 0)      = [6]
 ArrayKit.remove([2, 6], 1)      = [2]
 ArrayKit.remove([2, 6, 3], 1)   = [2, 3]
      Parameters:
      array - 要从中移除元素的数组
      index - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • removeElement

      public static int[] removeElement(int[] array, int element)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.removeElement(null, 1)      = null
 ArrayKit.removeElement([], 1)        = []
 ArrayKit.removeElement([1], 2)       = [1]
 ArrayKit.removeElement([1, 3], 1)    = [3]
 ArrayKit.removeElement([1, 3, 1], 1) = [3, 1]
      Parameters:
      array - 要从中移除元素的数组
      element - 要删除的元素
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • remove

      public static long[] remove(long[] array, int index)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.remove([1], 0)         = []
 ArrayKit.remove([2, 6], 0)      = [6]
 ArrayKit.remove([2, 6], 1)      = [2]
 ArrayKit.remove([2, 6, 3], 1)   = [2, 3]
      Parameters:
      array - 要从中移除元素的数组
      index - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • removeElement

      public static long[] removeElement(long[] array, long element)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.removeElement(null, 1)      = null
 ArrayKit.removeElement([], 1)        = []
 ArrayKit.removeElement([1], 2)       = [1]
 ArrayKit.removeElement([1, 3], 1)    = [3]
 ArrayKit.removeElement([1, 3, 1], 1) = [3, 1]
      Parameters:
      array - 要从中移除元素的数组
      element - 要删除的元素
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • remove

      public static short[] remove(short[] array, int index)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.remove([1], 0)         = []
 ArrayKit.remove([2, 6], 0)      = [6]
 ArrayKit.remove([2, 6], 1)      = [2]
 ArrayKit.remove([2, 6, 3], 1)   = [2, 3]
      Parameters:
      array - 要从中移除元素的数组
      index - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • removeElement

      public static short[] removeElement(short[] array, short element)
      从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素 如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引 
       ArrayKit.removeElement(null, 1)      = null
 ArrayKit.removeElement([], 1)        = []
 ArrayKit.removeElement([1], 2)       = [1]
 ArrayKit.removeElement([1, 3], 1)    = [3]
 ArrayKit.removeElement([1, 3, 1], 1) = [3, 1]
      Parameters:
      array - 要从中移除元素的数组
      element - 要删除的元素
      Returns:
      一个新数组，包含指定位置的元素以外的现有元素.

    • removeAll

      public static <T> T[] removeAll(T[] array, int... indices)
      从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素 
       ArrayKit.removeAll(["a", "b", "c"], 0, 2) = ["b"]
 ArrayKit.removeAll(["a", "b", "c"], 1, 2) = ["a"]
      Type Parameters:
      T - 数组的组件类型
      Parameters:
      array - 要从中删除元素的数组可能不是null
      indices - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeElements

      public static <T> T[] removeElements(T[] array, T... values)
      从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同. 
       ArrayKit.removeElements(null, "a", "b")            = null
 ArrayKit.removeElements([], "a", "b")              = []
 ArrayKit.removeElements(["a"], "b", "c")           = ["a"]
 ArrayKit.removeElements(["a", "b"], "a", "c")      = ["b"]
 ArrayKit.removeElements(["a", "b", "a"], "a")      = ["b", "a"]
 ArrayKit.removeElements(["a", "b", "a"], "a", "a") = ["b"]
      Type Parameters:
      T - 数组的组件类型
      Parameters:
      array - 要从中删除元素的数组可能不是null
      values - 要删除的元素
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeAll

      public static byte[] removeAll(byte[] array, int... indices)
      从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素 
       ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
      Parameters:
      array - 要从中删除元素的数组可能不是null
      indices - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeElements

      public static byte[] removeElements(byte[] array, byte... values)
      从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同. 
       ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
      Parameters:
      array - 要从中删除元素的数组可能不是null
      values - 要删除的元素
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeAll

      public static short[] removeAll(short[] array, int... indices)
      从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素 
       ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
      Parameters:
      array - 要从中删除元素的数组可能不是null
      indices - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeElements

      public static short[] removeElements(short[] array, short... values)
      从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同. 
       ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
      Parameters:
      array - 要从中删除元素的数组可能不是null
      values - 要删除的元素
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeAll

      public static int[] removeAll(int[] array, int... indices)
      从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素 
       ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
      Parameters:
      array - 要从中删除元素的数组可能不是null
      indices - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeElements

      public static int[] removeElements(int[] array, int... values)
      从指定数组中移除指定数量*的指定元素。所有后续元素都左移. 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同 
       ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
      Parameters:
      array - 要从中删除元素的数组可能不是null
      values - 要删除的元素
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeAll

      public static char[] removeAll(char[] array, int... indices)
      从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素 
       ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
      Parameters:
      array - 要从中删除元素的数组可能不是null
      indices - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeElements

      public static char[] removeElements(char[] array, char... values)
      从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同. 
       ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
      Parameters:
      array - 要从中删除元素的数组可能不是null
      values - 要删除的元素
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeAll

      public static long[] removeAll(long[] array, int... indices)
      从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素 
       ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
      Parameters:
      array - 要从中删除元素的数组可能不是null
      indices - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeElements

      public static long[] removeElements(long[] array, long... values)
      从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同 
       ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
      Parameters:
      array - 要从中删除元素的数组可能不是null
      values - 要删除的元素
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeAll

      public static float[] removeAll(float[] array, int... indices)
      从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素 
       ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
      Parameters:
      array - 要从中删除元素的数组可能不是null
      indices - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeElements

      public static float[] removeElements(float[] array, float... values)
      从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同 
       ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
      Parameters:
      array - 要从中删除元素的数组可能不是null
      values - 要删除的元素
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeAll

      public static double[] removeAll(double[] array, int... indices)
      从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素 
       ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
      Parameters:
      array - 要从中删除元素的数组可能不是null
      indices - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeElements

      public static double[] removeElements(double[] array, double... values)
      从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同. 
       ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
      Parameters:
      array - 要从中删除元素的数组可能不是null
      values - 要删除的元素
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • removeAll

      public static boolean[] removeAll(boolean[] array, int... indices)
      从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组，该数组具有与输入数组相同的元素 
       ArrayKit.removeAll([true, false, true], 0, 2) = [false]
 ArrayKit.removeAll([true, false, true], 1, 2) = [true]
      Parameters:
      array - 要从中删除元素的数组可能不是null
      indices - 要删除的元素的位置
      Returns:
      一个新数组，包含指定位置之外的现有元素

    • removeElements

      public static boolean[] removeElements(boolean[] array, boolean... values)
      从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素，其数量大于原始数组中包含的数量， 除了删除现有的匹配项外，不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同. 
       ArrayKit.removeElements(null, true, false)               = null
 ArrayKit.removeElements([], true, false)                 = []
 ArrayKit.removeElements([true], false, false)            = [true]
 ArrayKit.removeElements([true, false], true, true)       = [false]
 ArrayKit.removeElements([true, false, true], true)       = [false, true]
 ArrayKit.removeElements([true, false, true], true, true) = [false]
      Parameters:
      array - 要从中删除元素的数组可能不是null
      values - 要删除的元素
      Returns:
      一个新数组，包含指定位置之外的现有元素.

    • isSorted

      public static <T extends Comparable<? super T>> boolean isSorted(T[] array)
      该方法检查提供的数组是否按照类的compareTo方法排序.
      Type Parameters:
      T - 要检查数组的数据类型，必须实现Comparable
      Parameters:
      array - 要检查的数组
      Returns:
      数组是否已排序

    • isSorted

      public static <T> boolean isSorted(T[] array, Comparator<T> comparator)
      该方法检查提供的数组是否按照提供的Comparator排序.
      Type Parameters:
      T - 数组的数据类型
      Parameters:
      array - 要检查的数组
      comparator - 要比较的Comparator
      Returns:
      数组是否已排序

    • isSorted

      public static boolean isSorted(int[] array)
      该方法检查提供的数组是否按照提供的Comparator排序.
      Parameters:
      array - 要检查的数组
      Returns:
      数组是否已排序

    • isSorted

      public static boolean isSorted(long[] array)
      该方法检查提供的数组是否按照提供的Comparator排序.
      Parameters:
      array - 要检查的数组
      Returns:
      数组是否已排序

    • isSorted

      public static boolean isSorted(short[] array)
      该方法检查提供的数组是否按照提供的Comparator排序.
      Parameters:
      array - 要检查的数组
      Returns:
      数组是否已排序

    • isSorted

      public static boolean isSorted(double[] array)
      该方法检查提供的数组是否按照提供的Comparator排序.
      Parameters:
      array - 要检查的数组
      Returns:
      数组是否已排序

    • isSorted

      public static boolean isSorted(float[] array)
      该方法检查提供的数组是否按照提供的Comparator排序.
      Parameters:
      array - 要检查的数组
      Returns:
      数组是否已排序

    • isSorted

      public static boolean isSorted(byte[] array)
      该方法检查提供的数组是否按照提供的Comparator排序.
      Parameters:
      array - 要检查的数组
      Returns:
      数组是否已排序

    • isSorted

      public static boolean isSorted(char[] array)
      该方法检查提供的数组是否按照提供的Comparator排序.
      Parameters:
      array - 要检查的数组
      Returns:
      数组是否已排序

    • isSorted

      public static boolean isSorted(boolean[] array)
      该方法检查提供的数组是否按照提供的Comparator排序.
      Parameters:
      array - 要检查的数组
      Returns:
      数组是否已排序

    • removeAllOccurences

      public static boolean[] removeAllOccurences(boolean[] array, boolean element)
      从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
      Parameters:
      element - 要删除的元素
      array - 输入数组
      Returns:
      一个新数组，包含除指定元素之外的现有元素.

    • removeAllOccurences

      public static char[] removeAllOccurences(char[] array, char element)
      从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
      Parameters:
      element - 要删除的元素
      array - 输入数组
      Returns:
      一个新数组，包含除指定元素之外的现有元素.

    • removeAllOccurences

      public static byte[] removeAllOccurences(byte[] array, byte element)
      从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
      Parameters:
      element - 要删除的元素
      array - 输入数组
      Returns:
      一个新数组，包含除指定元素之外的现有元素.

    • removeAllOccurences

      public static short[] removeAllOccurences(short[] array, short element)
      从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
      Parameters:
      element - 要删除的元素
      array - 输入数组
      Returns:
      一个新数组，包含除指定元素之外的现有元素.

    • removeAllOccurences

      public static int[] removeAllOccurences(int[] array, int element)
      从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
      Parameters:
      element - 要删除的元素
      array - 输入数组
      Returns:
      一个新数组，包含除指定元素之外的现有元素.

    • removeAllOccurences

      public static long[] removeAllOccurences(long[] array, long element)
      从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
      Parameters:
      element - 要删除的元素
      array - 输入数组
      Returns:
      一个新数组，包含除指定元素之外的现有元素.

    • removeAllOccurences

      public static float[] removeAllOccurences(float[] array, float element)
      从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
      Parameters:
      element - 要删除的元素
      array - 输入数组
      Returns:
      一个新数组，包含除指定元素之外的现有元素.

    • removeAllOccurences

      public static double[] removeAllOccurences(double[] array, double element)
      从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
      Parameters:
      element - 要删除的元素
      array - 输入数组
      Returns:
      一个新数组，包含除指定元素之外的现有元素.

    • removeAllOccurences

      public static <T> T[] removeAllOccurences(T[] array, T element)
      从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
      Type Parameters:
      T - 对象
      Parameters:
      element - 要删除的元素
      array - 输入数组
      Returns:
      一个新数组，包含除指定元素之外的现有元素.

    • toStringArray

      public static String[] toStringArray(Object[] array)
      返回一个数组，该数组包含参数数组中每个元素的字符串表示形式. 该方法为一个null输入数组返回null.
      Parameters:
      array - 要处理的Object[] 可以为null
      Returns:
      String[]的大小与其元素的字符串表示形式相同，null如果是空数组输入

    • toStringArray

      public static String[] toStringArray(Object[] array, String valueForNullElements)
      返回一个数组，该数组包含处理null元素的参数数组中每个元素的字符串表示形式 该方法为一个null输入数组返回null
      Parameters:
      array - 要处理的Object[] 可以为null
      valueForNullElements - 找到null 时要插入的值
      Returns:
      (@ code String)阵列，如果没有阵列输入

    • insert

      public static <T> T[] insert(T[] buffer, int index, T... newElements)
      将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
      Type Parameters:
      T - 数组元素类型
      Parameters:
      buffer - 已有数组
      index - 插入位置，此位置为对应此位置元素之前的空档
      newElements - 新元素
      Returns:
      新数组

    • insert

      public static <T> Object insert(Object array, int index, T... newElements)
      将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 已有数组
      index - 插入位置，此位置为对应此位置元素之前的空档
      newElements - 新元素
      Returns:
      新数组

    • insert

      public static boolean[] insert(int index, boolean[] array, boolean... values)
      将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组 
       ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
      Parameters:
      index - 插入位置,此位置为对应此位置元素之前的空档
      array - 已有数组
      values - 要插入的新值可以是null
      Returns:
      新数组.

    • insert

      public static byte[] insert(int index, byte[] array, byte... values)
      将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组 
       ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
      Parameters:
      index - 插入位置,此位置为对应此位置元素之前的空档
      array - 已有数组
      values - 要插入的新值可以是null
      Returns:
      新数组.

    • insert

      public static char[] insert(int index, char[] array, char... values)
      将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组 
       ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
      Parameters:
      index - 插入位置,此位置为对应此位置元素之前的空档
      array - 已有数组
      values - 要插入的新值可以是null
      Returns:
      新数组.

    • insert

      public static double[] insert(int index, double[] array, double... values)
      将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组 
       ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
      Parameters:
      index - 插入位置,此位置为对应此位置元素之前的空档
      array - 已有数组
      values - 要插入的新值可以是null
      Returns:
      新数组.

    • insert

      public static float[] insert(int index, float[] array, float... values)
      将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组 
       ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
      Parameters:
      index - 插入位置,此位置为对应此位置元素之前的空档
      array - 已有数组
      values - 要插入的新值可以是null
      Returns:
      新数组.

    • insert

      public static int[] insert(int index, int[] array, int... values)
      将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组 
       ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
      Parameters:
      index - 插入位置,此位置为对应此位置元素之前的空档
      array - 已有数组
      values - 要插入的新值可以是null
      Returns:
      新数组.

    • insert

      public static long[] insert(int index, long[] array, long... values)
      将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组 
       ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
      Parameters:
      index - 插入位置,此位置为对应此位置元素之前的空档
      array - 已有数组
      values - 要插入的新值可以是null
      Returns:
      新数组.

    • insert

      public static short[] insert(int index, short[] array, short... values)
      将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组 
       ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
      Parameters:
      index - 插入位置,此位置为对应此位置元素之前的空档
      array - 已有数组
      values - 要插入的新值可以是null
      Returns:
      新数组.

    • insert

      public static <T> T[] insert(int index, T[] array, T... values)
      将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组 
       ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
      Type Parameters:
      T - 对象
      Parameters:
      index - 插入位置,此位置为对应此位置元素之前的空档
      array - 已有数组
      values - 要插入的新值可以是null
      Returns:
      新数组.

    • shuffle

      public static void shuffle(Object[] array)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组

    • shuffle

      public static void shuffle(Object[] array, Random random)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组
      random - 用于排列元素的随机性的来源

    • shuffle

      public static void shuffle(boolean[] array)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组

    • shuffle

      public static void shuffle(boolean[] array, Random random)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组
      random - 用于排列元素的随机性的来源

    • shuffle

      public static void shuffle(byte[] array)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组

    • shuffle

      public static void shuffle(byte[] array, Random random)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组
      random - 用于排列元素的随机性的来源

    • shuffle

      public static void shuffle(char[] array)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组

    • shuffle

      public static void shuffle(char[] array, Random random)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组
      random - 用于排列元素的随机性的来源

    • shuffle

      public static void shuffle(short[] array)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组

    • shuffle

      public static void shuffle(short[] array, Random random)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组
      random - 用于排列元素的随机性的来源

    • shuffle

      public static void shuffle(int[] array)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组

    • shuffle

      public static void shuffle(int[] array, Random random)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组
      random - 用于排列元素的随机性的来源

    • shuffle

      public static void shuffle(long[] array)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组

    • shuffle

      public static void shuffle(long[] array, Random random)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组
      random - 用于排列元素的随机性的来源

    • shuffle

      public static void shuffle(float[] array)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组

    • shuffle

      public static void shuffle(float[] array, Random random)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组
      random - 用于排列元素的随机性的来源

    • shuffle

      public static void shuffle(double[] array)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组

    • shuffle

      public static void shuffle(double[] array, Random random)
      使用Fisher-Yates算法随机遍历指定数组的元素.
      Parameters:
      array - 要洗牌的数组
      random - 用于排列元素的随机性的来源

    • newArray

      public static <T> T[] newArray(Class<?> componentType, int newSize)
      新建一个空数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      componentType - 元素类型
      newSize - 大小
      Returns:
      空数组

    • newArray

      public static <T> T[] newArray(int newSize)
      新建一个空数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      newSize - 大小
      Returns:
      空数组

    • newArray

      public static Object[] newArray(Class<?> type, Object arrayObj)
      强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组
      Parameters:
      type - 数组类型或数组元素类型
      arrayObj - 原数组
      Returns:
      转换后的数组类型
      Throws:
      NullPointerException - 提供参数为空
      IllegalArgumentException - 参数arrayObj不是数组

    • getComponentType

      public static Class<?> getComponentType(Object array)
      获取数组对象的元素类型
      Parameters:
      array - 数组对象
      Returns:
      元素类型

    • getComponentType

      public static Class<?> getComponentType(Class<?> arrayClass)
      获取数组对象的元素类型
      Parameters:
      arrayClass - 数组类
      Returns:
      元素类型

    • getArrayType

      public static Class<?> getArrayType(Class<?> componentType)
      根据数组元素类型,获取数组的类型 方法是通过创建一个空数组从而获取其类型
      Parameters:
      componentType - 数组元素类型
      Returns:
      数组类型

    • append

      public static <T> T[] append(T[] buffer, T... newElements)
      将新元素添加到已有数组中 添加新元素会生成一个新的数组，不影响原数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      buffer - 已有数组
      newElements - 新元素
      Returns:
      新数组

    • append

      public static <T> Object append(Object array, T... newElements)
      将新元素添加到已有数组中 添加新元素会生成一个新的数组，不影响原数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 已有数组
      newElements - 新元素
      Returns:
      新数组

    • setOrAppend

      public static <T> T[] setOrAppend(T[] buffer, int index, T value)
      将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加
      Type Parameters:
      T - 数组元素类型
      Parameters:
      buffer - 已有数组
      index - 位置,大于长度追加,否则替换
      value - 新值
      Returns:
      新数组或原有数组

    • setOrAppend

      public static Object setOrAppend(Object array, int index, Object value)
      将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加
      Parameters:
      array - 已有数组
      index - 位置,大于长度追加,否则替换
      value - 新值
      Returns:
      新数组或原有数组

    • replace

      public static <T> T[] replace(T[] buffer, int index, T... values)
      将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新数组或原有数组 如果插入位置为为负数，那么生成一个由插入元素顺序加已有数组顺序的新数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      buffer - 已有数组
      index - 位置，大于长度追加，否则替换，<0表示从头部追加
      values - 新值
      Returns:
      新数组或原有数组

    • resize

      public static <T> T[] resize(T[] buffer, int newSize, Class<?> componentType)
      生成一个新的重新设置大小的数组 调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,缩小则截断
      Type Parameters:
      T - 数组元素类型
      Parameters:
      buffer - 原数组
      newSize - 新的数组大小
      componentType - 数组元素类型
      Returns:
      调整后的新数组

    • resize

      public static <T> T[] resize(T[] buffer, int newSize)
      生成一个新的重新设置大小的数组 新数组的类型为原数组的类型,调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,缩小则截断
      Type Parameters:
      T - 数组元素类型
      Parameters:
      buffer - 原数组
      newSize - 新的数组大小
      Returns:
      调整后的新数组

    • resize

      public static byte[] resize(byte[] bytes, int newSize)
      生成一个新的重新设置大小的数组 调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,其它位置补充0,缩小则截断
      Parameters:
      bytes - 原数组
      newSize - 新的数组大小
      Returns:
      调整后的新数组

    • copy

      public static Object copy(Object src, int srcPos, Object dest, int destPos, int length)
      包装 System.arraycopy(Object, int, Object, int, int) 数组复制
      Parameters:
      src - 源数组
      srcPos - 源数组开始位置
      dest - 目标数组
      destPos - 目标数组开始位置
      length - 拷贝数组长度
      Returns:
      目标数组

    • copy

      public static Object copy(Object src, Object dest, int length)
      包装 System.arraycopy(Object, int, Object, int, int) 数组复制,缘数组和目标数组都是从位置0开始复制
      Parameters:
      src - 源数组
      dest - 目标数组
      length - 拷贝数组长度
      Returns:
      目标数组

    • range

      public static int[] range(int excludedEnd)
      生成一个从0开始的数字列表
      Parameters:
      excludedEnd - 结束的数字(不包含)
      Returns:
      数字列表

    • range

      public static int[] range(int includedStart, int excludedEnd)
      生成一个数字列表 自动判定正序反序
      Parameters:
      includedStart - 开始的数字(包含)
      excludedEnd - 结束的数字(不包含)
      Returns:
      数字列表

    • range

      public static int[] range(int includedStart, int excludedEnd, int step)
      生成一个数字列表 自动判定正序反序
      Parameters:
      includedStart - 开始的数字(包含)
      excludedEnd - 结束的数字(不包含)
      step - 步进
      Returns:
      数字列表

    • unWrap

      public static int[] unWrap(Integer... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Long[] wrap(long... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static long[] unWrap(Long... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Character[] wrap(char... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static char[] unWrap(Character... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Byte[] wrap(byte... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static byte[] unWrap(Byte... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Short[] wrap(short... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static short[] unWrap(Short... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Float[] wrap(float... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static float[] unWrap(Float... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Double[] wrap(double... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static double[] unWrap(Double... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Boolean[] wrap(boolean... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static boolean[] unWrap(Boolean... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Object[] wrap(Object object)
      包装数组对象
      Parameters:
      object - 对象,可以是对象数组或者基本类型数组
      Returns:
      包装类型数组或对象数组
      Throws:
      InstrumentException - 对象为非数组

    • get

      public static <T> T get(Object array, int index)
      获取数组对象中指定index的值,支持负数,例如-1表示倒数第一个值
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组对象
      index - 下标,支持负数
      Returns:
      值

    • get

      public static <T> T[] get(Object array, int... indexes)
      获取数组中指定多个下标元素值,组成新数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      indexes - 下标列表
      Returns:
      结果

    • sub

      public static <T> T[] sub(T[] array, int start, int end)
      获取子数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      Returns:
      新的数组
      See Also:

    • sub

      public static byte[] sub(byte[] array, int start, int end)
      获取子数组
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      Returns:
      新的数组
      See Also:

    • sub

      public static int[] sub(int[] array, int start, int end)
      获取子数组
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      Returns:
      新的数组
      See Also:

    • sub

      public static long[] sub(long[] array, int start, int end)
      获取子数组
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      Returns:
      新的数组
      See Also:

    • sub

      public static short[] sub(short[] array, int start, int end)
      获取子数组
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      Returns:
      新的数组
      See Also:

    • sub

      public static char[] sub(char[] array, int start, int end)
      获取子数组
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      Returns:
      新的数组
      See Also:

    • sub

      public static double[] sub(double[] array, int start, int end)
      获取子数组
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      Returns:
      新的数组
      See Also:

    • sub

      public static float[] sub(float[] array, int start, int end)
      获取子数组
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      Returns:
      新的数组
      See Also:

    • sub

      public static boolean[] sub(boolean[] array, int start, int end)
      获取子数组
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      Returns:
      新的数组
      See Also:

    • sub

      public static Object[] sub(Object array, int start, int end)
      获取子数组
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      Returns:
      新的数组

    • sub

      public static Object[] sub(Object array, int start, int end, int step)
      获取子数组
      Parameters:
      array - 数组
      start - 开始位置(包括)
      end - 结束位置(不包括)
      step - 步进
      Returns:
      新的数组

    • join

      public static String join(CharSequence conjunction, Object... args)
      以 conjunction 为分隔符将多个对象转换为字符串
      Parameters:
      conjunction - 分隔符 Symbol.COMMA
      args - 数组
      Returns:
      连接后的字符串

    • join

      public static <T> String join(T[] array, CharSequence conjunction)
      以 conjunction 为分隔符将数组转换为字符串
      Type Parameters:
      T - 被处理的集合
      Parameters:
      array - 数组
      conjunction - 分隔符
      Returns:
      连接后的字符串

    • join

      public static <T> String join(T[] array, CharSequence delimiter, String prefix, String suffix)
      以 conjunction 为分隔符将数组转换为字符串
      Type Parameters:
      T - 被处理的集合
      Parameters:
      array - 数组
      delimiter - 分隔符
      prefix - 每个元素添加的前缀，null表示不添加
      suffix - 每个元素添加的后缀，null表示不添加
      Returns:
      连接后的字符串

    • join

      public static <T> String join(T[] array, CharSequence conjunction, Editor<T> editor)
      以 conjunction 为分隔符将数组转换为字符串
      Type Parameters:
      T - 被处理的集合
      Parameters:
      array - 数组
      conjunction - 分隔符
      editor - 每个元素的编辑器，null表示不编辑
      Returns:
      连接后的字符串

    • min

      public static <T extends Comparable<? super T>> T min(T[] numberArray)
      取最小值
      Type Parameters:
      T - 元素类型
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static long min(long... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static int min(int... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static short min(short... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static char min(char... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static byte min(byte... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static double min(double... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static float min(float... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • max

      public static <T extends Comparable<? super T>> T max(T[] numberArray)
      取最大值
      Type Parameters:
      T - 元素类型
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static long max(long... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static int max(int... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static short max(short... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static char max(char... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static byte max(byte... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static double max(double... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static float max(float... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static <T extends Comparable<? super T>> T max(T[] numberArray, Comparator<T> comparator)
      取最大值
      Type Parameters:
      T - 元素类型
      Parameters:
      numberArray - 数字数组
      comparator - 比较器，null表示默认比较器
      Returns:
      最大值

    • filter

      public static <T> T[] filter(T[] array, Editor<T> editor)
      过滤 过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能： 
       1、过滤出需要的对象,如果返回null表示这个元素对象抛弃
 2、修改元素对象,返回集合中为修改后的对象
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      editor - 编辑器接口
      Returns:
      过滤后的数组

    • filter

      public static <T> T[] filter(T[] array, Filter<T> filter)
      过滤 过滤过程通过传入的Filter实现来过滤返回需要的元素内容,这个Editor实现可以实现以下功能：
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      filter - 过滤器接口,用于定义过滤规则
      Returns:
      过滤后的数组

    • zip

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

    • zip

      public static <K, V> Map<K,V> zip(K[] keys, V[] values, boolean isOrder)
      映射键值(参考Python的zip()函数) 例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分
      Type Parameters:
      K - Key类型
      V - Value类型
      Parameters:
      keys - 键列表
      values - 值列表
      isOrder - 是否有序
      Returns:
      Map

    • isSameType

      public static boolean isSameType(Object array1, Object array2)
      检查两个数组是否为同一类型
      Parameters:
      array1 - 第1个数组不能是null
      array2 - 第2个数组不能是null
      Returns:
      如果数组类型匹配，则为true
      Throws:
      IllegalArgumentException - 如果其中一个数组是null

    • indexOfIgnoreCase

      public static int indexOfIgnoreCase(CharSequence[] array, CharSequence value)
      返回数组中指定元素所在位置,忽略大小写,未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置, 未找到返回Normal.__1

    • isArrayIndexValid

      public static <T> boolean isArrayIndexValid(T[] array, int index)
      返回是否可以在给定索引处安全地访问给定数组
      Type Parameters:
      T - 数组的组件类型
      Parameters:
      array - 要检查的数组可能为空
      index - 要检查的数组的索引
      Returns:
      给定索引在给定数组中是否可安全访问

    • containsIgnoreCase

      public static boolean containsIgnoreCase(CharSequence[] array, CharSequence value)
      数组中是否包含元素,忽略大小写
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • containsAny

      public static <T> boolean containsAny(T[] array, T... values)
      数组中是否包含指定元素中的任意一个
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      values - 被检查的多个元素
      Returns:
      是否包含指定元素中的任意一个

    • containsAll

      public static <T> boolean containsAll(T[] array, T... values)
      数组中是否包含指定元素中的全部
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      values - 被检查的多个元素
      Returns:
      是否包含指定元素中的全部

    • getLength

      public static int getLength(Object array)
      返回指定数组的长度 
       ArrayKit.getLength(null)            = 0
 ArrayKit.getLength([])              = 0
 ArrayKit.getLength([null])          = 1
 ArrayKit.getLength([true, false])   = 2
 ArrayKit.getLength([1, 2, 3])       = 3
 ArrayKit.getLength(["a", "b", "c"]) = 3
      Parameters:
      array - 要从中检索长度的数组可以为空
      Returns:
      数组的长度，如果数组是null，则为0
      Throws:
      IllegalArgumentException - 如果对象参数不是数组

    • hashCode

      public static int hashCode(Object array)
      获得一个数组哈希码,用于正确处理多维数组 多维基元数组也可以用该方法正确处理
      Parameters:
      array - 数组
      Returns:
      返回数组的哈希码

    • cast

      public static Object[] cast(Class<?> type, Object arrayObj) throws NullPointerException, IllegalArgumentException
      强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组
      Parameters:
      type - 数组类型或数组元素类型
      arrayObj - 原数组
      Returns:
      转换后的数组类型
      Throws:
      NullPointerException - 提供参数为空
      IllegalArgumentException - 参数arrayObj不是数组

    • map

      public static <T, R> List<R> map(T[] array, Function<? super T,? extends R> func)
      按照指定规则，将一种类型的数组元素提取后转换为List
      Type Parameters:
      T - 原数组类型
      R - 目标数组类型
      Parameters:
      array - 被转换的数组
      func - 转换规则函数
      Returns:
      转换后的数组

    • map

      public static <T, R> R[] map(T[] array, Class<R> componentType, Function<? super T,? extends R> func)
      按照指定规则，将一种类型的数组转换为另一种类型
      Type Parameters:
      T - 原数组类型
      R - 目标数组类型
      Parameters:
      array - 被转换的数组
      componentType - 目标的元素类型
      func - 转换规则函数
      Returns:
      转换后的数组

    • map

      public static <T, R> R[] map(Object array, Class<R> targetComponentType, Function<? super T,? extends R> func)
      按照指定规则，将一种类型的数组转换为另一种类型
      Type Parameters:
      T - 原数组类型
      R - 目标数组类型
      Parameters:
      array - 被转换的数组
      targetComponentType - 目标的元素类型
      func - 转换规则函数
      Returns:
      转换后的数组

    • mapToSet

      public static <T, R> Set<R> mapToSet(T[] array, Function<? super T,? extends R> func)
      按照指定规则，将一种类型的数组元素提取后转换为Set
      Type Parameters:
      T - 原数组类型
      R - 目标数组类型
      Parameters:
      array - 被转换的数组
      func - 转换规则函数
      Returns:
      转换后的数组

    • equals

      public static boolean equals(Object array1, Object array2)
      判断两个数组是否相等，判断依据包括数组长度和每个元素都相等
      Parameters:
      array1 - 数组1
      array2 - 数组2
      Returns:
      是否相等

    • isSub

      public static <T> boolean isSub(T[] array, T[] subArray)
      查找子数组的位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      subArray - 子数组
      Returns:
      子数组的开始位置，即子数字第一个元素在数组中的位置

    • indexOfSub

      public static <T> int indexOfSub(T[] array, T[] subArray)
      查找子数组的位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      subArray - 子数组
      Returns:
      子数组的开始位置，即子数字第一个元素在数组中的位置

    • lastIndexOfSub

      public static <T> int lastIndexOfSub(T[] array, T[] subArray)
      查找最后一个子数组的开始位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      subArray - 子数组
      Returns:
      最后一个子数组的开始位置，即子数字第一个元素在数组中的位置

    • length

      public static int length(Object array) throws IllegalArgumentException
      获取数组长度 如果参数为null，返回0 
       ArrayKit.length(null)            = 0
 ArrayKit.length([])              = 0
 ArrayKit.length([null])          = 1
 ArrayKit.length([true, false])   = 2
 ArrayKit.length([1, 2, 3])       = 3
 ArrayKit.length(["a", "b", "c"]) = 3
      Parameters:
      array - 数组对象
      Returns:
      数组长度
      Throws:
      IllegalArgumentException - 如果参数不为数组，抛出此异常
      See Also: