ArrayUtil (hutool 2.16.2 API)

java.lang.Object
- com.xiaoleilu.hutool.util.ArrayUtil

```
public class ArrayUtil
extends Object
```
数组工具类

作者:

Looly

构造器概要

构造器
构造器和说明

ArrayUtil()

构造器
构造器和说明
`ArrayUtil()`

方法概要

方法
限定符和类型	方法和说明
`static <T> T[]`	`addAll(T[]... arrays)` 将多个数组合并在一起忽略null的数组
`static <T> T[]`	`append(T[] buffer, T... newElements)` 将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
`static <T> T[]`	`clone(T[] array)` 克隆数组
`static <T> boolean`	`contains(T[] array, T value)` 数组中是否包含元素
`static <T> T[]`	`filter(T[] array, Editor<T> editor)` 过滤
`static boolean`	`isArray(Object obj)` 对象是否为数组对象
`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 <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)` 数组是否为非空
`static String`	`join(boolean[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(byte[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(char[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(double[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(float[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(int[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(long[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(Object array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(short[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> String`	`join(T[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> T[]`	`newArray(Class<?> componentType, int newSize)` 新建一个空数组
`static int[]`	`range(int excludedEnd)` 生成一个数字列表自动判定正序反序
`static int[]`	`range(int includedStart, int excludedEnd)` 生成一个数字列表自动判定正序反序
`static int[]`	`range(int includedStart, int excludedEnd, int step)` 生成一个数字列表自动判定正序反序
`static <T> T[]`	`resize(T[] buffer, int newSize)` 生成一个新的重新设置大小的数组新数组的类型为原数组的类型
`static <T> T[]`	`resize(T[] buffer, int newSize, Class<?> componentType)` 生成一个新的重新设置大小的数组
`static byte[][]`	`split(byte[] array, int len)` 拆分byte数组
`static String`	`toString(Object obj)` 数组或集合转String
`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 Integer[]`	`wrap(int... values)` 将原始类型数组包装为包装类型
`static Long[]`	`wrap(long... values)` 将原始类型数组包装为包装类型
`static Object[]`	`wrap(Object obj)` 包装数组对象
`static Short[]`	`wrap(short... values)` 将原始类型数组包装为包装类型
`static <T,K> Map<T,K>`	`zip(T[] keys, K[] values)` 映射键值（参考Python的zip()函数）例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - ArrayUtil
```
public ArrayUtil()
```
- 方法详细资料
  - isEmpty
```
public static <T> boolean isEmpty(T[] array)
```
    数组是否为空
    
    参数:
    array - 数组
    
    返回:
    是否为空
  - isEmpty
```
public static boolean isEmpty(long[] array)
```
    数组是否为空
    
    参数:
    array - 数组
    
    返回:
    是否为空
  - isEmpty
```
public static boolean isEmpty(int[] array)
```
    数组是否为空
    
    参数:
    array - 数组
    
    返回:
    是否为空
  - isEmpty
```
public static boolean isEmpty(short[] array)
```
    数组是否为空
    
    参数:
    array - 数组
    
    返回:
    是否为空
  - isEmpty
```
public static boolean isEmpty(char[] array)
```
    数组是否为空
    
    参数:
    array - 数组
    
    返回:
    是否为空
  - isEmpty
```
public static boolean isEmpty(byte[] array)
```
    数组是否为空
    
    参数:
    array - 数组
    
    返回:
    是否为空
  - isEmpty
```
public static boolean isEmpty(double[] array)
```
    数组是否为空
    
    参数:
    array - 数组
    
    返回:
    是否为空
  - isEmpty
```
public static boolean isEmpty(float[] array)
```
    数组是否为空
    
    参数:
    array - 数组
    
    返回:
    是否为空
  - isEmpty
```
public static boolean isEmpty(boolean[] array)
```
    数组是否为空
    
    参数:
    array - 数组
    
    返回:
    是否为空
  - isNotEmpty
```
public static <T> boolean isNotEmpty(T[] array)
```
    数组是否为非空
    
    参数:
    array - 数组
    
    返回:
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(long[] array)
```
    数组是否为非空
    
    参数:
    array - 数组
    
    返回:
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(int[] array)
```
    数组是否为非空
    
    参数:
    array - 数组
    
    返回:
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(short[] array)
```
    数组是否为非空
    
    参数:
    array - 数组
    
    返回:
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(char[] array)
```
    数组是否为非空
    
    参数:
    array - 数组
    
    返回:
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(byte[] array)
```
    数组是否为非空
    
    参数:
    array - 数组
    
    返回:
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(double[] array)
```
    数组是否为非空
    
    参数:
    array - 数组
    
    返回:
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(float[] array)
```
    数组是否为非空
    
    参数:
    array - 数组
    
    返回:
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(boolean[] array)
```
    数组是否为非空
    
    参数:
    array - 数组
    
    返回:
    是否为非空
  - newArray
```
public static <T> T[] newArray(Class<?> componentType,
               int newSize)
```
    新建一个空数组
    
    参数:
    componentType - 元素类型
    newSize - 大小
    
    返回:
    空数组
  - append
```
@SafeVarargs
public static <T> T[] append(T[] buffer,
                         T... newElements)
```
    将新元素添加到已有数组中
    添加新元素会生成一个新的数组，不影响原数组
    
    参数:
    buffer - 已有数组
    newElements - 新元素
    
    返回:
    新数组
  - resize
```
public static <T> T[] resize(T[] buffer,
             int newSize,
             Class<?> componentType)
```
    生成一个新的重新设置大小的数组
    
    参数:
    buffer - 原数组
    newSize - 新的数组大小
    componentType - 数组元素类型
    
    返回:
    调整后的新数组
  - resize
```
public static <T> T[] resize(T[] buffer,
             int newSize)
```
    生成一个新的重新设置大小的数组
    新数组的类型为原数组的类型
    
    参数:
    buffer - 原数组
    newSize - 新的数组大小
    
    返回:
    调整后的新数组
  - addAll
```
@SafeVarargs
public static <T> T[] addAll(T[]... arrays)
```
    将多个数组合并在一起
    忽略null的数组
    
    参数:
    arrays - 数组集合
    
    返回:
    合并后的数组
  - clone
```
public static <T> T[] clone(T[] array)
```
    克隆数组
    
    参数:
    array - 被克隆的数组
    
    返回:
    新数组
  - range
```
public static int[] range(int excludedEnd)
```
    生成一个数字列表
    自动判定正序反序
    
    参数:
    excludedEnd - 结束的数字（不包含）
    
    返回:
    数字列表
  - range
```
public static int[] range(int includedStart,
          int excludedEnd)
```
    生成一个数字列表
    自动判定正序反序
    
    参数:
    includedStart - 开始的数字（包含）
    excludedEnd - 结束的数字（不包含）
    
    返回:
    数字列表
  - range
```
public static int[] range(int includedStart,
          int excludedEnd,
          int step)
```
    生成一个数字列表
    自动判定正序反序
    
    参数:
    includedStart - 开始的数字（包含）
    excludedEnd - 结束的数字（不包含）
    step - 步进
    
    返回:
    数字列表
  - split
```
public static byte[][] split(byte[] array,
             int len)
```
    拆分byte数组
    
    参数:
    array - 数组
    len - 每个小节的长度
    
    返回:
    拆分后的数组
  - filter
```
public static <T> T[] filter(T[] array,
             Editor<T> editor)
```
    过滤
    
    参数:
    array - 数组
    editor - 编辑器接口
    
    返回:
    过滤后的数组
  - zip
```
public static <T,K> Map<T,K> zip(T[] keys,
                 K[] values)
```
    映射键值（参考Python的zip()函数）
    例如：
    keys = [a,b,c,d]
    values = [1,2,3,4]
    则得到的Map是 {a=1, b=2, c=3, d=4}
    如果两个数组长度不同，则只对应最短部分
    
    参数:
    keys - 键列表
    values - 值列表
    
    返回:
    Map
  - contains
```
public static <T> boolean contains(T[] array,
                   T value)
```
    数组中是否包含元素
    
    参数:
    array - 数组
    value - 被检查的元素
    
    返回:
    是否包含
  - wrap
```
public static Integer[] wrap(int... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    values - 原始类型数组
    
    返回:
    包装类型数组
  - unWrap
```
public static int[] unWrap(Integer... values)
```
    包装类数组转为原始类型数组
    
    参数:
    values - 包装类型数组
    
    返回:
    原始类型数组
  - wrap
```
public static Long[] wrap(long... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    values - 原始类型数组
    
    返回:
    包装类型数组
  - unWrap
```
public static long[] unWrap(Long... values)
```
    包装类数组转为原始类型数组
    
    参数:
    values - 包装类型数组
    
    返回:
    原始类型数组
  - wrap
```
public static Character[] wrap(char... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    values - 原始类型数组
    
    返回:
    包装类型数组
  - unWrap
```
public static char[] unWrap(Character... values)
```
    包装类数组转为原始类型数组
    
    参数:
    values - 包装类型数组
    
    返回:
    原始类型数组
  - wrap
```
public static Byte[] wrap(byte... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    values - 原始类型数组
    
    返回:
    包装类型数组
  - unWrap
```
public static byte[] unWrap(Byte... values)
```
    包装类数组转为原始类型数组
    
    参数:
    values - 包装类型数组
    
    返回:
    原始类型数组
  - wrap
```
public static Short[] wrap(short... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    values - 原始类型数组
    
    返回:
    包装类型数组
  - unWrap
```
public static short[] unWrap(Short... values)
```
    包装类数组转为原始类型数组
    
    参数:
    values - 包装类型数组
    
    返回:
    原始类型数组
  - wrap
```
public static Float[] wrap(float... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    values - 原始类型数组
    
    返回:
    包装类型数组
  - unWrap
```
public static float[] unWrap(Float... values)
```
    包装类数组转为原始类型数组
    
    参数:
    values - 包装类型数组
    
    返回:
    原始类型数组
  - wrap
```
public static Double[] wrap(double... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    values - 原始类型数组
    
    返回:
    包装类型数组
  - unWrap
```
public static double[] unWrap(Double... values)
```
    包装类数组转为原始类型数组
    
    参数:
    values - 包装类型数组
    
    返回:
    原始类型数组
  - wrap
```
public static Boolean[] wrap(boolean... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    values - 原始类型数组
    
    返回:
    包装类型数组
  - unWrap
```
public static boolean[] unWrap(Boolean... values)
```
    包装类数组转为原始类型数组
    
    参数:
    values - 包装类型数组
    
    返回:
    原始类型数组
  - wrap
```
public static Object[] wrap(Object obj)
```
    包装数组对象
    
    参数:
    obj - 对象，可以是对象数组或者基本类型数组
    
    返回:
    包装类型数组或对象数组
    
    抛出:
    
    UtilException - 对象为非数组
  - isArray
```
public static boolean isArray(Object obj)
```
    对象是否为数组对象
    
    参数:
    obj - 对象
    
    返回:
    是否为数组对象
  - toString
```
public static String toString(Object obj)
```
    数组或集合转String
    
    参数:
    obj - 集合或数组对象
    
    返回:
    数组字符串，与集合转字符串格式相同
  - join
```
public static <T> String join(T[] array,
              String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    类型参数:
    T - 被处理的集合
    参数:
    array - 数组
    conjunction - 分隔符
    
    返回:
    连接后的字符串
  - join
```
public static String join(long[] array,
          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    array - 数组
    conjunction - 分隔符
    
    返回:
    连接后的字符串
  - join
```
public static String join(int[] array,
          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    array - 数组
    conjunction - 分隔符
    
    返回:
    连接后的字符串
  - join
```
public static String join(short[] array,
          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    array - 数组
    conjunction - 分隔符
    
    返回:
    连接后的字符串
  - join
```
public static String join(char[] array,
          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    array - 数组
    conjunction - 分隔符
    
    返回:
    连接后的字符串
  - join
```
public static String join(byte[] array,
          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    array - 数组
    conjunction - 分隔符
    
    返回:
    连接后的字符串
  - join
```
public static String join(boolean[] array,
          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    array - 数组
    conjunction - 分隔符
    
    返回:
    连接后的字符串
  - join
```
public static String join(float[] array,
          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    array - 数组
    conjunction - 分隔符
    
    返回:
    连接后的字符串
  - join
```
public static String join(double[] array,
          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    array - 数组
    conjunction - 分隔符
    
    返回:
    连接后的字符串
  - join
```
public static String join(Object array,
          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    array - 数组
    conjunction - 分隔符
    
    返回:
    连接后的字符串

类 ArrayUtil

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

ArrayUtil

方法详细资料

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

newArray

append

resize

resize

addAll

clone

range

range

range

split

filter

zip

contains

wrap

unWrap

wrap

unWrap

wrap

unWrap

wrap

unWrap

wrap

unWrap

wrap

unWrap

wrap

unWrap

wrap

unWrap

wrap

isArray

toString

join

join

join

join

join

join

join

join

join

join