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, Predicate<T> filter)	过滤 过滤过程通过传入的Filter实现来过滤返回需要的元素内容,这个Editor实现可以实现以下功能：
static <T> T[]	filter(T[] array, Editor<T> editor)	过滤 过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能：
static <T> int	firstNonAll(Predicate<T> matcher, int beginIndexInclude, T... array)	返回数组中第一个匹配规则的值的位置
static <T> int	firstNonAll(Predicate<T> matcher, T... array)	返回数组中第一个匹配规则的值的位置
static <T> T	firstNonNull(Predicate<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 <A, T> A	insert(A 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 extends Comparable<? super T>> T	min(T[] numberArray, Comparator<T> comparator)	取最小值
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)	从指定数组中移除指定位置的元素。
static byte[]	remove(byte[] array, int index)	从指定数组中移除指定位置的元素。
static char[]	remove(char[] array, int index)	从指定数组中移除指定位置的元素。
static double[]	remove(double[] array, int index)	从指定数组中移除指定位置的元素。
static float[]	remove(float[] array, int index)	从指定数组中移除指定位置的元素。
static int[]	remove(int[] array, int index)	从指定数组中移除指定位置的元素。
static long[]	remove(long[] array, int index)	从指定数组中移除指定位置的元素。
static short[]	remove(short[] array, int index)	从指定数组中移除指定位置的元素。
static <T> T[]	remove(T[] array)	去重数组中的元素，去重后生成新的数组，原数组不变 此方法通过LinkedHashSet 去重
static <T> T[]	remove(T[] array, int index)	从指定数组中移除指定位置的元素。
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)	从指定数组中移除指定位置的元素。
static byte[]	removeElement(byte[] array, byte element)	从指定数组中移除指定位置的元素。
static char[]	removeElement(char[] array, char element)	从指定数组中移除指定位置的元素。
static double[]	removeElement(double[] array, double element)	从指定数组中移除指定位置的元素。
static float[]	removeElement(float[] array, float element)	从指定数组中移除指定位置的元素。
static int[]	removeElement(int[] array, int element)	从指定数组中移除指定位置的元素。
static long[]	removeElement(long[] array, long element)	从指定数组中移除指定位置的元素。
static short[]	removeElement(short[] array, short element)	从指定数组中移除指定位置的元素。
static <T> T[]	removeElement(T[] array, Object element)	从指定数组中移除指定位置的元素。
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(Predicate<T> matcher,
 T... array)

返回数组中第一个匹配规则的值

Type Parameters:

T - 数组元素类型

Parameters:

matcher - 匹配接口，实现此接口自定义匹配规则

array - 数组

Returns:

匹配元素，如果不存在匹配元素或数组为空，返回null

firstNonAll

public static <T> int firstNonAll(Predicate<T> matcher,
 T... array)

返回数组中第一个匹配规则的值的位置

Type Parameters:

T - 数组元素类型

Parameters:

matcher - 匹配接口，实现此接口自定义匹配规则

array - 数组

Returns:

匹配到元素的位置，-1表示未匹配到

firstNonAll

public static <T> int firstNonAll(Predicate<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:

array - 输入数组

element - 要删除的元素

Returns:

一个新数组，包含除指定元素之外的现有元素.

removeAllOccurences

public static char[] removeAllOccurences(char[] array,
 char element)

从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null

Parameters:

array - 输入数组

element - 要删除的元素

Returns:

一个新数组，包含除指定元素之外的现有元素.

removeAllOccurences

public static byte[] removeAllOccurences(byte[] array,
 byte element)

从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null

Parameters:

array - 输入数组

element - 要删除的元素

Returns:

一个新数组，包含除指定元素之外的现有元素.

removeAllOccurences

public static short[] removeAllOccurences(short[] array,
 short element)

从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null

Parameters:

array - 输入数组

element - 要删除的元素

Returns:

一个新数组，包含除指定元素之外的现有元素.

removeAllOccurences

public static int[] removeAllOccurences(int[] array,
 int element)

从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null

Parameters:

array - 输入数组

element - 要删除的元素

Returns:

一个新数组，包含除指定元素之外的现有元素.

removeAllOccurences

public static long[] removeAllOccurences(long[] array,
 long element)

从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null

Parameters:

array - 输入数组

element - 要删除的元素

Returns:

一个新数组，包含除指定元素之外的现有元素.

removeAllOccurences

public static float[] removeAllOccurences(float[] array,
 float element)

从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null

Parameters:

array - 输入数组

element - 要删除的元素

Returns:

一个新数组，包含除指定元素之外的现有元素.

removeAllOccurences

public static double[] removeAllOccurences(double[] array,
 double element)

从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null

Parameters:

array - 输入数组

element - 要删除的元素

Returns:

一个新数组，包含除指定元素之外的现有元素.

removeAllOccurences

public static <T> T[] removeAllOccurences(T[] array,
 T element)

从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null

Type Parameters:

T - 对象

Parameters:

array - 输入数组

element - 要删除的元素

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 <A,
T> A insert(A array,
 int index,
 T... newElements)

将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充

Type Parameters:

A - 泛型对象

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:

InternalException - 对象为非数组

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:

• Arrays.copyOfRange(Object[], int, int)

sub

public static byte[] sub(byte[] array,
 int start,
 int end)

获取子数组

Parameters:

array - 数组

start - 开始位置(包括)

end - 结束位置(不包括)

Returns:

新的数组

See Also:

• Arrays.copyOfRange(Object[], int, int)

sub

public static int[] sub(int[] array,
 int start,
 int end)

获取子数组

Parameters:

array - 数组

start - 开始位置(包括)

end - 结束位置(不包括)

Returns:

新的数组

See Also:

• Arrays.copyOfRange(Object[], int, int)

sub

public static long[] sub(long[] array,
 int start,
 int end)

获取子数组

Parameters:

array - 数组

start - 开始位置(包括)

end - 结束位置(不包括)

Returns:

新的数组

See Also:

• Arrays.copyOfRange(Object[], int, int)

sub

public static short[] sub(short[] array,
 int start,
 int end)

获取子数组

Parameters:

array - 数组

start - 开始位置(包括)

end - 结束位置(不包括)

Returns:

新的数组

See Also:

• Arrays.copyOfRange(Object[], int, int)

sub

public static char[] sub(char[] array,
 int start,
 int end)

获取子数组

Parameters:

array - 数组

start - 开始位置(包括)

end - 结束位置(不包括)

Returns:

新的数组

See Also:

• Arrays.copyOfRange(Object[], int, int)

sub

public static double[] sub(double[] array,
 int start,
 int end)

获取子数组

Parameters:

array - 数组

start - 开始位置(包括)

end - 结束位置(不包括)

Returns:

新的数组

See Also:

• Arrays.copyOfRange(Object[], int, int)

sub

public static float[] sub(float[] array,
 int start,
 int end)

获取子数组

Parameters:

array - 数组

start - 开始位置(包括)

end - 结束位置(不包括)

Returns:

新的数组

See Also:

• Arrays.copyOfRange(Object[], int, int)

sub

public static boolean[] sub(boolean[] array,
 int start,
 int end)

获取子数组

Parameters:

array - 数组

start - 开始位置(包括)

end - 结束位置(不包括)

Returns:

新的数组

See Also:

• Arrays.copyOfRange(Object[], int, int)

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 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:

最小值

min

public static <T extends Comparable<? super T>> T min(T[] numberArray)

取最小值

Type Parameters:

T - 元素类型

Parameters:

numberArray - 数字数组

Returns:

最小值

min

public static <T extends Comparable<? super T>> T min(T[] numberArray,
 Comparator<T> comparator)

取最小值

Type Parameters:

T - 元素类型

Parameters:

numberArray - 数字数组

comparator - 比较器，null按照默认比较

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)

取最大值

Type Parameters:

T - 元素类型

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,
 Predicate<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:

• Array.getLength(Object)