From 633ed24564a1d210a6a04d7cd572dfb8c62337a6 Mon Sep 17 00:00:00 2001
From: Looly <loolly@gmail.com>
Date: Fri, 27 Nov 2020 11:32:17 +0800
Subject: [PATCH] add util

---
 CHANGELOG.md                                  |    2 +
 .../java/cn/hutool/core/util/ArrayUtil.java   | 3019 +---------------
 .../hutool/core/util/PrimitiveArrayUtil.java  | 3022 +++++++++++++++++
 3 files changed, 3044 insertions(+), 2999 deletions(-)
 create mode 100644 hutool-core/src/main/java/cn/hutool/core/util/PrimitiveArrayUtil.java

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 342a01837..df9bedd5f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,6 +18,8 @@
 * 【core   】     Base64增加encodeWithoutPadding方法（issue#I26J16@Gitee）
 * 【core   】     ExceptionUtil增加message消息包装为运行时异常的方法（pr#1253@Gitee）
 * 【core   】     DatePattern增加年月格式化常量（pr#220@Gitee）
+* 【core   】     ArrayUtil增加shuffle方法（pr#1255@Github）
+* 【core   】     ArrayUtil部分方法分离至PrimitiveArrayUtil
 
 ### Bug修复
 * 【cron   】     修复CronTimer可能死循环的问题（issue#1224@Github）
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
index f3cb96e9c..e8eb53e20 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
@@ -30,12 +30,7 @@ import java.util.function.Function;
  *
  * @author Looly
  */
-public class ArrayUtil {
-
-	/**
-	 * 数组中元素未找到的下标，值为-1
-	 */
-	public static final int INDEX_NOT_FOUND = -1;
+public class ArrayUtil extends PrimitiveArrayUtil{
 
 	// ---------------------------------------------------------------------- isEmpty
 
@@ -82,86 +77,6 @@ public class ArrayUtil {
 		return true;
 	}
 
-	/**
-	 * 数组是否为空
-	 *
-	 * @param array 数组
-	 * @return 是否为空
-	 */
-	public static boolean isEmpty(long[] array) {
-		return array == null || array.length == 0;
-	}
-
-	/**
-	 * 数组是否为空
-	 *
-	 * @param array 数组
-	 * @return 是否为空
-	 */
-	public static boolean isEmpty(int[] array) {
-		return array == null || array.length == 0;
-	}
-
-	/**
-	 * 数组是否为空
-	 *
-	 * @param array 数组
-	 * @return 是否为空
-	 */
-	public static boolean isEmpty(short[] array) {
-		return array == null || array.length == 0;
-	}
-
-	/**
-	 * 数组是否为空
-	 *
-	 * @param array 数组
-	 * @return 是否为空
-	 */
-	public static boolean isEmpty(char[] array) {
-		return array == null || array.length == 0;
-	}
-
-	/**
-	 * 数组是否为空
-	 *
-	 * @param array 数组
-	 * @return 是否为空
-	 */
-	public static boolean isEmpty(byte[] array) {
-		return array == null || array.length == 0;
-	}
-
-	/**
-	 * 数组是否为空
-	 *
-	 * @param array 数组
-	 * @return 是否为空
-	 */
-	public static boolean isEmpty(double[] array) {
-		return array == null || array.length == 0;
-	}
-
-	/**
-	 * 数组是否为空
-	 *
-	 * @param array 数组
-	 * @return 是否为空
-	 */
-	public static boolean isEmpty(float[] array) {
-		return array == null || array.length == 0;
-	}
-
-	/**
-	 * 数组是否为空
-	 *
-	 * @param array 数组
-	 * @return 是否为空
-	 */
-	public static boolean isEmpty(boolean[] array) {
-		return array == null || array.length == 0;
-	}
-
 	// ---------------------------------------------------------------------- isNotEmpty
 
 	/**
@@ -188,86 +103,6 @@ public class ArrayUtil {
 		return false == isEmpty(array);
 	}
 
-	/**
-	 * 数组是否为非空
-	 *
-	 * @param array 数组
-	 * @return 是否为非空
-	 */
-	public static boolean isNotEmpty(long[] array) {
-		return false == isEmpty(array);
-	}
-
-	/**
-	 * 数组是否为非空
-	 *
-	 * @param array 数组
-	 * @return 是否为非空
-	 */
-	public static boolean isNotEmpty(int[] array) {
-		return false == isEmpty(array);
-	}
-
-	/**
-	 * 数组是否为非空
-	 *
-	 * @param array 数组
-	 * @return 是否为非空
-	 */
-	public static boolean isNotEmpty(short[] array) {
-		return false == isEmpty(array);
-	}
-
-	/**
-	 * 数组是否为非空
-	 *
-	 * @param array 数组
-	 * @return 是否为非空
-	 */
-	public static boolean isNotEmpty(char[] array) {
-		return false == isEmpty(array);
-	}
-
-	/**
-	 * 数组是否为非空
-	 *
-	 * @param array 数组
-	 * @return 是否为非空
-	 */
-	public static boolean isNotEmpty(byte[] array) {
-		return false == isEmpty(array);
-	}
-
-	/**
-	 * 数组是否为非空
-	 *
-	 * @param array 数组
-	 * @return 是否为非空
-	 */
-	public static boolean isNotEmpty(double[] array) {
-		return false == isEmpty(array);
-	}
-
-	/**
-	 * 数组是否为非空
-	 *
-	 * @param array 数组
-	 * @return 是否为非空
-	 */
-	public static boolean isNotEmpty(float[] array) {
-		return false == isEmpty(array);
-	}
-
-	/**
-	 * 数组是否为非空
-	 *
-	 * @param array 数组
-	 * @return 是否为非空
-	 */
-	public static boolean isNotEmpty(boolean[] array) {
-		return false == isEmpty(array);
-	}
-
 	/**
 	 * 是否包含{@code null}元素
 	 *
@@ -594,26 +429,6 @@ public class ArrayUtil {
 		return newArray;
 	}
 
-	/**
-	 * 生成一个新的重新设置大小的数组<br>
-	 * 调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，其它位置补充0，缩小则截断
-	 *
-	 * @param bytes   原数组
-	 * @param newSize 新的数组大小
-	 * @return 调整后的新数组
-	 * @since 4.6.7
-	 */
-	public static byte[] resize(byte[] bytes, int newSize) {
-		if (newSize < 0) {
-			return bytes;
-		}
-		final byte[] newArray = new byte[newSize];
-		if (newSize > 0 && isNotEmpty(bytes)) {
-			System.arraycopy(bytes, 0, newArray, 0, Math.min(bytes.length, newSize));
-		}
-		return newArray;
-	}
-
 	/**
 	 * 生成一个新的重新设置大小的数组<br>
 	 * 新数组的类型为原数组的类型，调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，缩小则截断
@@ -659,262 +474,6 @@ public class ArrayUtil {
 		return result;
 	}
 
-	/**
-	 * 将多个数组合并在一起<br>
-	 * 忽略null的数组
-	 *
-	 * @param arrays 数组集合
-	 * @return 合并后的数组
-	 * @since 4.6.9
-	 */
-	public static byte[] addAll(byte[]... arrays) {
-		if (arrays.length == 1) {
-			return arrays[0];
-		}
-
-		// 计算总长度
-		int length = 0;
-		for (byte[] array : arrays) {
-			if (null != array) {
-				length += array.length;
-			}
-		}
-
-		final byte[] result = new byte[length];
-		length = 0;
-		for (byte[] array : arrays) {
-			if (null != array) {
-				System.arraycopy(array, 0, result, length, array.length);
-				length += array.length;
-			}
-		}
-		return result;
-	}
-
-	/**
-	 * 将多个数组合并在一起<br>
-	 * 忽略null的数组
-	 *
-	 * @param arrays 数组集合
-	 * @return 合并后的数组
-	 * @since 4.6.9
-	 */
-	public static int[] addAll(int[]... arrays) {
-		if (arrays.length == 1) {
-			return arrays[0];
-		}
-
-		// 计算总长度
-		int length = 0;
-		for (int[] array : arrays) {
-			if (null != array) {
-				length += array.length;
-			}
-		}
-
-		final int[] result = new int[length];
-		length = 0;
-		for (int[] array : arrays) {
-			if (null != array) {
-				System.arraycopy(array, 0, result, length, array.length);
-				length += array.length;
-			}
-		}
-		return result;
-	}
-
-	/**
-	 * 将多个数组合并在一起<br>
-	 * 忽略null的数组
-	 *
-	 * @param arrays 数组集合
-	 * @return 合并后的数组
-	 * @since 4.6.9
-	 */
-	public static long[] addAll(long[]... arrays) {
-		if (arrays.length == 1) {
-			return arrays[0];
-		}
-
-		// 计算总长度
-		int length = 0;
-		for (long[] array : arrays) {
-			if (null != array) {
-				length += array.length;
-			}
-		}
-
-		final long[] result = new long[length];
-		length = 0;
-		for (long[] array : arrays) {
-			if (null != array) {
-				System.arraycopy(array, 0, result, length, array.length);
-				length += array.length;
-			}
-		}
-		return result;
-	}
-
-	/**
-	 * 将多个数组合并在一起<br>
-	 * 忽略null的数组
-	 *
-	 * @param arrays 数组集合
-	 * @return 合并后的数组
-	 * @since 4.6.9
-	 */
-	public static double[] addAll(double[]... arrays) {
-		if (arrays.length == 1) {
-			return arrays[0];
-		}
-
-		// 计算总长度
-		int length = 0;
-		for (double[] array : arrays) {
-			if (null != array) {
-				length += array.length;
-			}
-		}
-
-		final double[] result = new double[length];
-		length = 0;
-		for (double[] array : arrays) {
-			if (null != array) {
-				System.arraycopy(array, 0, result, length, array.length);
-				length += array.length;
-			}
-		}
-		return result;
-	}
-
-	/**
-	 * 将多个数组合并在一起<br>
-	 * 忽略null的数组
-	 *
-	 * @param arrays 数组集合
-	 * @return 合并后的数组
-	 * @since 4.6.9
-	 */
-	public static float[] addAll(float[]... arrays) {
-		if (arrays.length == 1) {
-			return arrays[0];
-		}
-
-		// 计算总长度
-		int length = 0;
-		for (float[] array : arrays) {
-			if (null != array) {
-				length += array.length;
-			}
-		}
-
-		final float[] result = new float[length];
-		length = 0;
-		for (float[] array : arrays) {
-			if (null != array) {
-				System.arraycopy(array, 0, result, length, array.length);
-				length += array.length;
-			}
-		}
-		return result;
-	}
-
-	/**
-	 * 将多个数组合并在一起<br>
-	 * 忽略null的数组
-	 *
-	 * @param arrays 数组集合
-	 * @return 合并后的数组
-	 * @since 4.6.9
-	 */
-	public static char[] addAll(char[]... arrays) {
-		if (arrays.length == 1) {
-			return arrays[0];
-		}
-
-		// 计算总长度
-		int length = 0;
-		for (char[] array : arrays) {
-			if (null != array) {
-				length += array.length;
-			}
-		}
-
-		final char[] result = new char[length];
-		length = 0;
-		for (char[] array : arrays) {
-			if (null != array) {
-				System.arraycopy(array, 0, result, length, array.length);
-				length += array.length;
-			}
-		}
-		return result;
-	}
-
-	/**
-	 * 将多个数组合并在一起<br>
-	 * 忽略null的数组
-	 *
-	 * @param arrays 数组集合
-	 * @return 合并后的数组
-	 * @since 4.6.9
-	 */
-	public static boolean[] addAll(boolean[]... arrays) {
-		if (arrays.length == 1) {
-			return arrays[0];
-		}
-
-		// 计算总长度
-		int length = 0;
-		for (boolean[] array : arrays) {
-			if (null != array) {
-				length += array.length;
-			}
-		}
-
-		final boolean[] result = new boolean[length];
-		length = 0;
-		for (boolean[] array : arrays) {
-			if (null != array) {
-				System.arraycopy(array, 0, result, length, array.length);
-				length += array.length;
-			}
-		}
-		return result;
-	}
-
-	/**
-	 * 将多个数组合并在一起<br>
-	 * 忽略null的数组
-	 *
-	 * @param arrays 数组集合
-	 * @return 合并后的数组
-	 * @since 4.6.9
-	 */
-	public static short[] addAll(short[]... arrays) {
-		if (arrays.length == 1) {
-			return arrays[0];
-		}
-
-		// 计算总长度
-		int length = 0;
-		for (short[] array : arrays) {
-			if (null != array) {
-				length += array.length;
-			}
-		}
-
-		final short[] result = new short[length];
-		length = 0;
-		for (short[] array : arrays) {
-			if (null != array) {
-				System.arraycopy(array, 0, result, length, array.length);
-				length += array.length;
-			}
-		}
-		return result;
-	}
-
 	/**
 	 * 包装 {@link System#arraycopy(Object, int, Object, int, int)}<br>
 	 * 数组复制
@@ -992,89 +551,6 @@ public class ArrayUtil {
 		return null;
 	}
 
-	/**
-	 * 生成一个从0开始的数字列表<br>
-	 *
-	 * @param excludedEnd 结束的数字（不包含）
-	 * @return 数字列表
-	 */
-	public static int[] range(int excludedEnd) {
-		return range(0, excludedEnd, 1);
-	}
-
-	/**
-	 * 生成一个数字列表<br>
-	 * 自动判定正序反序
-	 *
-	 * @param includedStart 开始的数字（包含）
-	 * @param excludedEnd   结束的数字（不包含）
-	 * @return 数字列表
-	 */
-	public static int[] range(int includedStart, int excludedEnd) {
-		return range(includedStart, excludedEnd, 1);
-	}
-
-	/**
-	 * 生成一个数字列表<br>
-	 * 自动判定正序反序
-	 *
-	 * @param includedStart 开始的数字（包含）
-	 * @param excludedEnd   结束的数字（不包含）
-	 * @param step          步进
-	 * @return 数字列表
-	 */
-	public static int[] range(int includedStart, int excludedEnd, int step) {
-		if (includedStart > excludedEnd) {
-			int tmp = includedStart;
-			includedStart = excludedEnd;
-			excludedEnd = tmp;
-		}
-
-		if (step <= 0) {
-			step = 1;
-		}
-
-		int deviation = excludedEnd - includedStart;
-		int length = deviation / step;
-		if (deviation % step != 0) {
-			length += 1;
-		}
-		int[] range = new int[length];
-		for (int i = 0; i < length; i++) {
-			range[i] = includedStart;
-			includedStart += step;
-		}
-		return range;
-	}
-
-	/**
-	 * 拆分byte数组为几个等份（最后一份可能小于len）
-	 *
-	 * @param array 数组
-	 * @param len   每个小节的长度
-	 * @return 拆分后的数组
-	 */
-	public static byte[][] split(byte[] array, int len) {
-		int x = array.length / len;
-		int y = array.length % len;
-		int z = 0;
-		if (y != 0) {
-			z = 1;
-		}
-		byte[][] arrays = new byte[x + z][];
-		byte[] arr;
-		for (int i = 0; i < x + z; i++) {
-			arr = new byte[len];
-			if (i == x + z - 1 && y != 0) {
-				System.arraycopy(array, i * len, arr, 0, y);
-			} else {
-				System.arraycopy(array, i * len, arr, 0, len);
-			}
-			arrays[i] = arr;
-		}
-		return arrays;
-	}
-
 	/**
 	 * 过滤<br>
 	 * 过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
@@ -1372,760 +848,8 @@ public class ArrayUtil {
 		return indexOfIgnoreCase(array, value) > INDEX_NOT_FOUND;
 	}
 
-	/**
-	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int indexOf(long[] array, long value) {
-		if (null != array) {
-			for (int i = 0; i < array.length; i++) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int lastIndexOf(long[] array, long value) {
-		if (null != array) {
-			for (int i = array.length - 1; i >= 0; i--) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 数组中是否包含元素
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 是否包含
-	 * @since 3.0.7
-	 */
-	public static boolean contains(long[] array, long value) {
-		return indexOf(array, value) > INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int indexOf(int[] array, int value) {
-		if (null != array) {
-			for (int i = 0; i < array.length; i++) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int lastIndexOf(int[] array, int value) {
-		if (null != array) {
-			for (int i = array.length - 1; i >= 0; i--) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 数组中是否包含元素
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 是否包含
-	 * @since 3.0.7
-	 */
-	public static boolean contains(int[] array, int value) {
-		return indexOf(array, value) > INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int indexOf(short[] array, short value) {
-		if (null != array) {
-			for (int i = 0; i < array.length; i++) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int lastIndexOf(short[] array, short value) {
-		if (null != array) {
-			for (int i = array.length - 1; i >= 0; i--) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 数组中是否包含元素
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 是否包含
-	 * @since 3.0.7
-	 */
-	public static boolean contains(short[] array, short value) {
-		return indexOf(array, value) > INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int indexOf(char[] array, char value) {
-		if (null != array) {
-			for (int i = 0; i < array.length; i++) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int lastIndexOf(char[] array, char value) {
-		if (null != array) {
-			for (int i = array.length - 1; i >= 0; i--) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 数组中是否包含元素
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 是否包含
-	 * @since 3.0.7
-	 */
-	public static boolean contains(char[] array, char value) {
-		return indexOf(array, value) > INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int indexOf(byte[] array, byte value) {
-		if (null != array) {
-			for (int i = 0; i < array.length; i++) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int lastIndexOf(byte[] array, byte value) {
-		if (null != array) {
-			for (int i = array.length - 1; i >= 0; i--) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 数组中是否包含元素
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 是否包含
-	 * @since 3.0.7
-	 */
-	public static boolean contains(byte[] array, byte value) {
-		return indexOf(array, value) > INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int indexOf(double[] array, double value) {
-		if (null != array) {
-			for (int i = 0; i < array.length; i++) {
-				if (NumberUtil.equals(value, array[i])) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int lastIndexOf(double[] array, double value) {
-		if (null != array) {
-			for (int i = array.length - 1; i >= 0; i--) {
-				if (NumberUtil.equals(value, array[i])) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 数组中是否包含元素
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 是否包含
-	 * @since 3.0.7
-	 */
-	public static boolean contains(double[] array, double value) {
-		return indexOf(array, value) > INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int indexOf(float[] array, float value) {
-		if (null != array) {
-			for (int i = 0; i < array.length; i++) {
-				if (NumberUtil.equals(value, array[i])) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int lastIndexOf(float[] array, float value) {
-		if (null != array) {
-			for (int i = array.length - 1; i >= 0; i--) {
-				if (NumberUtil.equals(value, array[i])) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 数组中是否包含元素
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 是否包含
-	 * @since 3.0.7
-	 */
-	public static boolean contains(float[] array, float value) {
-		return indexOf(array, value) > INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int indexOf(boolean[] array, boolean value) {
-		if (null != array) {
-			for (int i = 0; i < array.length; i++) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
-	 * @since 3.0.7
-	 */
-	public static int lastIndexOf(boolean[] array, boolean value) {
-		if (null != array) {
-			for (int i = array.length - 1; i >= 0; i--) {
-				if (value == array[i]) {
-					return i;
-				}
-			}
-		}
-		return INDEX_NOT_FOUND;
-	}
-
-	/**
-	 * 数组中是否包含元素
-	 *
-	 * @param array 数组
-	 * @param value 被检查的元素
-	 * @return 是否包含
-	 * @since 3.0.7
-	 */
-	public static boolean contains(boolean[] array, boolean value) {
-		return indexOf(array, value) > INDEX_NOT_FOUND;
-	}
-
 	// ------------------------------------------------------------------- Wrap and unwrap
 
-	/**
-	 * 将原始类型数组包装为包装类型
-	 *
-	 * @param values 原始类型数组
-	 * @return 包装类型数组
-	 */
-	public static Integer[] wrap(int... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new Integer[0];
-		}
-
-		final Integer[] array = new Integer[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = values[i];
-		}
-		return array;
-	}
-
-	/**
-	 * 包装类数组转为原始类型数组，null转为0
-	 *
-	 * @param values 包装类型数组
-	 * @return 原始类型数组
-	 */
-	public static int[] unWrap(Integer... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new int[0];
-		}
-
-		final int[] array = new int[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = ObjectUtil.defaultIfNull(values[i], 0);
-		}
-		return array;
-	}
-
-	/**
-	 * 将原始类型数组包装为包装类型
-	 *
-	 * @param values 原始类型数组
-	 * @return 包装类型数组
-	 */
-	public static Long[] wrap(long... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new Long[0];
-		}
-
-		final Long[] array = new Long[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = values[i];
-		}
-		return array;
-	}
-
-	/**
-	 * 包装类数组转为原始类型数组
-	 *
-	 * @param values 包装类型数组
-	 * @return 原始类型数组
-	 */
-	public static long[] unWrap(Long... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new long[0];
-		}
-
-		final long[] array = new long[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = ObjectUtil.defaultIfNull(values[i], 0L);
-		}
-		return array;
-	}
-
-	/**
-	 * 将原始类型数组包装为包装类型
-	 *
-	 * @param values 原始类型数组
-	 * @return 包装类型数组
-	 */
-	public static Character[] wrap(char... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new Character[0];
-		}
-
-		final Character[] array = new Character[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = values[i];
-		}
-		return array;
-	}
-
-	/**
-	 * 包装类数组转为原始类型数组
-	 *
-	 * @param values 包装类型数组
-	 * @return 原始类型数组
-	 */
-	public static char[] unWrap(Character... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new char[0];
-		}
-
-		char[] array = new char[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = ObjectUtil.defaultIfNull(values[i], Character.MIN_VALUE);
-		}
-		return array;
-	}
-
-	/**
-	 * 将原始类型数组包装为包装类型
-	 *
-	 * @param values 原始类型数组
-	 * @return 包装类型数组
-	 */
-	public static Byte[] wrap(byte... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new Byte[0];
-		}
-
-		final Byte[] array = new Byte[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = values[i];
-		}
-		return array;
-	}
-
-	/**
-	 * 包装类数组转为原始类型数组
-	 *
-	 * @param values 包装类型数组
-	 * @return 原始类型数组
-	 */
-	public static byte[] unWrap(Byte... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new byte[0];
-		}
-
-		final byte[] array = new byte[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = ObjectUtil.defaultIfNull(values[i], (byte) 0);
-		}
-		return array;
-	}
-
-	/**
-	 * 将原始类型数组包装为包装类型
-	 *
-	 * @param values 原始类型数组
-	 * @return 包装类型数组
-	 */
-	public static Short[] wrap(short... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new Short[0];
-		}
-
-		final Short[] array = new Short[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = values[i];
-		}
-		return array;
-	}
-
-	/**
-	 * 包装类数组转为原始类型数组
-	 *
-	 * @param values 包装类型数组
-	 * @return 原始类型数组
-	 */
-	public static short[] unWrap(Short... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new short[0];
-		}
-
-		final short[] array = new short[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = ObjectUtil.defaultIfNull(values[i], (short) 0);
-		}
-		return array;
-	}
-
-	/**
-	 * 将原始类型数组包装为包装类型
-	 *
-	 * @param values 原始类型数组
-	 * @return 包装类型数组
-	 */
-	public static Float[] wrap(float... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new Float[0];
-		}
-
-		final Float[] array = new Float[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = values[i];
-		}
-		return array;
-	}
-
-	/**
-	 * 包装类数组转为原始类型数组
-	 *
-	 * @param values 包装类型数组
-	 * @return 原始类型数组
-	 */
-	public static float[] unWrap(Float... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new float[0];
-		}
-
-		final float[] array = new float[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = ObjectUtil.defaultIfNull(values[i], 0F);
-		}
-		return array;
-	}
-
-	/**
-	 * 将原始类型数组包装为包装类型
-	 *
-	 * @param values 原始类型数组
-	 * @return 包装类型数组
-	 */
-	public static Double[] wrap(double... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new Double[0];
-		}
-
-		final Double[] array = new Double[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = values[i];
-		}
-		return array;
-	}
-
-	/**
-	 * 包装类数组转为原始类型数组
-	 *
-	 * @param values 包装类型数组
-	 * @return 原始类型数组
-	 */
-	public static double[] unWrap(Double... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new double[0];
-		}
-
-		final double[] array = new double[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = ObjectUtil.defaultIfNull(values[i], 0D);
-		}
-		return array;
-	}
-
-	/**
-	 * 将原始类型数组包装为包装类型
-	 *
-	 * @param values 原始类型数组
-	 * @return 包装类型数组
-	 */
-	public static Boolean[] wrap(boolean... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new Boolean[0];
-		}
-
-		final Boolean[] array = new Boolean[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = values[i];
-		}
-		return array;
-	}
-
-	/**
-	 * 包装类数组转为原始类型数组
-	 *
-	 * @param values 包装类型数组
-	 * @return 原始类型数组
-	 */
-	public static boolean[] unWrap(Boolean... values) {
-		if (null == values) {
-			return null;
-		}
-		final int length = values.length;
-		if (0 == length) {
-			return new boolean[0];
-		}
-
-		final boolean[] array = new boolean[length];
-		for (int i = 0; i < length; i++) {
-			array[i] = ObjectUtil.defaultIfNull(values[i], false);
-		}
-		return array;
-	}
-
 	/**
 	 * 包装数组对象
 	 *
@@ -2263,286 +987,6 @@ public class ArrayUtil {
 		return Arrays.copyOfRange(array, start, end);
 	}
 
-	/**
-	 * 获取子数组
-	 *
-	 * @param array 数组
-	 * @param start 开始位置（包括）
-	 * @param end   结束位置（不包括）
-	 * @return 新的数组
-	 * @see Arrays#copyOfRange(Object[], int, int)
-	 * @since 4.5.2
-	 */
-	public static byte[] sub(byte[] array, int start, int end) {
-		int length = length(array);
-		if (start < 0) {
-			start += length;
-		}
-		if (end < 0) {
-			end += length;
-		}
-		if (start == length) {
-			return new byte[0];
-		}
-		if (start > end) {
-			int tmp = start;
-			start = end;
-			end = tmp;
-		}
-		if (end > length) {
-			if (start >= length) {
-				return new byte[0];
-			}
-			end = length;
-		}
-		return Arrays.copyOfRange(array, start, end);
-	}
-
-	/**
-	 * 获取子数组
-	 *
-	 * @param array 数组
-	 * @param start 开始位置（包括）
-	 * @param end   结束位置（不包括）
-	 * @return 新的数组
-	 * @see Arrays#copyOfRange(Object[], int, int)
-	 * @since 4.5.2
-	 */
-	public static int[] sub(int[] array, int start, int end) {
-		int length = length(array);
-		if (start < 0) {
-			start += length;
-		}
-		if (end < 0) {
-			end += length;
-		}
-		if (start == length) {
-			return new int[0];
-		}
-		if (start > end) {
-			int tmp = start;
-			start = end;
-			end = tmp;
-		}
-		if (end > length) {
-			if (start >= length) {
-				return new int[0];
-			}
-			end = length;
-		}
-		return Arrays.copyOfRange(array, start, end);
-	}
-
-	/**
-	 * 获取子数组
-	 *
-	 * @param array 数组
-	 * @param start 开始位置（包括）
-	 * @param end   结束位置（不包括）
-	 * @return 新的数组
-	 * @see Arrays#copyOfRange(Object[], int, int)
-	 * @since 4.5.2
-	 */
-	public static long[] sub(long[] array, int start, int end) {
-		int length = length(array);
-		if (start < 0) {
-			start += length;
-		}
-		if (end < 0) {
-			end += length;
-		}
-		if (start == length) {
-			return new long[0];
-		}
-		if (start > end) {
-			int tmp = start;
-			start = end;
-			end = tmp;
-		}
-		if (end > length) {
-			if (start >= length) {
-				return new long[0];
-			}
-			end = length;
-		}
-		return Arrays.copyOfRange(array, start, end);
-	}
-
-	/**
-	 * 获取子数组
-	 *
-	 * @param array 数组
-	 * @param start 开始位置（包括）
-	 * @param end   结束位置（不包括）
-	 * @return 新的数组
-	 * @see Arrays#copyOfRange(Object[], int, int)
-	 * @since 4.5.2
-	 */
-	public static short[] sub(short[] array, int start, int end) {
-		int length = length(array);
-		if (start < 0) {
-			start += length;
-		}
-		if (end < 0) {
-			end += length;
-		}
-		if (start == length) {
-			return new short[0];
-		}
-		if (start > end) {
-			int tmp = start;
-			start = end;
-			end = tmp;
-		}
-		if (end > length) {
-			if (start >= length) {
-				return new short[0];
-			}
-			end = length;
-		}
-		return Arrays.copyOfRange(array, start, end);
-	}
-
-	/**
-	 * 获取子数组
-	 *
-	 * @param array 数组
-	 * @param start 开始位置（包括）
-	 * @param end   结束位置（不包括）
-	 * @return 新的数组
-	 * @see Arrays#copyOfRange(Object[], int, int)
-	 * @since 4.5.2
-	 */
-	public static char[] sub(char[] array, int start, int end) {
-		int length = length(array);
-		if (start < 0) {
-			start += length;
-		}
-		if (end < 0) {
-			end += length;
-		}
-		if (start == length) {
-			return new char[0];
-		}
-		if (start > end) {
-			int tmp = start;
-			start = end;
-			end = tmp;
-		}
-		if (end > length) {
-			if (start >= length) {
-				return new char[0];
-			}
-			end = length;
-		}
-		return Arrays.copyOfRange(array, start, end);
-	}
-
-	/**
-	 * 获取子数组
-	 *
-	 * @param array 数组
-	 * @param start 开始位置（包括）
-	 * @param end   结束位置（不包括）
-	 * @return 新的数组
-	 * @see Arrays#copyOfRange(Object[], int, int)
-	 * @since 4.5.2
-	 */
-	public static double[] sub(double[] array, int start, int end) {
-		int length = length(array);
-		if (start < 0) {
-			start += length;
-		}
-		if (end < 0) {
-			end += length;
-		}
-		if (start == length) {
-			return new double[0];
-		}
-		if (start > end) {
-			int tmp = start;
-			start = end;
-			end = tmp;
-		}
-		if (end > length) {
-			if (start >= length) {
-				return new double[0];
-			}
-			end = length;
-		}
-		return Arrays.copyOfRange(array, start, end);
-	}
-
-	/**
-	 * 获取子数组
-	 *
-	 * @param array 数组
-	 * @param start 开始位置（包括）
-	 * @param end   结束位置（不包括）
-	 * @return 新的数组
-	 * @see Arrays#copyOfRange(Object[], int, int)
-	 * @since 4.5.2
-	 */
-	public static float[] sub(float[] array, int start, int end) {
-		int length = length(array);
-		if (start < 0) {
-			start += length;
-		}
-		if (end < 0) {
-			end += length;
-		}
-		if (start == length) {
-			return new float[0];
-		}
-		if (start > end) {
-			int tmp = start;
-			start = end;
-			end = tmp;
-		}
-		if (end > length) {
-			if (start >= length) {
-				return new float[0];
-			}
-			end = length;
-		}
-		return Arrays.copyOfRange(array, start, end);
-	}
-
-	/**
-	 * 获取子数组
-	 *
-	 * @param array 数组
-	 * @param start 开始位置（包括）
-	 * @param end   结束位置（不包括）
-	 * @return 新的数组
-	 * @see Arrays#copyOfRange(Object[], int, int)
-	 * @since 4.5.2
-	 */
-	public static boolean[] sub(boolean[] array, int start, int end) {
-		int length = length(array);
-		if (start < 0) {
-			start += length;
-		}
-		if (end < 0) {
-			end += length;
-		}
-		if (start == length) {
-			return new boolean[0];
-		}
-		if (start > end) {
-			int tmp = start;
-			start = end;
-			end = tmp;
-		}
-		if (end > length) {
-			if (start >= length) {
-				return new boolean[0];
-			}
-			end = length;
-		}
-		return Arrays.copyOfRange(array, start, end);
-	}
-
 	/**
 	 * 获取子数组
 	 *
@@ -2773,181 +1217,6 @@ public class ArrayUtil {
 		return sb.toString();
 	}
 
-	/**
-	 * 以 conjunction 为分隔符将数组转换为字符串
-	 *
-	 * @param array       数组
-	 * @param conjunction 分隔符
-	 * @return 连接后的字符串
-	 */
-	public static String join(int[] array, CharSequence conjunction) {
-		if (null == array) {
-			return null;
-		}
-
-		final StringBuilder sb = new StringBuilder();
-		boolean isFirst = true;
-		for (int item : array) {
-			if (isFirst) {
-				isFirst = false;
-			} else {
-				sb.append(conjunction);
-			}
-			sb.append(item);
-		}
-		return sb.toString();
-	}
-
-	/**
-	 * 以 conjunction 为分隔符将数组转换为字符串
-	 *
-	 * @param array       数组
-	 * @param conjunction 分隔符
-	 * @return 连接后的字符串
-	 */
-	public static String join(short[] array, CharSequence conjunction) {
-		if (null == array) {
-			return null;
-		}
-
-		final StringBuilder sb = new StringBuilder();
-		boolean isFirst = true;
-		for (short item : array) {
-			if (isFirst) {
-				isFirst = false;
-			} else {
-				sb.append(conjunction);
-			}
-			sb.append(item);
-		}
-		return sb.toString();
-	}
-
-	/**
-	 * 以 conjunction 为分隔符将数组转换为字符串
-	 *
-	 * @param array       数组
-	 * @param conjunction 分隔符
-	 * @return 连接后的字符串
-	 */
-	public static String join(char[] array, CharSequence conjunction) {
-		if (null == array) {
-			return null;
-		}
-
-		final StringBuilder sb = new StringBuilder();
-		boolean isFirst = true;
-		for (char item : array) {
-			if (isFirst) {
-				isFirst = false;
-			} else {
-				sb.append(conjunction);
-			}
-			sb.append(item);
-		}
-		return sb.toString();
-	}
-
-	/**
-	 * 以 conjunction 为分隔符将数组转换为字符串
-	 *
-	 * @param array       数组
-	 * @param conjunction 分隔符
-	 * @return 连接后的字符串
-	 */
-	public static String join(byte[] array, CharSequence conjunction) {
-		if (null == array) {
-			return null;
-		}
-
-		final StringBuilder sb = new StringBuilder();
-		boolean isFirst = true;
-		for (byte item : array) {
-			if (isFirst) {
-				isFirst = false;
-			} else {
-				sb.append(conjunction);
-			}
-			sb.append(item);
-		}
-		return sb.toString();
-	}
-
-	/**
-	 * 以 conjunction 为分隔符将数组转换为字符串
-	 *
-	 * @param array       数组
-	 * @param conjunction 分隔符
-	 * @return 连接后的字符串
-	 */
-	public static String join(boolean[] array, CharSequence conjunction) {
-		if (null == array) {
-			return null;
-		}
-
-		final StringBuilder sb = new StringBuilder();
-		boolean isFirst = true;
-		for (boolean item : array) {
-			if (isFirst) {
-				isFirst = false;
-			} else {
-				sb.append(conjunction);
-			}
-			sb.append(item);
-		}
-		return sb.toString();
-	}
-
-	/**
-	 * 以 conjunction 为分隔符将数组转换为字符串
-	 *
-	 * @param array       数组
-	 * @param conjunction 分隔符
-	 * @return 连接后的字符串
-	 */
-	public static String join(float[] array, CharSequence conjunction) {
-		if (null == array) {
-			return null;
-		}
-
-		final StringBuilder sb = new StringBuilder();
-		boolean isFirst = true;
-		for (float item : array) {
-			if (isFirst) {
-				isFirst = false;
-			} else {
-				sb.append(conjunction);
-			}
-			sb.append(item);
-		}
-		return sb.toString();
-	}
-
-	/**
-	 * 以 conjunction 为分隔符将数组转换为字符串
-	 *
-	 * @param array       数组
-	 * @param conjunction 分隔符
-	 * @return 连接后的字符串
-	 */
-	public static String join(double[] array, CharSequence conjunction) {
-		if (null == array) {
-			return null;
-		}
-
-		final StringBuilder sb = new StringBuilder();
-		boolean isFirst = true;
-		for (double item : array) {
-			if (isFirst) {
-				isFirst = false;
-			} else {
-				sb.append(conjunction);
-			}
-			sb.append(item);
-		}
-		return sb.toString();
-	}
-
 	/**
 	 * 以 conjunction 为分隔符将数组转换为字符串
 	 *
@@ -3065,149 +1334,7 @@ public class ArrayUtil {
 		return (T[]) remove((Object) array, index);
 	}
 
-	/**
-	 * 移除数组中对应位置的元素<br>
-	 * copy from commons-lang
-	 *
-	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
-	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static long[] remove(long[] array, int index) throws IllegalArgumentException {
-		return (long[]) remove((Object) array, index);
-	}
-
-	/**
-	 * 移除数组中对应位置的元素<br>
-	 * copy from commons-lang
-	 *
-	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
-	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static int[] remove(int[] array, int index) throws IllegalArgumentException {
-		return (int[]) remove((Object) array, index);
-	}
-
-	/**
-	 * 移除数组中对应位置的元素<br>
-	 * copy from commons-lang
-	 *
-	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
-	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static short[] remove(short[] array, int index) throws IllegalArgumentException {
-		return (short[]) remove((Object) array, index);
-	}
-
-	/**
-	 * 移除数组中对应位置的元素<br>
-	 * copy from commons-lang
-	 *
-	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
-	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static char[] remove(char[] array, int index) throws IllegalArgumentException {
-		return (char[]) remove((Object) array, index);
-	}
-
-	/**
-	 * 移除数组中对应位置的元素<br>
-	 * copy from commons-lang
-	 *
-	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
-	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static byte[] remove(byte[] array, int index) throws IllegalArgumentException {
-		return (byte[]) remove((Object) array, index);
-	}
-
-	/**
-	 * 移除数组中对应位置的元素<br>
-	 * copy from commons-lang
-	 *
-	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
-	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static double[] remove(double[] array, int index) throws IllegalArgumentException {
-		return (double[]) remove((Object) array, index);
-	}
-
-	/**
-	 * 移除数组中对应位置的元素<br>
-	 * copy from commons-lang
-	 *
-	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
-	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static float[] remove(float[] array, int index) throws IllegalArgumentException {
-		return (float[]) remove((Object) array, index);
-	}
-
-	/**
-	 * 移除数组中对应位置的元素<br>
-	 * copy from commons-lang
-	 *
-	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
-	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static boolean[] remove(boolean[] array, int index) throws IllegalArgumentException {
-		return (boolean[]) remove((Object) array, index);
-	}
-
-	/**
-	 * 移除数组中对应位置的元素<br>
-	 * copy from commons-lang
-	 *
-	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
-	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	@SuppressWarnings("SuspiciousSystemArraycopy")
-	public static Object remove(Object array, int index) throws IllegalArgumentException {
-		if (null == array) {
-			return null;
-		}
-		int length = length(array);
-		if (index < 0 || index >= length) {
-			return array;
-		}
-
-		final Object result = Array.newInstance(array.getClass().getComponentType(), length - 1);
-		System.arraycopy(array, 0, result, 0, index);
-		if (index < length - 1) {
-			// 后半部分
-			System.arraycopy(array, index + 1, result, index, length - index - 1);
-		}
-
-		return result;
-	}
-
-	// ---------------------------------------------------------------------- remove
+	// ---------------------------------------------------------------------- removeEle
 
 	/**
 	 * 移除数组中指定的元素<br>
@@ -3224,119 +1351,7 @@ public class ArrayUtil {
 		return remove(array, indexOf(array, element));
 	}
 
-	/**
-	 * 移除数组中指定的元素<br>
-	 * 只会移除匹配到的第一个元素 copy from commons-lang
-	 *
-	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
-	 * @param element 要移除的元素
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static long[] removeEle(long[] array, long element) throws IllegalArgumentException {
-		return remove(array, indexOf(array, element));
-	}
-
-	/**
-	 * 移除数组中指定的元素<br>
-	 * 只会移除匹配到的第一个元素 copy from commons-lang
-	 *
-	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
-	 * @param element 要移除的元素
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static int[] removeEle(int[] array, int element) throws IllegalArgumentException {
-		return remove(array, indexOf(array, element));
-	}
-
-	/**
-	 * 移除数组中指定的元素<br>
-	 * 只会移除匹配到的第一个元素 copy from commons-lang
-	 *
-	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
-	 * @param element 要移除的元素
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static short[] removeEle(short[] array, short element) throws IllegalArgumentException {
-		return remove(array, indexOf(array, element));
-	}
-
-	/**
-	 * 移除数组中指定的元素<br>
-	 * 只会移除匹配到的第一个元素 copy from commons-lang
-	 *
-	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
-	 * @param element 要移除的元素
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static char[] removeEle(char[] array, char element) throws IllegalArgumentException {
-		return remove(array, indexOf(array, element));
-	}
-
-	/**
-	 * 移除数组中指定的元素<br>
-	 * 只会移除匹配到的第一个元素 copy from commons-lang
-	 *
-	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
-	 * @param element 要移除的元素
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static byte[] removeEle(byte[] array, byte element) throws IllegalArgumentException {
-		return remove(array, indexOf(array, element));
-	}
-
-	/**
-	 * 移除数组中指定的元素<br>
-	 * 只会移除匹配到的第一个元素 copy from commons-lang
-	 *
-	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
-	 * @param element 要移除的元素
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static double[] removeEle(double[] array, double element) throws IllegalArgumentException {
-		return remove(array, indexOf(array, element));
-	}
-
-	/**
-	 * 移除数组中指定的元素<br>
-	 * 只会移除匹配到的第一个元素 copy from commons-lang
-	 *
-	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
-	 * @param element 要移除的元素
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static float[] removeEle(float[] array, float element) throws IllegalArgumentException {
-		return remove(array, indexOf(array, element));
-	}
-
-	/**
-	 * 移除数组中指定的元素<br>
-	 * 只会移除匹配到的第一个元素 copy from commons-lang
-	 *
-	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
-	 * @param element 要移除的元素
-	 * @return 去掉指定元素后的新数组或原数组
-	 * @throws IllegalArgumentException 参数对象不为数组对象
-	 * @since 3.0.8
-	 */
-	public static boolean[] removeEle(boolean[] array, boolean element) throws IllegalArgumentException {
-		return remove(array, indexOf(array, element));
-	}
-
-	// ------------------------------------------------------------------------------------------------------------ Reverse array
+	// ---------------------------------------------------------------------- Reverse array
 
 	/**
 	 * 反转数组，会变更原数组
@@ -3348,7 +1363,7 @@ public class ArrayUtil {
 	 * @return 变更后的原数组
 	 * @since 3.0.9
 	 */
-	public static <T> T[] reverse(final T[] array, final int startIndexInclusive, final int endIndexExclusive) {
+	public static <T> T[] reverse(T[] array, final int startIndexInclusive, final int endIndexExclusive) {
 		if (isEmpty(array)) {
 			return array;
 		}
@@ -3373,303 +1388,7 @@ public class ArrayUtil {
 	 * @return 变更后的原数组
 	 * @since 3.0.9
 	 */
-	public static <T> T[] reverse(final T[] array) {
-		return reverse(array, 0, array.length);
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array               数组，会变更
-	 * @param startIndexInclusive 其实位置（包含）
-	 * @param endIndexExclusive   结束位置（不包含）
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static long[] reverse(final long[] array, final int startIndexInclusive, final int endIndexExclusive) {
-		if (isEmpty(array)) {
-			return array;
-		}
-		int i = Math.max(startIndexInclusive, 0);
-		int j = Math.min(array.length, endIndexExclusive) - 1;
-		long tmp;
-		while (j > i) {
-			tmp = array[j];
-			array[j] = array[i];
-			array[i] = tmp;
-			j--;
-			i++;
-		}
-		return array;
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static long[] reverse(final long[] array) {
-		return reverse(array, 0, array.length);
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array               数组，会变更
-	 * @param startIndexInclusive 其实位置（包含）
-	 * @param endIndexExclusive   结束位置（不包含）
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static int[] reverse(final int[] array, final int startIndexInclusive, final int endIndexExclusive) {
-		if (isEmpty(array)) {
-			return array;
-		}
-		int i = Math.max(startIndexInclusive, 0);
-		int j = Math.min(array.length, endIndexExclusive) - 1;
-		int tmp;
-		while (j > i) {
-			tmp = array[j];
-			array[j] = array[i];
-			array[i] = tmp;
-			j--;
-			i++;
-		}
-		return array;
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static int[] reverse(final int[] array) {
-		return reverse(array, 0, array.length);
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array               数组，会变更
-	 * @param startIndexInclusive 其实位置（包含）
-	 * @param endIndexExclusive   结束位置（不包含）
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static short[] reverse(final short[] array, final int startIndexInclusive, final int endIndexExclusive) {
-		if (isEmpty(array)) {
-			return array;
-		}
-		int i = Math.max(startIndexInclusive, 0);
-		int j = Math.min(array.length, endIndexExclusive) - 1;
-		short tmp;
-		while (j > i) {
-			tmp = array[j];
-			array[j] = array[i];
-			array[i] = tmp;
-			j--;
-			i++;
-		}
-		return array;
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static short[] reverse(final short[] array) {
-		return reverse(array, 0, array.length);
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array               数组，会变更
-	 * @param startIndexInclusive 其实位置（包含）
-	 * @param endIndexExclusive   结束位置（不包含）
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static char[] reverse(final char[] array, final int startIndexInclusive, final int endIndexExclusive) {
-		if (isEmpty(array)) {
-			return array;
-		}
-		int i = Math.max(startIndexInclusive, 0);
-		int j = Math.min(array.length, endIndexExclusive) - 1;
-		char tmp;
-		while (j > i) {
-			tmp = array[j];
-			array[j] = array[i];
-			array[i] = tmp;
-			j--;
-			i++;
-		}
-		return array;
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static char[] reverse(final char[] array) {
-		return reverse(array, 0, array.length);
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array               数组，会变更
-	 * @param startIndexInclusive 其实位置（包含）
-	 * @param endIndexExclusive   结束位置（不包含）
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static byte[] reverse(final byte[] array, final int startIndexInclusive, final int endIndexExclusive) {
-		if (isEmpty(array)) {
-			return array;
-		}
-		int i = Math.max(startIndexInclusive, 0);
-		int j = Math.min(array.length, endIndexExclusive) - 1;
-		byte tmp;
-		while (j > i) {
-			tmp = array[j];
-			array[j] = array[i];
-			array[i] = tmp;
-			j--;
-			i++;
-		}
-		return array;
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static byte[] reverse(final byte[] array) {
-		return reverse(array, 0, array.length);
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array               数组，会变更
-	 * @param startIndexInclusive 其实位置（包含）
-	 * @param endIndexExclusive   结束位置（不包含）
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static double[] reverse(final double[] array, final int startIndexInclusive, final int endIndexExclusive) {
-		if (isEmpty(array)) {
-			return array;
-		}
-		int i = Math.max(startIndexInclusive, 0);
-		int j = Math.min(array.length, endIndexExclusive) - 1;
-		double tmp;
-		while (j > i) {
-			tmp = array[j];
-			array[j] = array[i];
-			array[i] = tmp;
-			j--;
-			i++;
-		}
-		return array;
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static double[] reverse(final double[] array) {
-		return reverse(array, 0, array.length);
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array               数组，会变更
-	 * @param startIndexInclusive 其实位置（包含）
-	 * @param endIndexExclusive   结束位置（不包含）
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static float[] reverse(final float[] array, final int startIndexInclusive, final int endIndexExclusive) {
-		if (isEmpty(array)) {
-			return array;
-		}
-		int i = Math.max(startIndexInclusive, 0);
-		int j = Math.min(array.length, endIndexExclusive) - 1;
-		float tmp;
-		while (j > i) {
-			tmp = array[j];
-			array[j] = array[i];
-			array[i] = tmp;
-			j--;
-			i++;
-		}
-		return array;
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static float[] reverse(final float[] array) {
-		return reverse(array, 0, array.length);
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array               数组，会变更
-	 * @param startIndexInclusive 其实位置（包含）
-	 * @param endIndexExclusive   结束位置（不包含）
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static boolean[] reverse(final boolean[] array, final int startIndexInclusive, final int endIndexExclusive) {
-		if (isEmpty(array)) {
-			return array;
-		}
-		int i = Math.max(startIndexInclusive, 0);
-		int j = Math.min(array.length, endIndexExclusive) - 1;
-		boolean tmp;
-		while (j > i) {
-			tmp = array[j];
-			array[j] = array[i];
-			array[i] = tmp;
-			j--;
-			i++;
-		}
-		return array;
-	}
-
-	/**
-	 * 反转数组，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 变更后的原数组
-	 * @since 3.0.9
-	 */
-	public static boolean[] reverse(final boolean[] array) {
+	public static <T> T[] reverse(T[] array) {
 		return reverse(array, 0, array.length);
 	}
 
@@ -3709,146 +1428,6 @@ public class ArrayUtil {
 		return min;
 	}
 
-	/**
-	 * 取最小值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最小值
-	 * @since 3.0.9
-	 */
-	public static long min(long... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		long min = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (min > numberArray[i]) {
-				min = numberArray[i];
-			}
-		}
-		return min;
-	}
-
-	/**
-	 * 取最小值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最小值
-	 * @since 3.0.9
-	 */
-	public static int min(int... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		int min = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (min > numberArray[i]) {
-				min = numberArray[i];
-			}
-		}
-		return min;
-	}
-
-	/**
-	 * 取最小值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最小值
-	 * @since 3.0.9
-	 */
-	public static short min(short... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		short min = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (min > numberArray[i]) {
-				min = numberArray[i];
-			}
-		}
-		return min;
-	}
-
-	/**
-	 * 取最小值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最小值
-	 * @since 3.0.9
-	 */
-	public static char min(char... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		char min = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (min > numberArray[i]) {
-				min = numberArray[i];
-			}
-		}
-		return min;
-	}
-
-	/**
-	 * 取最小值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最小值
-	 * @since 3.0.9
-	 */
-	public static byte min(byte... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		byte min = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (min > numberArray[i]) {
-				min = numberArray[i];
-			}
-		}
-		return min;
-	}
-
-	/**
-	 * 取最小值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最小值
-	 * @since 3.0.9
-	 */
-	public static double min(double... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		double min = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (min > numberArray[i]) {
-				min = numberArray[i];
-			}
-		}
-		return min;
-	}
-
-	/**
-	 * 取最小值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最小值
-	 * @since 3.0.9
-	 */
-	public static float min(float... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		float min = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (min > numberArray[i]) {
-				min = numberArray[i];
-			}
-		}
-		return min;
-	}
-
 	/**
 	 * 取最大值
 	 *
@@ -3883,417 +1462,12 @@ public class ArrayUtil {
 		return max;
 	}
 
-	/**
-	 * 取最大值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最大值
-	 * @since 3.0.9
-	 */
-	public static long max(long... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		long max = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (max < numberArray[i]) {
-				max = numberArray[i];
-			}
-		}
-		return max;
-	}
-
-	/**
-	 * 取最大值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最大值
-	 * @since 3.0.9
-	 */
-	public static int max(int... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		int max = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (max < numberArray[i]) {
-				max = numberArray[i];
-			}
-		}
-		return max;
-	}
-
-	/**
-	 * 取最大值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最大值
-	 * @since 3.0.9
-	 */
-	public static short max(short... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		short max = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (max < numberArray[i]) {
-				max = numberArray[i];
-			}
-		}
-		return max;
-	}
-
-	/**
-	 * 取最大值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最大值
-	 * @since 3.0.9
-	 */
-	public static char max(char... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		char max = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (max < numberArray[i]) {
-				max = numberArray[i];
-			}
-		}
-		return max;
-	}
-
-	/**
-	 * 取最大值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最大值
-	 * @since 3.0.9
-	 */
-	public static byte max(byte... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		byte max = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (max < numberArray[i]) {
-				max = numberArray[i];
-			}
-		}
-		return max;
-	}
-
-	/**
-	 * 取最大值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最大值
-	 * @since 3.0.9
-	 */
-	public static double max(double... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		double max = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (max < numberArray[i]) {
-				max = numberArray[i];
-			}
-		}
-		return max;
-	}
-
-	/**
-	 * 取最大值
-	 *
-	 * @param numberArray 数字数组
-	 * @return 最大值
-	 * @since 3.0.9
-	 */
-	public static float max(float... numberArray) {
-		if (isEmpty(numberArray)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		float max = numberArray[0];
-		for (int i = 1; i < numberArray.length; i++) {
-			if (max < numberArray[i]) {
-				max = numberArray[i];
-			}
-		}
-		return max;
-	}
-
-
 	// 使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序
 
 	/**
 	 * 打乱数组顺序，会变更原数组
 	 *
-	 * @param array 数组，会变更
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static int[] shuffle(int[] array) {
-		return shuffle(array, RandomUtil.getRandom());
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array  数组，会变更
-	 * @param random 随机数生成器
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static int[] shuffle(int[] array, Random random) {
-		if (array == null || random == null || array.length <= 1) {
-			return array;
-		}
-
-		for (int i = array.length; i > 1; i--) {
-			swap(array, i - 1, random.nextInt(i));
-		}
-
-		return array;
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static long[] shuffle(long[] array) {
-		return shuffle(array, RandomUtil.getRandom());
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array  数组，会变更
-	 * @param random 随机数生成器
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static long[] shuffle(long[] array, Random random) {
-		if (array == null || random == null || array.length <= 1) {
-			return array;
-		}
-
-		for (int i = array.length; i > 1; i--) {
-			swap(array, i - 1, random.nextInt(i));
-		}
-
-		return array;
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static double[] shuffle(double[] array) {
-		return shuffle(array, RandomUtil.getRandom());
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array  数组，会变更
-	 * @param random 随机数生成器
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static double[] shuffle(double[] array, Random random) {
-		if (array == null || random == null || array.length <= 1) {
-			return array;
-		}
-
-		for (int i = array.length; i > 1; i--) {
-			swap(array, i - 1, random.nextInt(i));
-		}
-
-		return array;
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static float[] shuffle(float[] array) {
-		return shuffle(array, RandomUtil.getRandom());
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array  数组，会变更
-	 * @param random 随机数生成器
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static float[] shuffle(float[] array, Random random) {
-		if (array == null || random == null || array.length <= 1) {
-			return array;
-		}
-
-		for (int i = array.length; i > 1; i--) {
-			swap(array, i - 1, random.nextInt(i));
-		}
-
-		return array;
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean[] shuffle(boolean[] array) {
-		return shuffle(array, RandomUtil.getRandom());
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array  数组，会变更
-	 * @param random 随机数生成器
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean[] shuffle(boolean[] array, Random random) {
-		if (array == null || random == null || array.length <= 1) {
-			return array;
-		}
-
-		for (int i = array.length; i > 1; i--) {
-			swap(array, i - 1, random.nextInt(i));
-		}
-
-		return array;
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static byte[] shuffle(byte[] array) {
-		return shuffle(array, RandomUtil.getRandom());
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array  数组，会变更
-	 * @param random 随机数生成器
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static byte[] shuffle(byte[] array, Random random) {
-		if (array == null || random == null || array.length <= 1) {
-			return array;
-		}
-
-		for (int i = array.length; i > 1; i--) {
-			swap(array, i - 1, random.nextInt(i));
-		}
-
-		return array;
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static char[] shuffle(char[] array) {
-		return shuffle(array, RandomUtil.getRandom());
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array  数组，会变更
-	 * @param random 随机数生成器
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static char[] shuffle(char[] array, Random random) {
-		if (array == null || random == null || array.length <= 1) {
-			return array;
-		}
-
-		for (int i = array.length; i > 1; i--) {
-			swap(array, i - 1, random.nextInt(i));
-		}
-
-		return array;
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array 数组，会变更
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static short[] shuffle(short[] array) {
-		return shuffle(array, RandomUtil.getRandom());
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param array  数组，会变更
-	 * @param random 随机数生成器
-	 * @return 打乱后的数组
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static short[] shuffle(short[] array, Random random) {
-		if (array == null || random == null || array.length <= 1) {
-			return array;
-		}
-
-		for (int i = array.length; i > 1; i--) {
-			swap(array, i - 1, random.nextInt(i));
-		}
-
-		return array;
-	}
-
-	/**
-	 * 打乱数组顺序，会变更原数组
-	 *
-	 * @param <T> 元素类型
+	 * @param <T>   元素类型
 	 * @param array 数组，会变更
 	 * @return 打乱后的数组
 	 * @author FengBaoheng
@@ -4306,7 +1480,7 @@ public class ArrayUtil {
 	/**
 	 * 打乱数组顺序，会变更原数组
 	 *
-	 * @param <T> 元素类型
+	 * @param <T>    元素类型
 	 * @param array  数组，会变更
 	 * @param random 随机数生成器
 	 * @return 打乱后的数组
@@ -4325,158 +1499,6 @@ public class ArrayUtil {
 		return array;
 	}
 
-	/**
-	 * 交换数组中两个位置的值
-	 *
-	 * @param array  数组
-	 * @param index1 位置1
-	 * @param index2 位置2
-	 * @return 交换后的数组，与传入数组为同一对象
-	 * @since 4.0.7
-	 */
-	public static int[] swap(int[] array, int index1, int index2) {
-		if (isEmpty(array)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		int tmp = array[index1];
-		array[index1] = array[index2];
-		array[index2] = tmp;
-		return array;
-	}
-
-	/**
-	 * 交换数组中两个位置的值
-	 *
-	 * @param array  数组
-	 * @param index1 位置1
-	 * @param index2 位置2
-	 * @return 交换后的数组，与传入数组为同一对象
-	 * @since 4.0.7
-	 */
-	public static long[] swap(long[] array, int index1, int index2) {
-		if (isEmpty(array)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		long tmp = array[index1];
-		array[index1] = array[index2];
-		array[index2] = tmp;
-		return array;
-	}
-
-	/**
-	 * 交换数组中两个位置的值
-	 *
-	 * @param array  数组
-	 * @param index1 位置1
-	 * @param index2 位置2
-	 * @return 交换后的数组，与传入数组为同一对象
-	 * @since 4.0.7
-	 */
-	public static double[] swap(double[] array, int index1, int index2) {
-		if (isEmpty(array)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		double tmp = array[index1];
-		array[index1] = array[index2];
-		array[index2] = tmp;
-		return array;
-	}
-
-	/**
-	 * 交换数组中两个位置的值
-	 *
-	 * @param array  数组
-	 * @param index1 位置1
-	 * @param index2 位置2
-	 * @return 交换后的数组，与传入数组为同一对象
-	 * @since 4.0.7
-	 */
-	public static float[] swap(float[] array, int index1, int index2) {
-		if (isEmpty(array)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		float tmp = array[index1];
-		array[index1] = array[index2];
-		array[index2] = tmp;
-		return array;
-	}
-
-	/**
-	 * 交换数组中两个位置的值
-	 *
-	 * @param array  数组
-	 * @param index1 位置1
-	 * @param index2 位置2
-	 * @return 交换后的数组，与传入数组为同一对象
-	 * @since 4.0.7
-	 */
-	public static boolean[] swap(boolean[] array, int index1, int index2) {
-		if (isEmpty(array)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		boolean tmp = array[index1];
-		array[index1] = array[index2];
-		array[index2] = tmp;
-		return array;
-	}
-
-	/**
-	 * 交换数组中两个位置的值
-	 *
-	 * @param array  数组
-	 * @param index1 位置1
-	 * @param index2 位置2
-	 * @return 交换后的数组，与传入数组为同一对象
-	 * @since 4.0.7
-	 */
-	public static byte[] swap(byte[] array, int index1, int index2) {
-		if (isEmpty(array)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		byte tmp = array[index1];
-		array[index1] = array[index2];
-		array[index2] = tmp;
-		return array;
-	}
-
-	/**
-	 * 交换数组中两个位置的值
-	 *
-	 * @param array  数组
-	 * @param index1 位置1
-	 * @param index2 位置2
-	 * @return 交换后的数组，与传入数组为同一对象
-	 * @since 4.0.7
-	 */
-	public static char[] swap(char[] array, int index1, int index2) {
-		if (isEmpty(array)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		char tmp = array[index1];
-		array[index1] = array[index2];
-		array[index2] = tmp;
-		return array;
-	}
-
-	/**
-	 * 交换数组中两个位置的值
-	 *
-	 * @param array  数组
-	 * @param index1 位置1
-	 * @param index2 位置2
-	 * @return 交换后的数组，与传入数组为同一对象
-	 * @since 4.0.7
-	 */
-	public static short[] swap(short[] array, int index1, int index2) {
-		if (isEmpty(array)) {
-			throw new IllegalArgumentException("Number array must not empty !");
-		}
-		short tmp = array[index1];
-		array[index1] = array[index2];
-		array[index2] = tmp;
-		return array;
-	}
-
 	/**
 	 * 交换数组中两个位置的值
 	 *
@@ -4575,6 +1597,19 @@ public class ArrayUtil {
 		return false == hasEmpty(args);
 	}
 
+	/**
+	 * 多个字段是否全部不为null
+	 *
+	 * @param <T>   数组元素类型
+	 * @param array 被检查的数组
+	 * @return 多个字段是否全部不为null
+	 * @since 5.4.0
+	 */
+	@SuppressWarnings("unchecked")
+	public static <T> boolean isAllNotNull(T... array) {
+		return false == hasNull(array);
+	}
+
 	/**
 	 * 去重数组中的元素，去重后生成新的数组，原数组不变<br>
 	 * 此方法通过{@link LinkedHashSet} 去重
@@ -4594,20 +1629,6 @@ public class ArrayUtil {
 		return toArray(set, (Class<T>) getComponentType(array));
 	}
 
-
-	/**
-	 * 多个字段是否全部不为null
-	 *
-	 * @param <T>   数组元素类型
-	 * @param array 被检查的数组
-	 * @return 多个字段是否全部不为null
-	 * @since 5.4.0
-	 */
-	@SuppressWarnings("unchecked")
-	public static <T> boolean isAllNotNull(T... array) {
-		return false == hasNull(array);
-	}
-
 	/**
 	 * 按照指定规则，将一种类型的数组转换为另一种类型
 	 *
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/PrimitiveArrayUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/PrimitiveArrayUtil.java
new file mode 100644
index 000000000..b77130d3a
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/util/PrimitiveArrayUtil.java
@@ -0,0 +1,3022 @@
+package cn.hutool.core.util;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.Random;
+
+/**
+ * 原始类型数组工具类
+ *
+ * @author looly
+ * @since 5.5.2
+ */
+public class PrimitiveArrayUtil {
+	/**
+	 * 数组中元素未找到的下标，值为-1
+	 */
+	public static final int INDEX_NOT_FOUND = -1;
+
+	// ---------------------------------------------------------------------- isEmpty
+
+	/**
+	 * 数组是否为空
+	 *
+	 * @param array 数组
+	 * @return 是否为空
+	 */
+	public static boolean isEmpty(long[] array) {
+		return array == null || array.length == 0;
+	}
+
+	/**
+	 * 数组是否为空
+	 *
+	 * @param array 数组
+	 * @return 是否为空
+	 */
+	public static boolean isEmpty(int[] array) {
+		return array == null || array.length == 0;
+	}
+
+	/**
+	 * 数组是否为空
+	 *
+	 * @param array 数组
+	 * @return 是否为空
+	 */
+	public static boolean isEmpty(short[] array) {
+		return array == null || array.length == 0;
+	}
+
+	/**
+	 * 数组是否为空
+	 *
+	 * @param array 数组
+	 * @return 是否为空
+	 */
+	public static boolean isEmpty(char[] array) {
+		return array == null || array.length == 0;
+	}
+
+	/**
+	 * 数组是否为空
+	 *
+	 * @param array 数组
+	 * @return 是否为空
+	 */
+	public static boolean isEmpty(byte[] array) {
+		return array == null || array.length == 0;
+	}
+
+	/**
+	 * 数组是否为空
+	 *
+	 * @param array 数组
+	 * @return 是否为空
+	 */
+	public static boolean isEmpty(double[] array) {
+		return array == null || array.length == 0;
+	}
+
+	/**
+	 * 数组是否为空
+	 *
+	 * @param array 数组
+	 * @return 是否为空
+	 */
+	public static boolean isEmpty(float[] array) {
+		return array == null || array.length == 0;
+	}
+
+	/**
+	 * 数组是否为空
+	 *
+	 * @param array 数组
+	 * @return 是否为空
+	 */
+	public static boolean isEmpty(boolean[] array) {
+		return array == null || array.length == 0;
+	}
+
+	// ---------------------------------------------------------------------- isNotEmpty
+
+	/**
+	 * 数组是否为非空
+	 *
+	 * @param array 数组
+	 * @return 是否为非空
+	 */
+	public static boolean isNotEmpty(long[] array) {
+		return false == isEmpty(array);
+	}
+
+	/**
+	 * 数组是否为非空
+	 *
+	 * @param array 数组
+	 * @return 是否为非空
+	 */
+	public static boolean isNotEmpty(int[] array) {
+		return false == isEmpty(array);
+	}
+
+	/**
+	 * 数组是否为非空
+	 *
+	 * @param array 数组
+	 * @return 是否为非空
+	 */
+	public static boolean isNotEmpty(short[] array) {
+		return false == isEmpty(array);
+	}
+
+	/**
+	 * 数组是否为非空
+	 *
+	 * @param array 数组
+	 * @return 是否为非空
+	 */
+	public static boolean isNotEmpty(char[] array) {
+		return false == isEmpty(array);
+	}
+
+	/**
+	 * 数组是否为非空
+	 *
+	 * @param array 数组
+	 * @return 是否为非空
+	 */
+	public static boolean isNotEmpty(byte[] array) {
+		return false == isEmpty(array);
+	}
+
+	/**
+	 * 数组是否为非空
+	 *
+	 * @param array 数组
+	 * @return 是否为非空
+	 */
+	public static boolean isNotEmpty(double[] array) {
+		return false == isEmpty(array);
+	}
+
+	/**
+	 * 数组是否为非空
+	 *
+	 * @param array 数组
+	 * @return 是否为非空
+	 */
+	public static boolean isNotEmpty(float[] array) {
+		return false == isEmpty(array);
+	}
+
+	/**
+	 * 数组是否为非空
+	 *
+	 * @param array 数组
+	 * @return 是否为非空
+	 */
+	public static boolean isNotEmpty(boolean[] array) {
+		return false == isEmpty(array);
+	}
+
+	// ---------------------------------------------------------------------- resize
+
+	/**
+	 * 生成一个新的重新设置大小的数组<br>
+	 * 调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，其它位置补充0，缩小则截断
+	 *
+	 * @param bytes   原数组
+	 * @param newSize 新的数组大小
+	 * @return 调整后的新数组
+	 * @since 4.6.7
+	 */
+	public static byte[] resize(byte[] bytes, int newSize) {
+		if (newSize < 0) {
+			return bytes;
+		}
+		final byte[] newArray = new byte[newSize];
+		if (newSize > 0 && isNotEmpty(bytes)) {
+			System.arraycopy(bytes, 0, newArray, 0, Math.min(bytes.length, newSize));
+		}
+		return newArray;
+	}
+
+	// ---------------------------------------------------------------------- addAll
+
+	/**
+	 * 将多个数组合并在一起<br>
+	 * 忽略null的数组
+	 *
+	 * @param arrays 数组集合
+	 * @return 合并后的数组
+	 * @since 4.6.9
+	 */
+	public static byte[] addAll(byte[]... arrays) {
+		if (arrays.length == 1) {
+			return arrays[0];
+		}
+
+		// 计算总长度
+		int length = 0;
+		for (byte[] array : arrays) {
+			if (null != array) {
+				length += array.length;
+			}
+		}
+
+		final byte[] result = new byte[length];
+		length = 0;
+		for (byte[] array : arrays) {
+			if (null != array) {
+				System.arraycopy(array, 0, result, length, array.length);
+				length += array.length;
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * 将多个数组合并在一起<br>
+	 * 忽略null的数组
+	 *
+	 * @param arrays 数组集合
+	 * @return 合并后的数组
+	 * @since 4.6.9
+	 */
+	public static int[] addAll(int[]... arrays) {
+		if (arrays.length == 1) {
+			return arrays[0];
+		}
+
+		// 计算总长度
+		int length = 0;
+		for (int[] array : arrays) {
+			if (null != array) {
+				length += array.length;
+			}
+		}
+
+		final int[] result = new int[length];
+		length = 0;
+		for (int[] array : arrays) {
+			if (null != array) {
+				System.arraycopy(array, 0, result, length, array.length);
+				length += array.length;
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * 将多个数组合并在一起<br>
+	 * 忽略null的数组
+	 *
+	 * @param arrays 数组集合
+	 * @return 合并后的数组
+	 * @since 4.6.9
+	 */
+	public static long[] addAll(long[]... arrays) {
+		if (arrays.length == 1) {
+			return arrays[0];
+		}
+
+		// 计算总长度
+		int length = 0;
+		for (long[] array : arrays) {
+			if (null != array) {
+				length += array.length;
+			}
+		}
+
+		final long[] result = new long[length];
+		length = 0;
+		for (long[] array : arrays) {
+			if (null != array) {
+				System.arraycopy(array, 0, result, length, array.length);
+				length += array.length;
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * 将多个数组合并在一起<br>
+	 * 忽略null的数组
+	 *
+	 * @param arrays 数组集合
+	 * @return 合并后的数组
+	 * @since 4.6.9
+	 */
+	public static double[] addAll(double[]... arrays) {
+		if (arrays.length == 1) {
+			return arrays[0];
+		}
+
+		// 计算总长度
+		int length = 0;
+		for (double[] array : arrays) {
+			if (null != array) {
+				length += array.length;
+			}
+		}
+
+		final double[] result = new double[length];
+		length = 0;
+		for (double[] array : arrays) {
+			if (null != array) {
+				System.arraycopy(array, 0, result, length, array.length);
+				length += array.length;
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * 将多个数组合并在一起<br>
+	 * 忽略null的数组
+	 *
+	 * @param arrays 数组集合
+	 * @return 合并后的数组
+	 * @since 4.6.9
+	 */
+	public static float[] addAll(float[]... arrays) {
+		if (arrays.length == 1) {
+			return arrays[0];
+		}
+
+		// 计算总长度
+		int length = 0;
+		for (float[] array : arrays) {
+			if (null != array) {
+				length += array.length;
+			}
+		}
+
+		final float[] result = new float[length];
+		length = 0;
+		for (float[] array : arrays) {
+			if (null != array) {
+				System.arraycopy(array, 0, result, length, array.length);
+				length += array.length;
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * 将多个数组合并在一起<br>
+	 * 忽略null的数组
+	 *
+	 * @param arrays 数组集合
+	 * @return 合并后的数组
+	 * @since 4.6.9
+	 */
+	public static char[] addAll(char[]... arrays) {
+		if (arrays.length == 1) {
+			return arrays[0];
+		}
+
+		// 计算总长度
+		int length = 0;
+		for (char[] array : arrays) {
+			if (null != array) {
+				length += array.length;
+			}
+		}
+
+		final char[] result = new char[length];
+		length = 0;
+		for (char[] array : arrays) {
+			if (null != array) {
+				System.arraycopy(array, 0, result, length, array.length);
+				length += array.length;
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * 将多个数组合并在一起<br>
+	 * 忽略null的数组
+	 *
+	 * @param arrays 数组集合
+	 * @return 合并后的数组
+	 * @since 4.6.9
+	 */
+	public static boolean[] addAll(boolean[]... arrays) {
+		if (arrays.length == 1) {
+			return arrays[0];
+		}
+
+		// 计算总长度
+		int length = 0;
+		for (boolean[] array : arrays) {
+			if (null != array) {
+				length += array.length;
+			}
+		}
+
+		final boolean[] result = new boolean[length];
+		length = 0;
+		for (boolean[] array : arrays) {
+			if (null != array) {
+				System.arraycopy(array, 0, result, length, array.length);
+				length += array.length;
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * 将多个数组合并在一起<br>
+	 * 忽略null的数组
+	 *
+	 * @param arrays 数组集合
+	 * @return 合并后的数组
+	 * @since 4.6.9
+	 */
+	public static short[] addAll(short[]... arrays) {
+		if (arrays.length == 1) {
+			return arrays[0];
+		}
+
+		// 计算总长度
+		int length = 0;
+		for (short[] array : arrays) {
+			if (null != array) {
+				length += array.length;
+			}
+		}
+
+		final short[] result = new short[length];
+		length = 0;
+		for (short[] array : arrays) {
+			if (null != array) {
+				System.arraycopy(array, 0, result, length, array.length);
+				length += array.length;
+			}
+		}
+		return result;
+	}
+
+	// ---------------------------------------------------------------------- range
+
+	/**
+	 * 生成一个从0开始的数字列表<br>
+	 *
+	 * @param excludedEnd 结束的数字（不包含）
+	 * @return 数字列表
+	 */
+	public static int[] range(int excludedEnd) {
+		return range(0, excludedEnd, 1);
+	}
+
+	/**
+	 * 生成一个数字列表<br>
+	 * 自动判定正序反序
+	 *
+	 * @param includedStart 开始的数字（包含）
+	 * @param excludedEnd   结束的数字（不包含）
+	 * @return 数字列表
+	 */
+	public static int[] range(int includedStart, int excludedEnd) {
+		return range(includedStart, excludedEnd, 1);
+	}
+
+	/**
+	 * 生成一个数字列表<br>
+	 * 自动判定正序反序
+	 *
+	 * @param includedStart 开始的数字（包含）
+	 * @param excludedEnd   结束的数字（不包含）
+	 * @param step          步进
+	 * @return 数字列表
+	 */
+	public static int[] range(int includedStart, int excludedEnd, int step) {
+		if (includedStart > excludedEnd) {
+			int tmp = includedStart;
+			includedStart = excludedEnd;
+			excludedEnd = tmp;
+		}
+
+		if (step <= 0) {
+			step = 1;
+		}
+
+		int deviation = excludedEnd - includedStart;
+		int length = deviation / step;
+		if (deviation % step != 0) {
+			length += 1;
+		}
+		int[] range = new int[length];
+		for (int i = 0; i < length; i++) {
+			range[i] = includedStart;
+			includedStart += step;
+		}
+		return range;
+	}
+
+	// ---------------------------------------------------------------------- split
+
+	/**
+	 * 拆分byte数组为几个等份（最后一份可能小于len）
+	 *
+	 * @param array 数组
+	 * @param len   每个小节的长度
+	 * @return 拆分后的数组
+	 */
+	public static byte[][] split(byte[] array, int len) {
+		int x = array.length / len;
+		int y = array.length % len;
+		int z = 0;
+		if (y != 0) {
+			z = 1;
+		}
+		byte[][] arrays = new byte[x + z][];
+		byte[] arr;
+		for (int i = 0; i < x + z; i++) {
+			arr = new byte[len];
+			if (i == x + z - 1 && y != 0) {
+				System.arraycopy(array, i * len, arr, 0, y);
+			} else {
+				System.arraycopy(array, i * len, arr, 0, len);
+			}
+			arrays[i] = arr;
+		}
+		return arrays;
+	}
+
+	// ---------------------------------------------------------------------- indexOf、LastIndexOf、contains
+
+	/**
+	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int indexOf(long[] array, long value) {
+		if (null != array) {
+			for (int i = 0; i < array.length; i++) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int lastIndexOf(long[] array, long value) {
+		if (null != array) {
+			for (int i = array.length - 1; i >= 0; i--) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 数组中是否包含元素
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 是否包含
+	 * @since 3.0.7
+	 */
+	public static boolean contains(long[] array, long value) {
+		return indexOf(array, value) > INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int indexOf(int[] array, int value) {
+		if (null != array) {
+			for (int i = 0; i < array.length; i++) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int lastIndexOf(int[] array, int value) {
+		if (null != array) {
+			for (int i = array.length - 1; i >= 0; i--) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 数组中是否包含元素
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 是否包含
+	 * @since 3.0.7
+	 */
+	public static boolean contains(int[] array, int value) {
+		return indexOf(array, value) > INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int indexOf(short[] array, short value) {
+		if (null != array) {
+			for (int i = 0; i < array.length; i++) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int lastIndexOf(short[] array, short value) {
+		if (null != array) {
+			for (int i = array.length - 1; i >= 0; i--) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 数组中是否包含元素
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 是否包含
+	 * @since 3.0.7
+	 */
+	public static boolean contains(short[] array, short value) {
+		return indexOf(array, value) > INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int indexOf(char[] array, char value) {
+		if (null != array) {
+			for (int i = 0; i < array.length; i++) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int lastIndexOf(char[] array, char value) {
+		if (null != array) {
+			for (int i = array.length - 1; i >= 0; i--) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 数组中是否包含元素
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 是否包含
+	 * @since 3.0.7
+	 */
+	public static boolean contains(char[] array, char value) {
+		return indexOf(array, value) > INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int indexOf(byte[] array, byte value) {
+		if (null != array) {
+			for (int i = 0; i < array.length; i++) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int lastIndexOf(byte[] array, byte value) {
+		if (null != array) {
+			for (int i = array.length - 1; i >= 0; i--) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 数组中是否包含元素
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 是否包含
+	 * @since 3.0.7
+	 */
+	public static boolean contains(byte[] array, byte value) {
+		return indexOf(array, value) > INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int indexOf(double[] array, double value) {
+		if (null != array) {
+			for (int i = 0; i < array.length; i++) {
+				if (NumberUtil.equals(value, array[i])) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int lastIndexOf(double[] array, double value) {
+		if (null != array) {
+			for (int i = array.length - 1; i >= 0; i--) {
+				if (NumberUtil.equals(value, array[i])) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 数组中是否包含元素
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 是否包含
+	 * @since 3.0.7
+	 */
+	public static boolean contains(double[] array, double value) {
+		return indexOf(array, value) > INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int indexOf(float[] array, float value) {
+		if (null != array) {
+			for (int i = 0; i < array.length; i++) {
+				if (NumberUtil.equals(value, array[i])) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int lastIndexOf(float[] array, float value) {
+		if (null != array) {
+			for (int i = array.length - 1; i >= 0; i--) {
+				if (NumberUtil.equals(value, array[i])) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 数组中是否包含元素
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 是否包含
+	 * @since 3.0.7
+	 */
+	public static boolean contains(float[] array, float value) {
+		return indexOf(array, value) > INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int indexOf(boolean[] array, boolean value) {
+		if (null != array) {
+			for (int i = 0; i < array.length; i++) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND}
+	 * @since 3.0.7
+	 */
+	public static int lastIndexOf(boolean[] array, boolean value) {
+		if (null != array) {
+			for (int i = array.length - 1; i >= 0; i--) {
+				if (value == array[i]) {
+					return i;
+				}
+			}
+		}
+		return INDEX_NOT_FOUND;
+	}
+
+	/**
+	 * 数组中是否包含元素
+	 *
+	 * @param array 数组
+	 * @param value 被检查的元素
+	 * @return 是否包含
+	 * @since 3.0.7
+	 */
+	public static boolean contains(boolean[] array, boolean value) {
+		return indexOf(array, value) > INDEX_NOT_FOUND;
+	}
+
+	// ------------------------------------------------------------------- Wrap and unwrap
+
+	/**
+	 * 将原始类型数组包装为包装类型
+	 *
+	 * @param values 原始类型数组
+	 * @return 包装类型数组
+	 */
+	public static Integer[] wrap(int... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new Integer[0];
+		}
+
+		final Integer[] array = new Integer[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = values[i];
+		}
+		return array;
+	}
+
+	/**
+	 * 包装类数组转为原始类型数组，null转为0
+	 *
+	 * @param values 包装类型数组
+	 * @return 原始类型数组
+	 */
+	public static int[] unWrap(Integer... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new int[0];
+		}
+
+		final int[] array = new int[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = ObjectUtil.defaultIfNull(values[i], 0);
+		}
+		return array;
+	}
+
+	/**
+	 * 将原始类型数组包装为包装类型
+	 *
+	 * @param values 原始类型数组
+	 * @return 包装类型数组
+	 */
+	public static Long[] wrap(long... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new Long[0];
+		}
+
+		final Long[] array = new Long[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = values[i];
+		}
+		return array;
+	}
+
+	/**
+	 * 包装类数组转为原始类型数组
+	 *
+	 * @param values 包装类型数组
+	 * @return 原始类型数组
+	 */
+	public static long[] unWrap(Long... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new long[0];
+		}
+
+		final long[] array = new long[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = ObjectUtil.defaultIfNull(values[i], 0L);
+		}
+		return array;
+	}
+
+	/**
+	 * 将原始类型数组包装为包装类型
+	 *
+	 * @param values 原始类型数组
+	 * @return 包装类型数组
+	 */
+	public static Character[] wrap(char... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new Character[0];
+		}
+
+		final Character[] array = new Character[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = values[i];
+		}
+		return array;
+	}
+
+	/**
+	 * 包装类数组转为原始类型数组
+	 *
+	 * @param values 包装类型数组
+	 * @return 原始类型数组
+	 */
+	public static char[] unWrap(Character... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new char[0];
+		}
+
+		char[] array = new char[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = ObjectUtil.defaultIfNull(values[i], Character.MIN_VALUE);
+		}
+		return array;
+	}
+
+	/**
+	 * 将原始类型数组包装为包装类型
+	 *
+	 * @param values 原始类型数组
+	 * @return 包装类型数组
+	 */
+	public static Byte[] wrap(byte... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new Byte[0];
+		}
+
+		final Byte[] array = new Byte[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = values[i];
+		}
+		return array;
+	}
+
+	/**
+	 * 包装类数组转为原始类型数组
+	 *
+	 * @param values 包装类型数组
+	 * @return 原始类型数组
+	 */
+	public static byte[] unWrap(Byte... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new byte[0];
+		}
+
+		final byte[] array = new byte[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = ObjectUtil.defaultIfNull(values[i], (byte) 0);
+		}
+		return array;
+	}
+
+	/**
+	 * 将原始类型数组包装为包装类型
+	 *
+	 * @param values 原始类型数组
+	 * @return 包装类型数组
+	 */
+	public static Short[] wrap(short... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new Short[0];
+		}
+
+		final Short[] array = new Short[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = values[i];
+		}
+		return array;
+	}
+
+	/**
+	 * 包装类数组转为原始类型数组
+	 *
+	 * @param values 包装类型数组
+	 * @return 原始类型数组
+	 */
+	public static short[] unWrap(Short... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new short[0];
+		}
+
+		final short[] array = new short[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = ObjectUtil.defaultIfNull(values[i], (short) 0);
+		}
+		return array;
+	}
+
+	/**
+	 * 将原始类型数组包装为包装类型
+	 *
+	 * @param values 原始类型数组
+	 * @return 包装类型数组
+	 */
+	public static Float[] wrap(float... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new Float[0];
+		}
+
+		final Float[] array = new Float[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = values[i];
+		}
+		return array;
+	}
+
+	/**
+	 * 包装类数组转为原始类型数组
+	 *
+	 * @param values 包装类型数组
+	 * @return 原始类型数组
+	 */
+	public static float[] unWrap(Float... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new float[0];
+		}
+
+		final float[] array = new float[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = ObjectUtil.defaultIfNull(values[i], 0F);
+		}
+		return array;
+	}
+
+	/**
+	 * 将原始类型数组包装为包装类型
+	 *
+	 * @param values 原始类型数组
+	 * @return 包装类型数组
+	 */
+	public static Double[] wrap(double... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new Double[0];
+		}
+
+		final Double[] array = new Double[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = values[i];
+		}
+		return array;
+	}
+
+	/**
+	 * 包装类数组转为原始类型数组
+	 *
+	 * @param values 包装类型数组
+	 * @return 原始类型数组
+	 */
+	public static double[] unWrap(Double... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new double[0];
+		}
+
+		final double[] array = new double[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = ObjectUtil.defaultIfNull(values[i], 0D);
+		}
+		return array;
+	}
+
+	/**
+	 * 将原始类型数组包装为包装类型
+	 *
+	 * @param values 原始类型数组
+	 * @return 包装类型数组
+	 */
+	public static Boolean[] wrap(boolean... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new Boolean[0];
+		}
+
+		final Boolean[] array = new Boolean[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = values[i];
+		}
+		return array;
+	}
+
+	/**
+	 * 包装类数组转为原始类型数组
+	 *
+	 * @param values 包装类型数组
+	 * @return 原始类型数组
+	 */
+	public static boolean[] unWrap(Boolean... values) {
+		if (null == values) {
+			return null;
+		}
+		final int length = values.length;
+		if (0 == length) {
+			return new boolean[0];
+		}
+
+		final boolean[] array = new boolean[length];
+		for (int i = 0; i < length; i++) {
+			array[i] = ObjectUtil.defaultIfNull(values[i], false);
+		}
+		return array;
+	}
+
+	// ------------------------------------------------------------------- sub
+
+	/**
+	 * 获取子数组
+	 *
+	 * @param array 数组
+	 * @param start 开始位置（包括）
+	 * @param end   结束位置（不包括）
+	 * @return 新的数组
+	 * @see Arrays#copyOfRange(Object[], int, int)
+	 * @since 4.5.2
+	 */
+	public static byte[] sub(byte[] array, int start, int end) {
+		int length = Array.getLength(array);
+		if (start < 0) {
+			start += length;
+		}
+		if (end < 0) {
+			end += length;
+		}
+		if (start == length) {
+			return new byte[0];
+		}
+		if (start > end) {
+			int tmp = start;
+			start = end;
+			end = tmp;
+		}
+		if (end > length) {
+			if (start >= length) {
+				return new byte[0];
+			}
+			end = length;
+		}
+		return Arrays.copyOfRange(array, start, end);
+	}
+
+	/**
+	 * 获取子数组
+	 *
+	 * @param array 数组
+	 * @param start 开始位置（包括）
+	 * @param end   结束位置（不包括）
+	 * @return 新的数组
+	 * @see Arrays#copyOfRange(Object[], int, int)
+	 * @since 4.5.2
+	 */
+	public static int[] sub(int[] array, int start, int end) {
+		int length = Array.getLength(array);
+		if (start < 0) {
+			start += length;
+		}
+		if (end < 0) {
+			end += length;
+		}
+		if (start == length) {
+			return new int[0];
+		}
+		if (start > end) {
+			int tmp = start;
+			start = end;
+			end = tmp;
+		}
+		if (end > length) {
+			if (start >= length) {
+				return new int[0];
+			}
+			end = length;
+		}
+		return Arrays.copyOfRange(array, start, end);
+	}
+
+	/**
+	 * 获取子数组
+	 *
+	 * @param array 数组
+	 * @param start 开始位置（包括）
+	 * @param end   结束位置（不包括）
+	 * @return 新的数组
+	 * @see Arrays#copyOfRange(Object[], int, int)
+	 * @since 4.5.2
+	 */
+	public static long[] sub(long[] array, int start, int end) {
+		int length = Array.getLength(array);
+		if (start < 0) {
+			start += length;
+		}
+		if (end < 0) {
+			end += length;
+		}
+		if (start == length) {
+			return new long[0];
+		}
+		if (start > end) {
+			int tmp = start;
+			start = end;
+			end = tmp;
+		}
+		if (end > length) {
+			if (start >= length) {
+				return new long[0];
+			}
+			end = length;
+		}
+		return Arrays.copyOfRange(array, start, end);
+	}
+
+	/**
+	 * 获取子数组
+	 *
+	 * @param array 数组
+	 * @param start 开始位置（包括）
+	 * @param end   结束位置（不包括）
+	 * @return 新的数组
+	 * @see Arrays#copyOfRange(Object[], int, int)
+	 * @since 4.5.2
+	 */
+	public static short[] sub(short[] array, int start, int end) {
+		int length = Array.getLength(array);
+		if (start < 0) {
+			start += length;
+		}
+		if (end < 0) {
+			end += length;
+		}
+		if (start == length) {
+			return new short[0];
+		}
+		if (start > end) {
+			int tmp = start;
+			start = end;
+			end = tmp;
+		}
+		if (end > length) {
+			if (start >= length) {
+				return new short[0];
+			}
+			end = length;
+		}
+		return Arrays.copyOfRange(array, start, end);
+	}
+
+	/**
+	 * 获取子数组
+	 *
+	 * @param array 数组
+	 * @param start 开始位置（包括）
+	 * @param end   结束位置（不包括）
+	 * @return 新的数组
+	 * @see Arrays#copyOfRange(Object[], int, int)
+	 * @since 4.5.2
+	 */
+	public static char[] sub(char[] array, int start, int end) {
+		int length = Array.getLength(array);
+		if (start < 0) {
+			start += length;
+		}
+		if (end < 0) {
+			end += length;
+		}
+		if (start == length) {
+			return new char[0];
+		}
+		if (start > end) {
+			int tmp = start;
+			start = end;
+			end = tmp;
+		}
+		if (end > length) {
+			if (start >= length) {
+				return new char[0];
+			}
+			end = length;
+		}
+		return Arrays.copyOfRange(array, start, end);
+	}
+
+	/**
+	 * 获取子数组
+	 *
+	 * @param array 数组
+	 * @param start 开始位置（包括）
+	 * @param end   结束位置（不包括）
+	 * @return 新的数组
+	 * @see Arrays#copyOfRange(Object[], int, int)
+	 * @since 4.5.2
+	 */
+	public static double[] sub(double[] array, int start, int end) {
+		int length = Array.getLength(array);
+		if (start < 0) {
+			start += length;
+		}
+		if (end < 0) {
+			end += length;
+		}
+		if (start == length) {
+			return new double[0];
+		}
+		if (start > end) {
+			int tmp = start;
+			start = end;
+			end = tmp;
+		}
+		if (end > length) {
+			if (start >= length) {
+				return new double[0];
+			}
+			end = length;
+		}
+		return Arrays.copyOfRange(array, start, end);
+	}
+
+	/**
+	 * 获取子数组
+	 *
+	 * @param array 数组
+	 * @param start 开始位置（包括）
+	 * @param end   结束位置（不包括）
+	 * @return 新的数组
+	 * @see Arrays#copyOfRange(Object[], int, int)
+	 * @since 4.5.2
+	 */
+	public static float[] sub(float[] array, int start, int end) {
+		int length = Array.getLength(array);
+		if (start < 0) {
+			start += length;
+		}
+		if (end < 0) {
+			end += length;
+		}
+		if (start == length) {
+			return new float[0];
+		}
+		if (start > end) {
+			int tmp = start;
+			start = end;
+			end = tmp;
+		}
+		if (end > length) {
+			if (start >= length) {
+				return new float[0];
+			}
+			end = length;
+		}
+		return Arrays.copyOfRange(array, start, end);
+	}
+
+	/**
+	 * 获取子数组
+	 *
+	 * @param array 数组
+	 * @param start 开始位置（包括）
+	 * @param end   结束位置（不包括）
+	 * @return 新的数组
+	 * @see Arrays#copyOfRange(Object[], int, int)
+	 * @since 4.5.2
+	 */
+	public static boolean[] sub(boolean[] array, int start, int end) {
+		int length = Array.getLength(array);
+		if (start < 0) {
+			start += length;
+		}
+		if (end < 0) {
+			end += length;
+		}
+		if (start == length) {
+			return new boolean[0];
+		}
+		if (start > end) {
+			int tmp = start;
+			start = end;
+			end = tmp;
+		}
+		if (end > length) {
+			if (start >= length) {
+				return new boolean[0];
+			}
+			end = length;
+		}
+		return Arrays.copyOfRange(array, start, end);
+	}
+
+	// ------------------------------------------------------------------- join
+
+	/**
+	 * 以 conjunction 为分隔符将数组转换为字符串
+	 *
+	 * @param array       数组
+	 * @param conjunction 分隔符
+	 * @return 连接后的字符串
+	 */
+	public static String join(int[] array, CharSequence conjunction) {
+		if (null == array) {
+			return null;
+		}
+
+		final StringBuilder sb = new StringBuilder();
+		boolean isFirst = true;
+		for (int item : array) {
+			if (isFirst) {
+				isFirst = false;
+			} else {
+				sb.append(conjunction);
+			}
+			sb.append(item);
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * 以 conjunction 为分隔符将数组转换为字符串
+	 *
+	 * @param array       数组
+	 * @param conjunction 分隔符
+	 * @return 连接后的字符串
+	 */
+	public static String join(short[] array, CharSequence conjunction) {
+		if (null == array) {
+			return null;
+		}
+
+		final StringBuilder sb = new StringBuilder();
+		boolean isFirst = true;
+		for (short item : array) {
+			if (isFirst) {
+				isFirst = false;
+			} else {
+				sb.append(conjunction);
+			}
+			sb.append(item);
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * 以 conjunction 为分隔符将数组转换为字符串
+	 *
+	 * @param array       数组
+	 * @param conjunction 分隔符
+	 * @return 连接后的字符串
+	 */
+	public static String join(char[] array, CharSequence conjunction) {
+		if (null == array) {
+			return null;
+		}
+
+		final StringBuilder sb = new StringBuilder();
+		boolean isFirst = true;
+		for (char item : array) {
+			if (isFirst) {
+				isFirst = false;
+			} else {
+				sb.append(conjunction);
+			}
+			sb.append(item);
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * 以 conjunction 为分隔符将数组转换为字符串
+	 *
+	 * @param array       数组
+	 * @param conjunction 分隔符
+	 * @return 连接后的字符串
+	 */
+	public static String join(byte[] array, CharSequence conjunction) {
+		if (null == array) {
+			return null;
+		}
+
+		final StringBuilder sb = new StringBuilder();
+		boolean isFirst = true;
+		for (byte item : array) {
+			if (isFirst) {
+				isFirst = false;
+			} else {
+				sb.append(conjunction);
+			}
+			sb.append(item);
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * 以 conjunction 为分隔符将数组转换为字符串
+	 *
+	 * @param array       数组
+	 * @param conjunction 分隔符
+	 * @return 连接后的字符串
+	 */
+	public static String join(boolean[] array, CharSequence conjunction) {
+		if (null == array) {
+			return null;
+		}
+
+		final StringBuilder sb = new StringBuilder();
+		boolean isFirst = true;
+		for (boolean item : array) {
+			if (isFirst) {
+				isFirst = false;
+			} else {
+				sb.append(conjunction);
+			}
+			sb.append(item);
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * 以 conjunction 为分隔符将数组转换为字符串
+	 *
+	 * @param array       数组
+	 * @param conjunction 分隔符
+	 * @return 连接后的字符串
+	 */
+	public static String join(float[] array, CharSequence conjunction) {
+		if (null == array) {
+			return null;
+		}
+
+		final StringBuilder sb = new StringBuilder();
+		boolean isFirst = true;
+		for (float item : array) {
+			if (isFirst) {
+				isFirst = false;
+			} else {
+				sb.append(conjunction);
+			}
+			sb.append(item);
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * 以 conjunction 为分隔符将数组转换为字符串
+	 *
+	 * @param array       数组
+	 * @param conjunction 分隔符
+	 * @return 连接后的字符串
+	 */
+	public static String join(double[] array, CharSequence conjunction) {
+		if (null == array) {
+			return null;
+		}
+
+		final StringBuilder sb = new StringBuilder();
+		boolean isFirst = true;
+		for (double item : array) {
+			if (isFirst) {
+				isFirst = false;
+			} else {
+				sb.append(conjunction);
+			}
+			sb.append(item);
+		}
+		return sb.toString();
+	}
+
+	// ------------------------------------------------------------------- remove
+
+	/**
+	 * 移除数组中对应位置的元素<br>
+	 * copy from commons-lang
+	 *
+	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
+	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static long[] remove(long[] array, int index) throws IllegalArgumentException {
+		return (long[]) remove((Object) array, index);
+	}
+
+	/**
+	 * 移除数组中对应位置的元素<br>
+	 * copy from commons-lang
+	 *
+	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
+	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static int[] remove(int[] array, int index) throws IllegalArgumentException {
+		return (int[]) remove((Object) array, index);
+	}
+
+	/**
+	 * 移除数组中对应位置的元素<br>
+	 * copy from commons-lang
+	 *
+	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
+	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static short[] remove(short[] array, int index) throws IllegalArgumentException {
+		return (short[]) remove((Object) array, index);
+	}
+
+	/**
+	 * 移除数组中对应位置的元素<br>
+	 * copy from commons-lang
+	 *
+	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
+	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static char[] remove(char[] array, int index) throws IllegalArgumentException {
+		return (char[]) remove((Object) array, index);
+	}
+
+	/**
+	 * 移除数组中对应位置的元素<br>
+	 * copy from commons-lang
+	 *
+	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
+	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static byte[] remove(byte[] array, int index) throws IllegalArgumentException {
+		return (byte[]) remove((Object) array, index);
+	}
+
+	/**
+	 * 移除数组中对应位置的元素<br>
+	 * copy from commons-lang
+	 *
+	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
+	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static double[] remove(double[] array, int index) throws IllegalArgumentException {
+		return (double[]) remove((Object) array, index);
+	}
+
+	/**
+	 * 移除数组中对应位置的元素<br>
+	 * copy from commons-lang
+	 *
+	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
+	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static float[] remove(float[] array, int index) throws IllegalArgumentException {
+		return (float[]) remove((Object) array, index);
+	}
+
+	/**
+	 * 移除数组中对应位置的元素<br>
+	 * copy from commons-lang
+	 *
+	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
+	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static boolean[] remove(boolean[] array, int index) throws IllegalArgumentException {
+		return (boolean[]) remove((Object) array, index);
+	}
+
+	/**
+	 * 移除数组中对应位置的元素<br>
+	 * copy from commons-lang
+	 *
+	 * @param array 数组对象，可以是对象数组，也可以原始类型数组
+	 * @param index 位置，如果位置小于0或者大于长度，返回原数组
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	@SuppressWarnings("SuspiciousSystemArraycopy")
+	public static Object remove(Object array, int index) throws IllegalArgumentException {
+		if (null == array) {
+			return null;
+		}
+		int length = Array.getLength(array);
+		if (index < 0 || index >= length) {
+			return array;
+		}
+
+		final Object result = Array.newInstance(array.getClass().getComponentType(), length - 1);
+		System.arraycopy(array, 0, result, 0, index);
+		if (index < length - 1) {
+			// 后半部分
+			System.arraycopy(array, index + 1, result, index, length - index - 1);
+		}
+
+		return result;
+	}
+
+	// ---------------------------------------------------------------------- removeEle
+
+	/**
+	 * 移除数组中指定的元素<br>
+	 * 只会移除匹配到的第一个元素 copy from commons-lang
+	 *
+	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
+	 * @param element 要移除的元素
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static long[] removeEle(long[] array, long element) throws IllegalArgumentException {
+		return remove(array, indexOf(array, element));
+	}
+
+	/**
+	 * 移除数组中指定的元素<br>
+	 * 只会移除匹配到的第一个元素 copy from commons-lang
+	 *
+	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
+	 * @param element 要移除的元素
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static int[] removeEle(int[] array, int element) throws IllegalArgumentException {
+		return remove(array, indexOf(array, element));
+	}
+
+	/**
+	 * 移除数组中指定的元素<br>
+	 * 只会移除匹配到的第一个元素 copy from commons-lang
+	 *
+	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
+	 * @param element 要移除的元素
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static short[] removeEle(short[] array, short element) throws IllegalArgumentException {
+		return remove(array, indexOf(array, element));
+	}
+
+	/**
+	 * 移除数组中指定的元素<br>
+	 * 只会移除匹配到的第一个元素 copy from commons-lang
+	 *
+	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
+	 * @param element 要移除的元素
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static char[] removeEle(char[] array, char element) throws IllegalArgumentException {
+		return remove(array, indexOf(array, element));
+	}
+
+	/**
+	 * 移除数组中指定的元素<br>
+	 * 只会移除匹配到的第一个元素 copy from commons-lang
+	 *
+	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
+	 * @param element 要移除的元素
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static byte[] removeEle(byte[] array, byte element) throws IllegalArgumentException {
+		return remove(array, indexOf(array, element));
+	}
+
+	/**
+	 * 移除数组中指定的元素<br>
+	 * 只会移除匹配到的第一个元素 copy from commons-lang
+	 *
+	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
+	 * @param element 要移除的元素
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static double[] removeEle(double[] array, double element) throws IllegalArgumentException {
+		return remove(array, indexOf(array, element));
+	}
+
+	/**
+	 * 移除数组中指定的元素<br>
+	 * 只会移除匹配到的第一个元素 copy from commons-lang
+	 *
+	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
+	 * @param element 要移除的元素
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static float[] removeEle(float[] array, float element) throws IllegalArgumentException {
+		return remove(array, indexOf(array, element));
+	}
+
+	/**
+	 * 移除数组中指定的元素<br>
+	 * 只会移除匹配到的第一个元素 copy from commons-lang
+	 *
+	 * @param array   数组对象，可以是对象数组，也可以原始类型数组
+	 * @param element 要移除的元素
+	 * @return 去掉指定元素后的新数组或原数组
+	 * @throws IllegalArgumentException 参数对象不为数组对象
+	 * @since 3.0.8
+	 */
+	public static boolean[] removeEle(boolean[] array, boolean element) throws IllegalArgumentException {
+		return remove(array, indexOf(array, element));
+	}
+
+	// ---------------------------------------------------------------------- reverse
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array               数组，会变更
+	 * @param startIndexInclusive 其实位置（包含）
+	 * @param endIndexExclusive   结束位置（不包含）
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static long[] reverse(long[] array, final int startIndexInclusive, final int endIndexExclusive) {
+		if (isEmpty(array)) {
+			return array;
+		}
+		int i = Math.max(startIndexInclusive, 0);
+		int j = Math.min(array.length, endIndexExclusive) - 1;
+		long tmp;
+		while (j > i) {
+			tmp = array[j];
+			array[j] = array[i];
+			array[i] = tmp;
+			j--;
+			i++;
+		}
+		return array;
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static long[] reverse(long[] array) {
+		return reverse(array, 0, array.length);
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array               数组，会变更
+	 * @param startIndexInclusive 其实位置（包含）
+	 * @param endIndexExclusive   结束位置（不包含）
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static int[] reverse(int[] array, final int startIndexInclusive, final int endIndexExclusive) {
+		if (isEmpty(array)) {
+			return array;
+		}
+		int i = Math.max(startIndexInclusive, 0);
+		int j = Math.min(array.length, endIndexExclusive) - 1;
+		int tmp;
+		while (j > i) {
+			tmp = array[j];
+			array[j] = array[i];
+			array[i] = tmp;
+			j--;
+			i++;
+		}
+		return array;
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static int[] reverse(int[] array) {
+		return reverse(array, 0, array.length);
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array               数组，会变更
+	 * @param startIndexInclusive 其实位置（包含）
+	 * @param endIndexExclusive   结束位置（不包含）
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static short[] reverse(short[] array, final int startIndexInclusive, final int endIndexExclusive) {
+		if (isEmpty(array)) {
+			return array;
+		}
+		int i = Math.max(startIndexInclusive, 0);
+		int j = Math.min(array.length, endIndexExclusive) - 1;
+		short tmp;
+		while (j > i) {
+			tmp = array[j];
+			array[j] = array[i];
+			array[i] = tmp;
+			j--;
+			i++;
+		}
+		return array;
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static short[] reverse(short[] array) {
+		return reverse(array, 0, array.length);
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array               数组，会变更
+	 * @param startIndexInclusive 其实位置（包含）
+	 * @param endIndexExclusive   结束位置（不包含）
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static char[] reverse(char[] array, final int startIndexInclusive, final int endIndexExclusive) {
+		if (isEmpty(array)) {
+			return array;
+		}
+		int i = Math.max(startIndexInclusive, 0);
+		int j = Math.min(array.length, endIndexExclusive) - 1;
+		char tmp;
+		while (j > i) {
+			tmp = array[j];
+			array[j] = array[i];
+			array[i] = tmp;
+			j--;
+			i++;
+		}
+		return array;
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static char[] reverse(char[] array) {
+		return reverse(array, 0, array.length);
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array               数组，会变更
+	 * @param startIndexInclusive 其实位置（包含）
+	 * @param endIndexExclusive   结束位置（不包含）
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static byte[] reverse(byte[] array, final int startIndexInclusive, final int endIndexExclusive) {
+		if (isEmpty(array)) {
+			return array;
+		}
+		int i = Math.max(startIndexInclusive, 0);
+		int j = Math.min(array.length, endIndexExclusive) - 1;
+		byte tmp;
+		while (j > i) {
+			tmp = array[j];
+			array[j] = array[i];
+			array[i] = tmp;
+			j--;
+			i++;
+		}
+		return array;
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static byte[] reverse(byte[] array) {
+		return reverse(array, 0, array.length);
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array               数组，会变更
+	 * @param startIndexInclusive 其实位置（包含）
+	 * @param endIndexExclusive   结束位置（不包含）
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static double[] reverse(double[] array, final int startIndexInclusive, final int endIndexExclusive) {
+		if (isEmpty(array)) {
+			return array;
+		}
+		int i = Math.max(startIndexInclusive, 0);
+		int j = Math.min(array.length, endIndexExclusive) - 1;
+		double tmp;
+		while (j > i) {
+			tmp = array[j];
+			array[j] = array[i];
+			array[i] = tmp;
+			j--;
+			i++;
+		}
+		return array;
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static double[] reverse(double[] array) {
+		return reverse(array, 0, array.length);
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array               数组，会变更
+	 * @param startIndexInclusive 其实位置（包含）
+	 * @param endIndexExclusive   结束位置（不包含）
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static float[] reverse(float[] array, final int startIndexInclusive, final int endIndexExclusive) {
+		if (isEmpty(array)) {
+			return array;
+		}
+		int i = Math.max(startIndexInclusive, 0);
+		int j = Math.min(array.length, endIndexExclusive) - 1;
+		float tmp;
+		while (j > i) {
+			tmp = array[j];
+			array[j] = array[i];
+			array[i] = tmp;
+			j--;
+			i++;
+		}
+		return array;
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static float[] reverse(float[] array) {
+		return reverse(array, 0, array.length);
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array               数组，会变更
+	 * @param startIndexInclusive 其实位置（包含）
+	 * @param endIndexExclusive   结束位置（不包含）
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static boolean[] reverse(boolean[] array, final int startIndexInclusive, final int endIndexExclusive) {
+		if (isEmpty(array)) {
+			return array;
+		}
+		int i = Math.max(startIndexInclusive, 0);
+		int j = Math.min(array.length, endIndexExclusive) - 1;
+		boolean tmp;
+		while (j > i) {
+			tmp = array[j];
+			array[j] = array[i];
+			array[i] = tmp;
+			j--;
+			i++;
+		}
+		return array;
+	}
+
+	/**
+	 * 反转数组，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 变更后的原数组
+	 * @since 3.0.9
+	 */
+	public static boolean[] reverse(boolean[] array) {
+		return reverse(array, 0, array.length);
+	}
+
+	// ------------------------------------------------------------------------------------------------------------ min and max
+
+	/**
+	 * 取最小值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最小值
+	 * @since 3.0.9
+	 */
+	public static long min(long... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		long min = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (min > numberArray[i]) {
+				min = numberArray[i];
+			}
+		}
+		return min;
+	}
+
+	/**
+	 * 取最小值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最小值
+	 * @since 3.0.9
+	 */
+	public static int min(int... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		int min = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (min > numberArray[i]) {
+				min = numberArray[i];
+			}
+		}
+		return min;
+	}
+
+	/**
+	 * 取最小值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最小值
+	 * @since 3.0.9
+	 */
+	public static short min(short... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		short min = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (min > numberArray[i]) {
+				min = numberArray[i];
+			}
+		}
+		return min;
+	}
+
+	/**
+	 * 取最小值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最小值
+	 * @since 3.0.9
+	 */
+	public static char min(char... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		char min = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (min > numberArray[i]) {
+				min = numberArray[i];
+			}
+		}
+		return min;
+	}
+
+	/**
+	 * 取最小值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最小值
+	 * @since 3.0.9
+	 */
+	public static byte min(byte... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		byte min = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (min > numberArray[i]) {
+				min = numberArray[i];
+			}
+		}
+		return min;
+	}
+
+	/**
+	 * 取最小值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最小值
+	 * @since 3.0.9
+	 */
+	public static double min(double... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		double min = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (min > numberArray[i]) {
+				min = numberArray[i];
+			}
+		}
+		return min;
+	}
+
+	/**
+	 * 取最小值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最小值
+	 * @since 3.0.9
+	 */
+	public static float min(float... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		float min = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (min > numberArray[i]) {
+				min = numberArray[i];
+			}
+		}
+		return min;
+	}
+
+	/**
+	 * 取最大值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最大值
+	 * @since 3.0.9
+	 */
+	public static long max(long... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		long max = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (max < numberArray[i]) {
+				max = numberArray[i];
+			}
+		}
+		return max;
+	}
+
+	/**
+	 * 取最大值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最大值
+	 * @since 3.0.9
+	 */
+	public static int max(int... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		int max = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (max < numberArray[i]) {
+				max = numberArray[i];
+			}
+		}
+		return max;
+	}
+
+	/**
+	 * 取最大值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最大值
+	 * @since 3.0.9
+	 */
+	public static short max(short... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		short max = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (max < numberArray[i]) {
+				max = numberArray[i];
+			}
+		}
+		return max;
+	}
+
+	/**
+	 * 取最大值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最大值
+	 * @since 3.0.9
+	 */
+	public static char max(char... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		char max = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (max < numberArray[i]) {
+				max = numberArray[i];
+			}
+		}
+		return max;
+	}
+
+	/**
+	 * 取最大值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最大值
+	 * @since 3.0.9
+	 */
+	public static byte max(byte... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		byte max = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (max < numberArray[i]) {
+				max = numberArray[i];
+			}
+		}
+		return max;
+	}
+
+	/**
+	 * 取最大值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最大值
+	 * @since 3.0.9
+	 */
+	public static double max(double... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		double max = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (max < numberArray[i]) {
+				max = numberArray[i];
+			}
+		}
+		return max;
+	}
+
+	/**
+	 * 取最大值
+	 *
+	 * @param numberArray 数字数组
+	 * @return 最大值
+	 * @since 3.0.9
+	 */
+	public static float max(float... numberArray) {
+		if (isEmpty(numberArray)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		float max = numberArray[0];
+		for (int i = 1; i < numberArray.length; i++) {
+			if (max < numberArray[i]) {
+				max = numberArray[i];
+			}
+		}
+		return max;
+	}
+
+	// ---------------------------------------------------------------------- shuffle
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static int[] shuffle(int[] array) {
+		return shuffle(array, RandomUtil.getRandom());
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array  数组，会变更
+	 * @param random 随机数生成器
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static int[] shuffle(int[] array, Random random) {
+		if (array == null || random == null || array.length <= 1) {
+			return array;
+		}
+
+		for (int i = array.length; i > 1; i--) {
+			swap(array, i - 1, random.nextInt(i));
+		}
+
+		return array;
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static long[] shuffle(long[] array) {
+		return shuffle(array, RandomUtil.getRandom());
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array  数组，会变更
+	 * @param random 随机数生成器
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static long[] shuffle(long[] array, Random random) {
+		if (array == null || random == null || array.length <= 1) {
+			return array;
+		}
+
+		for (int i = array.length; i > 1; i--) {
+			swap(array, i - 1, random.nextInt(i));
+		}
+
+		return array;
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static double[] shuffle(double[] array) {
+		return shuffle(array, RandomUtil.getRandom());
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array  数组，会变更
+	 * @param random 随机数生成器
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static double[] shuffle(double[] array, Random random) {
+		if (array == null || random == null || array.length <= 1) {
+			return array;
+		}
+
+		for (int i = array.length; i > 1; i--) {
+			swap(array, i - 1, random.nextInt(i));
+		}
+
+		return array;
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static float[] shuffle(float[] array) {
+		return shuffle(array, RandomUtil.getRandom());
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array  数组，会变更
+	 * @param random 随机数生成器
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static float[] shuffle(float[] array, Random random) {
+		if (array == null || random == null || array.length <= 1) {
+			return array;
+		}
+
+		for (int i = array.length; i > 1; i--) {
+			swap(array, i - 1, random.nextInt(i));
+		}
+
+		return array;
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean[] shuffle(boolean[] array) {
+		return shuffle(array, RandomUtil.getRandom());
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array  数组，会变更
+	 * @param random 随机数生成器
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean[] shuffle(boolean[] array, Random random) {
+		if (array == null || random == null || array.length <= 1) {
+			return array;
+		}
+
+		for (int i = array.length; i > 1; i--) {
+			swap(array, i - 1, random.nextInt(i));
+		}
+
+		return array;
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static byte[] shuffle(byte[] array) {
+		return shuffle(array, RandomUtil.getRandom());
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array  数组，会变更
+	 * @param random 随机数生成器
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static byte[] shuffle(byte[] array, Random random) {
+		if (array == null || random == null || array.length <= 1) {
+			return array;
+		}
+
+		for (int i = array.length; i > 1; i--) {
+			swap(array, i - 1, random.nextInt(i));
+		}
+
+		return array;
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static char[] shuffle(char[] array) {
+		return shuffle(array, RandomUtil.getRandom());
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array  数组，会变更
+	 * @param random 随机数生成器
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static char[] shuffle(char[] array, Random random) {
+		if (array == null || random == null || array.length <= 1) {
+			return array;
+		}
+
+		for (int i = array.length; i > 1; i--) {
+			swap(array, i - 1, random.nextInt(i));
+		}
+
+		return array;
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array 数组，会变更
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static short[] shuffle(short[] array) {
+		return shuffle(array, RandomUtil.getRandom());
+	}
+
+	/**
+	 * 打乱数组顺序，会变更原数组
+	 *
+	 * @param array  数组，会变更
+	 * @param random 随机数生成器
+	 * @return 打乱后的数组
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static short[] shuffle(short[] array, Random random) {
+		if (array == null || random == null || array.length <= 1) {
+			return array;
+		}
+
+		for (int i = array.length; i > 1; i--) {
+			swap(array, i - 1, random.nextInt(i));
+		}
+
+		return array;
+	}
+
+	// ---------------------------------------------------------------------- shuffle
+
+	/**
+	 * 交换数组中两个位置的值
+	 *
+	 * @param array  数组
+	 * @param index1 位置1
+	 * @param index2 位置2
+	 * @return 交换后的数组，与传入数组为同一对象
+	 * @since 4.0.7
+	 */
+	public static int[] swap(int[] array, int index1, int index2) {
+		if (isEmpty(array)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		int tmp = array[index1];
+		array[index1] = array[index2];
+		array[index2] = tmp;
+		return array;
+	}
+
+	/**
+	 * 交换数组中两个位置的值
+	 *
+	 * @param array  数组
+	 * @param index1 位置1
+	 * @param index2 位置2
+	 * @return 交换后的数组，与传入数组为同一对象
+	 * @since 4.0.7
+	 */
+	public static long[] swap(long[] array, int index1, int index2) {
+		if (isEmpty(array)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		long tmp = array[index1];
+		array[index1] = array[index2];
+		array[index2] = tmp;
+		return array;
+	}
+
+	/**
+	 * 交换数组中两个位置的值
+	 *
+	 * @param array  数组
+	 * @param index1 位置1
+	 * @param index2 位置2
+	 * @return 交换后的数组，与传入数组为同一对象
+	 * @since 4.0.7
+	 */
+	public static double[] swap(double[] array, int index1, int index2) {
+		if (isEmpty(array)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		double tmp = array[index1];
+		array[index1] = array[index2];
+		array[index2] = tmp;
+		return array;
+	}
+
+	/**
+	 * 交换数组中两个位置的值
+	 *
+	 * @param array  数组
+	 * @param index1 位置1
+	 * @param index2 位置2
+	 * @return 交换后的数组，与传入数组为同一对象
+	 * @since 4.0.7
+	 */
+	public static float[] swap(float[] array, int index1, int index2) {
+		if (isEmpty(array)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		float tmp = array[index1];
+		array[index1] = array[index2];
+		array[index2] = tmp;
+		return array;
+	}
+
+	/**
+	 * 交换数组中两个位置的值
+	 *
+	 * @param array  数组
+	 * @param index1 位置1
+	 * @param index2 位置2
+	 * @return 交换后的数组，与传入数组为同一对象
+	 * @since 4.0.7
+	 */
+	public static boolean[] swap(boolean[] array, int index1, int index2) {
+		if (isEmpty(array)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		boolean tmp = array[index1];
+		array[index1] = array[index2];
+		array[index2] = tmp;
+		return array;
+	}
+
+	/**
+	 * 交换数组中两个位置的值
+	 *
+	 * @param array  数组
+	 * @param index1 位置1
+	 * @param index2 位置2
+	 * @return 交换后的数组，与传入数组为同一对象
+	 * @since 4.0.7
+	 */
+	public static byte[] swap(byte[] array, int index1, int index2) {
+		if (isEmpty(array)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		byte tmp = array[index1];
+		array[index1] = array[index2];
+		array[index2] = tmp;
+		return array;
+	}
+
+	/**
+	 * 交换数组中两个位置的值
+	 *
+	 * @param array  数组
+	 * @param index1 位置1
+	 * @param index2 位置2
+	 * @return 交换后的数组，与传入数组为同一对象
+	 * @since 4.0.7
+	 */
+	public static char[] swap(char[] array, int index1, int index2) {
+		if (isEmpty(array)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		char tmp = array[index1];
+		array[index1] = array[index2];
+		array[index2] = tmp;
+		return array;
+	}
+
+	/**
+	 * 交换数组中两个位置的值
+	 *
+	 * @param array  数组
+	 * @param index1 位置1
+	 * @param index2 位置2
+	 * @return 交换后的数组，与传入数组为同一对象
+	 * @since 4.0.7
+	 */
+	public static short[] swap(short[] array, int index1, int index2) {
+		if (isEmpty(array)) {
+			throw new IllegalArgumentException("Number array must not empty !");
+		}
+		short tmp = array[index1];
+		array[index1] = array[index2];
+		array[index2] = tmp;
+		return array;
+	}
+}