Package org.miaixz.bus.core.xyz

Class ArrayKit

java.lang.Object

org.miaixz.bus.core.center.array.ArrayValidator

org.miaixz.bus.core.center.array.PrimitiveArray

org.miaixz.bus.core.xyz.ArrayKit

public class ArrayKit
extends PrimitiveArray

数组工具类

Since:

Java 17+

Author:

Kimi Liu

Constructor Summary

Constructors

Constructor	Description
ArrayKit()

Method Summary

Modifier and Type	Method	Description
static <T> T[]	addAll(T[]... arrays)	合并所有数组，返回合并后的新数组 忽略null的数组
static <A, T> A	append(A array, T... newElements)	将新元素添加到已有数组中 添加新元素会生成一个新的数组，不影响原数组
static <T> T[]	append(T[] buffer, T... newElements)	将新元素添加到已有数组中 添加新元素会生成一个新的数组，不影响原数组
static boolean	arrayEquals(Object o1, Object o2)	比较给定的数组和Arrays.equals，根据数组元素而不是数组引用执行相等性检查
static Object[]	cast(Class<?> type, Object arrayObj)	强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组
static <A> A	castOrWrapSingle(Object values, Class<?> elementType)	转为数组，如果values为数组，返回，否则返回一个只有values一个元素的数组 注意：values的元素类型或其本身类型必须和提供的elementType完全一致
static <T> T	clone(T object)	克隆数组，如果非数组返回null
static <T> T[]	clone(T[] array)	克隆数组
static <T> boolean	contains(T[] array, T 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 <T> T	copy(Object src, int srcPos, T dest, int destPos, int length)	包装 System.arraycopy(Object, int, Object, int, int) 数组复制
static <T> T	copy(Object src, T dest)	包装 System.arraycopy(Object, int, Object, int, int) 数组复制，源数组和目标数组都是从位置0开始复制，复制长度为源数组的长度
static <T> T	copy(Object src, T dest, int length)	包装 System.arraycopy(Object, int, Object, int, int) 数组复制，源数组和目标数组都是从位置0开始复制
static <T> T[]	distinct(T[] array)	去重数组中的元素，去重后生成新的数组，原数组不变 此方法通过LinkedHashSet 去重
static <T, K> T[]	distinct(T[] array, Function<T,K> uniqueGenerator, boolean override)	去重数组中的元素，去重后生成新的数组，原数组不变 此方法通过LinkedHashSet 去重
static <T> T[]	edit(T[] array, UnaryOperator<T> editor)	对每个数组元素执行指定操作，返回操作后的元素 这个Editor实现可以实现以下功能： 过滤出需要的对象，如果返回null则抛弃这个元素对象 修改元素对象，返回修改后的对象
static boolean	equals(Object array1, Object array2)	判断两个数组是否相等，判断依据包括数组长度和每个元素都相等。
static <T> T[]	filter(T[] array, Predicate<T> predicate)	过滤数组元素 保留 Predicate.test(Object)为true的元素
static <E> E	get(E[] array, Predicate<E> predicate)	获取满足条件的第一个元素
static <E> E	get(Object array, int index)	获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值 如果数组下标越界，返回null
static <T> T[]	getAny(Object array, int... indexes)	获取数组中所有指定位置的元素值，组成新数组
static Class<?>	getArrayType(Class<?> componentType)	根据数组元素类型，获取数组的类型 方法是通过创建一个空数组从而获取其类型
static Class<?>	getComponentType(Class<?> arrayClass)	获取数组对象的元素类型，方法调用参数与返回结果举例： Object[].class = Object.class String[].class = String.class int[].class = int.class Integer[].class = Integer.class null = null String.class = null
static Class<?>	getComponentType(Object array)	获取数组对象的元素类型，方法调用参数与返回结果举例： Object[] = Object.class String[] = String.class int[] = int.class Integer[] = Integer.class null = null String = null
static <T> Boolean	hasSameElement(T[] array)	判断数组中是否有相同元素
static <A, E> A	insert(A array, int index, E... newElements)	将新元素插入到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用默认值填充
static <T> T[]	insert(T[] buffer, int index, T... newElements)	将新元素插入到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
static String	join(Object array, CharSequence conjunction)	以 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, UnaryOperator<T> editor)	先处理数组元素，再以 conjunction 为分隔符将数组转换为字符串
static <T> int	lastIndexOfSub(T[] array, int endInclude, T[] subArray)	查找最后一个子数组的开始位置
static <T> int	lastIndexOfSub(T[] array, T[] subArray)	查找最后一个子数组的开始位置
static <T, R> R[]	map(Object array, Class<R> targetComponentType, Function<? super T,? extends R> func)	按照指定规则，将一种类型的数组转换为另一种类型
static <T, R> R[]	mapToArray(T[] array, Function<? super T,? extends R> func, IntFunction<R[]> generator)	按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为 Set
static <T, R> List<R>	mapToList(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 <T extends Comparable<? super T>> T	max(T[] numberArray)	取最大值
static <T extends Comparable<? super T>> T	max(T[] numberArray, Comparator<T> comparator)	取最大值
static <T extends Comparable<? super T>> T	min(T[] numberArray)	取最小值
static <T extends Comparable<? super T>> T	min(T[] numberArray, Comparator<T> comparator)	取最小值
static Object[]	newArray(int newSize)	新建一个Object类型空数组
static <T> T[]	newArray(Class<?> componentType, int newSize)	新建一个空数组
static String[]	nullToEmpty(String[] array)	数组元素中的null转换为""
static <T> T[]	ofArray(Iterable<T> iterable, Class<T> componentType)	将集合转为数组，如果集合为null，则返回空的数组（元素个数为0）
static <T> T[]	remove(T[] array, int index)	移除数组中对应位置的元素 copier from commons-lang
static <T extends CharSequence> T[]	removeBlank(T[] array)	去除null或者""或者空白字符串 元素
static <T> T[]	removeEle(T[] array, T element)	移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
static <T extends CharSequence> T[]	removeEmpty(T[] array)	去除null或者"" 元素
static <T> T[]	removeNull(T[] array)	去除 null 元素
static <A> A	replace(A array, int index, A values)	从数组中的指定位置开始，按顺序使用新元素替换旧元素 如果 指定位置 为负数，那么生成一个新数组，其中新元素按顺序放在数组头部 如果 指定位置 大于等于 旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部 如果 指定位置 加上 新元素数量 大于 旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素 否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组
static <T> T[]	replace(T[] array, int index, T... values)	从数组中的指定位置开始，按顺序使用新元素替换旧元素 如果 指定位置 为负数，那么生成一个新数组，其中新元素按顺序放在数组头部 如果 指定位置 大于等于 旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部 如果 指定位置 加上 新元素数量 大于 旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素 否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组
static Object	resize(Object array, int newSize)	生成一个新的重新设置大小的数组 调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断
static <T> T[]	resize(T[] buffer, int newSize)	生成一个新的重新设置大小的数组 调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断原数组
static <T> T[]	resize(T[] data, int newSize, Class<?> componentType)	生成一个新的重新设置大小的数组 调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断
static <T> T[]	reverse(T[] array)	反转数组，会变更原数组
static <T> T[]	reverse(T[] array, int startIndexInclusive, int endIndexExclusive)	反转数组，会变更原数组
static <A> A	setOrAppend(A array, int index, Object value)	将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
static <T> T[]	setOrAppend(T[] array, int index, T value)	将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
static <A, E> A	setOrPadding(A array, int index, E value, E paddingValue)	将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加paddingValue直到到达index后，设置值
static <A> A	setOrPadding(A array, int index, Object value)	将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加null或0直到到达index后，设置值
static <T> T[]	shuffle(T[] array)	打乱数组顺序，会变更原数组 使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序
static <T> T[]	shuffle(T[] array, Random random)	打乱数组顺序，会变更原数组 使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序
static <T> boolean	startWith(T[] array, T[] prefix)	array数组是否以prefix开头，每个元素的匹配使用ObjectValidator.equals(Object, Object)匹配。
static <A> A	sub(A array, int beginInclude, int endExclude)	获取子数组
static <A> A	sub(A array, int beginInclude, int endExclude, int step)	获取子数组
static <T> T[]	sub(T[] array, int start, int end)	获取子数组
static Object	swap(Object array, int index1, int index2)	交换数组中两个位置的值
static <T> T[]	swap(T[] array, int index1, int index2)	交换数组中两个位置的值
static Object[]	wrap(Object object)	包装数组对象
static <A> A	wrapSingle(Object value, Class<?> elementType)	包装单一元素为数组
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 org.miaixz.bus.core.center.array.PrimitiveArray

addAll, addAll, addAll, addAll, addAll, addAll, addAll, addAll, contains, contains, contains, contains, contains, contains, contains, contains, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, max, max, max, max, max, max, max, min, min, min, min, min, min, min, remove, remove, remove, remove, remove, remove, remove, remove, remove, removeEle, removeEle, removeEle, removeEle, removeEle, removeEle, removeEle, removeEle, resize, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, split, startWith, startWith, startWith, startWith, startWith, startWith, startWith, startWith, sub, sub, sub, sub, sub, sub, sub, sub, swap, swap, swap, swap, swap, swap, swap, swap, unWrap, unWrap, unWrap, unWrap, unWrap, unWrap, unWrap, unWrap, wrap, wrap, wrap, wrap, wrap, wrap, wrap, wrap

Methods inherited from class org.miaixz.bus.core.center.array.ArrayValidator

defaultIfEmpty, emptyCount, firstMatch, firstNonNull, hasBlank, hasEmpty, hasEmptyVarargs, hasNonNull, hasNull, indexOf, indexOf, indexOfIgnoreCase, indexOfSub, indexOfSub, isAllBlank, isAllEmpty, isAllEmptyVarargs, isAllNotBlank, isAllNotEmpty, isAllNotNull, isAllNull, isArray, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isSorted, isSorted, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSub, isSubEquals, lastIndexOf, lastIndexOf, length, matchIndex, matchIndex, regionMatches, toString

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

castOrWrapSingle

public static <A> A castOrWrapSingle(Object values,
 Class<?> elementType)

转为数组，如果values为数组，返回，否则返回一个只有values一个元素的数组 注意：values的元素类型或其本身类型必须和提供的elementType完全一致

Type Parameters:

A - 数组类型

Parameters:

values - 元素值

elementType - 数组元素类型，null表示使用values的类型

Returns:

数组

wrapSingle

public static <A> A wrapSingle(Object value,
 Class<?> elementType)

包装单一元素为数组

Type Parameters:

A - 数组类型

Parameters:

value - 元素值

elementType - 数组元素类型，null表示使用value的类型

Returns:

数组

ofArray

public static <T> T[] ofArray(Iterable<T> iterable,
 Class<T> componentType)

将集合转为数组，如果集合为null，则返回空的数组（元素个数为0）

Type Parameters:

T - 数组元素类型

Parameters:

iterable - Iterable

componentType - 集合元素类型

Returns:

数组

newArray

public static <T> T[] newArray(Class<?> componentType,
 int newSize)

新建一个空数组

Type Parameters:

T - 数组元素类型

Parameters:

componentType - 元素类型，例如：Integer.class，但是不能使用原始类型，例如：int.class

newSize - 大小

Returns:

空数组

newArray

public static Object[] newArray(int newSize)

新建一个Object类型空数组

Parameters:

newSize - 大小

Returns:

Object类型的空数组

getComponentType

public static Class<?> getComponentType(Object array)

获取数组对象的元素类型，方法调用参数与返回结果举例：

• Object[] = Object.class
• String[] = String.class
• int[] = int.class
• Integer[] = Integer.class
• null = null
• String = null

Parameters:

array - 数组对象

Returns:

元素类型

getComponentType

public static Class<?> getComponentType(Class<?> arrayClass)

获取数组对象的元素类型，方法调用参数与返回结果举例：

• Object[].class = Object.class
• String[].class = String.class
• int[].class = int.class
• Integer[].class = Integer.class
• null = null
• String.class = null

Parameters:

arrayClass - 数组对象的class

Returns:

元素类型

getArrayType

public static Class<?> getArrayType(Class<?> componentType)

根据数组元素类型，获取数组的类型 方法是通过创建一个空数组从而获取其类型

本方法是 getComponentType(Class)的逆方法

Parameters:

componentType - 数组元素类型

Returns:

数组类型

cast

public static Object[] cast(Class<?> type,
 Object arrayObj)
                     throws NullPointerException,
IllegalArgumentException

强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组

Parameters:

type - 数组类型或数组元素类型

arrayObj - 原数组

Returns:

转换后的数组类型

Throws:

NullPointerException - 提供参数为空

IllegalArgumentException - 参数arrayObj不是数组

append

@SafeVarargs
public static <T> T[] append(T[] buffer,
 T... newElements)

将新元素添加到已有数组中 添加新元素会生成一个新的数组，不影响原数组

Type Parameters:

T - 数组元素类型

Parameters:

buffer - 已有数组

newElements - 新元素

Returns:

新数组

append

@SafeVarargs
public static <A,
T> A append(A array,
 T... newElements)

将新元素添加到已有数组中 添加新元素会生成一个新的数组，不影响原数组

Type Parameters:

A - 数组类型

T - 数组元素类型

Parameters:

array - 已有数组

newElements - 新元素

Returns:

新数组

setOrAppend

public static <T> T[] setOrAppend(T[] array,
 int index,
 T value)

将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加

Type Parameters:

T - 数组元素类型

Parameters:

array - 已有数组

index - 位置，大于等于长度则追加，否则替换

value - 新值

Returns:

新数组或原有数组

setOrAppend

public static <A> A setOrAppend(A array,
 int index,
 Object value)

将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加

Type Parameters:

A - 数组类型

Parameters:

array - 已有数组

index - 位置，大于等于长度则追加，否则替换

value - 新值

Returns:

新数组或原有数组

setOrPadding

public static <A> A setOrPadding(A array,
 int index,
 Object value)

将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加null或0直到到达index后，设置值

Type Parameters:

A - 数组类型

Parameters:

array - 已有数组

index - 位置，大于等于长度则追加，否则替换

value - 新值

Returns:

新数组或原有数组

setOrPadding

public static <A,
E> A setOrPadding(A array,
 int index,
 E value,
 E paddingValue)

将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加paddingValue直到到达index后，设置值

Type Parameters:

A - 数组类型

E - 元素类型

Parameters:

array - 已有数组

index - 位置，大于等于长度则追加，否则替换

value - 新值

paddingValue - 填充值

Returns:

新数组或原有数组

addAll

@SafeVarargs
public static <T> T[] addAll(T[]... arrays)

合并所有数组，返回合并后的新数组 忽略null的数组

Type Parameters:

T - 数组元素类型

Parameters:

arrays - 数组集合

Returns:

合并后的数组

replace

public static <T> T[] replace(T[] array,
 int index,
 T... values)

从数组中的指定位置开始，按顺序使用新元素替换旧元素

• 如果 指定位置 为负数，那么生成一个新数组，其中新元素按顺序放在数组头部
• 如果 指定位置 大于等于 旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部
• 如果 指定位置 加上 新元素数量 大于 旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素
• 否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组

Type Parameters:

T - 数组元素类型

Parameters:

array - 已有数组

index - 位置

values - 新值

Returns:

新数组或原有数组

replace

public static <A> A replace(A array,
 int index,
 A values)

从数组中的指定位置开始，按顺序使用新元素替换旧元素

• 如果 指定位置 为负数，那么生成一个新数组，其中新元素按顺序放在数组头部
• 如果 指定位置 大于等于 旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部
• 如果 指定位置 加上 新元素数量 大于 旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素
• 否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组

Type Parameters:

A - 数组类型

Parameters:

array - 已有数组

index - 位置

values - 新值

Returns:

新数组或原有数组

insert

public static <T> T[] insert(T[] buffer,
 int index,
 T... newElements)

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

Type Parameters:

T - 数组元素类型

Parameters:

buffer - 已有数组

index - 插入位置，此位置为对应此位置元素之前的空档

newElements - 新元素

Returns:

新数组

insert

@SafeVarargs
public static <A,
E> A insert(A array,
 int index,
 E... newElements)

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

Type Parameters:

A - 数组类型

E - 数组元素类型

Parameters:

array - 已有数组，可以为原始类型数组

index - 插入位置，此位置为对应此位置元素之前的空档

newElements - 新元素

Returns:

新数组

resize

public static <T> T[] resize(T[] data,
 int newSize,
 Class<?> componentType)

生成一个新的重新设置大小的数组 调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断

Type Parameters:

T - 数组元素类型

Parameters:

data - 原数组

newSize - 新的数组大小

componentType - 数组元素类型

Returns:

调整后的新数组

resize

public static Object resize(Object array,
 int newSize)

生成一个新的重新设置大小的数组 调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断

Parameters:

array - 原数组

newSize - 新的数组大小

Returns:

调整后的新数组

See Also:

• System.arraycopy(Object, int, Object, int, int)

resize

public static <T> T[] resize(T[] buffer,
 int newSize)

生成一个新的重新设置大小的数组 调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断原数组

Type Parameters:

T - 数组元素类型

Parameters:

buffer - 原数组

newSize - 新的数组大小

Returns:

调整后的新数组

copy

public static <T> T copy(Object src,
 T dest)

包装 System.arraycopy(Object, int, Object, int, int) 数组复制，源数组和目标数组都是从位置0开始复制，复制长度为源数组的长度

Type Parameters:

T - 目标数组类型

Parameters:

src - 源数组

dest - 目标数组

Returns:

目标数组

copy

public static <T> T copy(Object src,
 T dest,
 int length)

包装 System.arraycopy(Object, int, Object, int, int) 数组复制，源数组和目标数组都是从位置0开始复制

Type Parameters:

T - 目标数组类型

Parameters:

src - 源数组

dest - 目标数组

length - 拷贝数组长度

Returns:

目标数组

copy

public static <T> T copy(Object src,
 int srcPos,
 T dest,
 int destPos,
 int length)

包装 System.arraycopy(Object, int, Object, int, int) 数组复制

Type Parameters:

T - 目标数组类型

Parameters:

src - 源数组

srcPos - 源数组开始位置

dest - 目标数组

destPos - 目标数组开始位置

length - 拷贝数组长度

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:

克隆后的数组对象

edit

public static <T> T[] edit(T[] array,
 UnaryOperator<T> editor)

对每个数组元素执行指定操作，返回操作后的元素 这个Editor实现可以实现以下功能：

1. 过滤出需要的对象，如果返回null则抛弃这个元素对象
2. 修改元素对象，返回修改后的对象

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

editor - 编辑器接口，为 null则返回原数组

Returns:

编辑后的数组

filter

public static <T> T[] filter(T[] array,
 Predicate<T> predicate)

过滤数组元素 保留 Predicate.test(Object)为true的元素

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

predicate - 过滤器接口，用于定义过滤规则，为null则返回原数组

Returns:

过滤后的数组

removeNull

public static <T> T[] removeNull(T[] array)

去除 null 元素

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

Returns:

处理后的数组

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:

处理后的数组

nullToEmpty

public static String[] nullToEmpty(String[] array)

数组元素中的null转换为""

Parameters:

array - 数组

Returns:

处理后的数组

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 - Map中的元素是否保留键值数组本身的顺序

Returns:

Map

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

contains

public static <T> boolean contains(T[] array,
 T value)

数组中是否包含指定元素

Type Parameters:

T - 数组元素类型

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:

是否包含所有指定元素

containsIgnoreCase

public static boolean containsIgnoreCase(CharSequence[] array,
 CharSequence value)

数组中是否包含元素，忽略大小写

Parameters:

array - 数组

value - 被检查的元素

Returns:

是否包含

wrap

public static Object[] wrap(Object object)

包装数组对象

Parameters:

object - 对象，可以是对象数组或者基本类型数组

Returns:

包装类型数组或对象数组

Throws:

InternalException - 对象为非数组

get

public static <E> E get(Object array,
 int index)

获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值 如果数组下标越界，返回null

Type Parameters:

E - 数组元素类型

Parameters:

array - 数组对象

index - 下标，支持负数

Returns:

值

get

public static <E> E get(E[] array,
 Predicate<E> predicate)

获取满足条件的第一个元素

Type Parameters:

E - 元素类型

Parameters:

array - 数组

predicate - 条件

Returns:

满足条件的第一个元素，未找到返回null

getAny

public static <T> T[] getAny(Object array,
 int... indexes)

获取数组中所有指定位置的元素值，组成新数组

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组，如果提供为null则返回null

indexes - 下标列表

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,
 UnaryOperator<T> editor)

先处理数组元素，再以 conjunction 为分隔符将数组转换为字符串

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

conjunction - 分隔符

editor - 每个元素的编辑器，null表示不编辑

Returns:

连接后的字符串

join

public static String join(Object array,
 CharSequence conjunction)

以 conjunction 为分隔符将数组转换为字符串

Parameters:

array - 数组

conjunction - 分隔符

Returns:

连接后的字符串

remove

public static <T> T[] remove(T[] array,
 int index)
                      throws IllegalArgumentException

移除数组中对应位置的元素 copier from commons-lang

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组对象，可以是对象数组，也可以原始类型数组

index - 位置，如果位置小于0或者大于长度，返回原数组

Returns:

去掉指定元素后的新数组或原数组

Throws:

IllegalArgumentException - 参数对象不为数组对象

removeEle

public static <T> T[] removeEle(T[] array,
 T element)
                         throws IllegalArgumentException

移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组对象，可以是对象数组，也可以原始类型数组

element - 要移除的元素

Returns:

去掉指定元素后的新数组或原数组

Throws:

IllegalArgumentException - 参数对象不为数组对象

reverse

public static <T> T[] reverse(T[] array,
 int startIndexInclusive,
 int endIndexExclusive)

反转数组，会变更原数组

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组，会变更

startIndexInclusive - 开始位置（包含）

endIndexExclusive - 结束位置（不包含）

Returns:

变更后的原数组

reverse

public static <T> T[] reverse(T[] array)

反转数组，会变更原数组

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组，会变更

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

最大值

shuffle

public static <T> T[] shuffle(T[] array)

打乱数组顺序，会变更原数组 使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序

Type Parameters:

T - 元素类型

Parameters:

array - 数组，会变更

Returns:

打乱后的数组

shuffle

public static <T> T[] shuffle(T[] array,
 Random random)

打乱数组顺序，会变更原数组 使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序

Type Parameters:

T - 元素类型

Parameters:

array - 数组，会变更

random - 随机数生成器

Returns:

打乱后的数组

swap

public static <T> T[] swap(T[] array,
 int index1,
 int index2)

交换数组中两个位置的值

Type Parameters:

T - 元素类型

Parameters:

array - 数组

index1 - 位置1

index2 - 位置2

Returns:

交换后的数组，与传入数组为同一对象

swap

public static Object swap(Object array,
 int index1,
 int index2)

交换数组中两个位置的值

Parameters:

array - 数组对象

index1 - 位置1

index2 - 位置2

Returns:

交换后的数组，与传入数组为同一对象

distinct

public static <T> T[] distinct(T[] array)

去重数组中的元素，去重后生成新的数组，原数组不变 此方法通过LinkedHashSet 去重

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

Returns:

去重后的数组

distinct

public static <T,
K> T[] distinct(T[] array,
 Function<T,K> uniqueGenerator,
 boolean override)

去重数组中的元素，去重后生成新的数组，原数组不变 此方法通过LinkedHashSet 去重

Type Parameters:

T - 数组元素类型

K - 唯一键类型

Parameters:

array - 数组

uniqueGenerator - 唯一键生成器

override - 是否覆盖模式，如果为true，加入的新值会覆盖相同key的旧值，否则会忽略新加值

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:

转换后的数组

mapToList

public static <T,
R> List<R> mapToList(T[] array,
 Function<? super T,? extends R> func)

按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为 List

Type Parameters:

T - 原数组类型

R - 目标数组类型

Parameters:

array - 被转换的数组

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:

集合

mapToArray

public static <T,
R> R[] mapToArray(T[] array,
 Function<? super T,? extends R> func,
 IntFunction<R[]> generator)

按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为 Set

Type Parameters:

T - 原数组类型

R - 目标数组类型

Parameters:

array - 被转换的数组

func - 转换规则函数

generator - 数组生成器，如返回String[]，则传入String[]::new

Returns:

集合

equals

public static boolean equals(Object array1,
 Object array2)

判断两个数组是否相等，判断依据包括数组长度和每个元素都相等。

Parameters:

array1 - 数组1

array2 - 数组2

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 <A> A sub(A array,
 int beginInclude,
 int endExclude)

获取子数组

Type Parameters:

A - 数组类型

Parameters:

array - 数组

beginInclude - 开始位置（包括）

endExclude - 结束位置（不包括）

Returns:

新的数组

sub

public static <A> A sub(A array,
 int beginInclude,
 int endExclude,
 int step)

获取子数组

Type Parameters:

A - 数组类型

Parameters:

array - 数组

beginInclude - 开始位置（包括）

endExclude - 结束位置（不包括）

step - 步进

Returns:

新的数组

lastIndexOfSub

public static <T> int lastIndexOfSub(T[] array,
 T[] subArray)

查找最后一个子数组的开始位置

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

subArray - 子数组

Returns:

最后一个子数组的开始位置，即子数字第一个元素在数组中的位置

lastIndexOfSub

public static <T> int lastIndexOfSub(T[] array,
 int endInclude,
 T[] subArray)

查找最后一个子数组的开始位置

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

endInclude - 从后往前查找时的开始位置（包含）

subArray - 子数组

Returns:

最后一个子数组的开始位置，即从后往前，子数字第一个元素在数组中的位置

hasSameElement

public static <T> Boolean hasSameElement(T[] array)

判断数组中是否有相同元素

若传入空数组，则返回false

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

Returns:

数组是否有相同元素

startWith

public static <T> boolean startWith(T[] array,
 T[] prefix)

array数组是否以prefix开头，每个元素的匹配使用ObjectValidator.equals(Object, Object)匹配。

• array和prefix为同一个数组（即array == prefix），返回true
• array或prefix为空数组（null或length为0的数组），返回true
• prefix长度大于array，返回false

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

prefix - 前缀

Returns:

是否开头

arrayEquals

public static boolean arrayEquals(Object o1,
 Object o2)

比较给定的数组和Arrays.equals，根据数组元素而不是数组引用执行相等性检查

Parameters:

o1 - 第一个比较对象

o2 - 第二个比较对象

Returns:

给定对象是否相等

See Also:

• ObjectKit.nullSafeEquals(Object, Object)
• Arrays.equals(long[], long[])