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 obj)

克隆数组，如果非数组返回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)匹配。 array和prefix为同一个数组（即array == prefix），返回true array或prefix为空数组（null或length为0的数组），返回true prefix长度大于array，返回false

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 obj)

包装数组对象

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 obj)
  
  克隆数组，如果非数组返回null
  
  Type Parameters:
  
  T - 数组元素类型
  
  Parameters:
  
  obj - 数组对象
  
  Returns:
  
  克隆后的数组对象
- edit
  
  public static <T> T[] edit(T[] array, UnaryOperator<T> editor)
  对每个数组元素执行指定操作，返回操作后的元素这个Editor实现可以实现以下功能：
  
  过滤出需要的对象，如果返回null则抛弃这个元素对象
  
  修改元素对象，返回修改后的对象
  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 obj)
  
  包装数组对象
  
  Parameters:
  
  obj - 对象，可以是对象数组或者基本类型数组
  
  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[])

Class ArrayKit

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Constructor Details

ArrayKit

Method Details

castOrWrapSingle

wrapSingle

ofArray

newArray

newArray

getComponentType

getComponentType

getArrayType

cast

append

append

setOrAppend

setOrAppend

setOrPadding

setOrPadding

addAll

replace

replace

insert

insert

resize

resize

resize

copy

copy

copy

clone

clone

edit

filter

removeNull

removeEmpty

removeBlank

nullToEmpty

zip

zip

contains

containsAny

containsAll

containsIgnoreCase

wrap

get

get

getAny

join

join

join

join

remove

removeEle

reverse

reverse

min

min

max

max

shuffle

shuffle

swap

swap

distinct

distinct

map

mapToList

mapToSet

mapToArray

equals

sub

sub

sub

lastIndexOfSub