All Downloads are FREE. Search and download functionalities are using the official Maven repository.

cn.hutool.core.util.PrimitiveArrayUtil Maven / Gradle / Ivy

There is a newer version: 5.8.33
Show newest version
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

	/**
	 * 生成一个新的重新设置大小的数组
* 调整大小后拷贝原数组到新数组下。扩大则占位前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 /** * 将多个数组合并在一起
* 忽略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; } /** * 将多个数组合并在一起
* 忽略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; } /** * 将多个数组合并在一起
* 忽略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; } /** * 将多个数组合并在一起
* 忽略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; } /** * 将多个数组合并在一起
* 忽略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; } /** * 将多个数组合并在一起
* 忽略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; } /** * 将多个数组合并在一起
* 忽略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; } /** * 将多个数组合并在一起
* 忽略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开始的数字列表
* * @param excludedEnd 结束的数字(不包含) * @return 数字列表 */ public static int[] range(int excludedEnd) { return range(0, excludedEnd, 1); } /** * 生成一个数字列表
* 自动判定正序反序 * * @param includedStart 开始的数字(包含) * @param excludedEnd 结束的数字(不包含) * @return 数字列表 */ public static int[] range(int includedStart, int excludedEnd) { return range(includedStart, excludedEnd, 1); } /** * 生成一个数字列表
* 自动判定正序反序 * * @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数组为几个等份(最后一份按照剩余长度分配空间) * * @param array 数组 * @param len 每个小节的长度 * @return 拆分后的数组 */ public static byte[][] split(byte[] array, int len) { int amount = array.length / len; final int remainder = array.length % len; if (remainder != 0) { ++amount; } final byte[][] arrays = new byte[amount][]; byte[] arr; for (int i = 0; i < amount; i++) { if (i == amount - 1 && remainder != 0) { // 有剩余,按照实际长度创建 arr = new byte[remainder]; System.arraycopy(array, i * len, arr, 0, remainder); } else { arr = new byte[len]; 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; } /** * 包装类数组转为原始类型数组
* {@code null} 按照 {@code false} 对待 * * @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); } // ------------------------------------------------------------------- remove /** * 移除数组中对应位置的元素
* 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); } /** * 移除数组中对应位置的元素
* 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); } /** * 移除数组中对应位置的元素
* 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); } /** * 移除数组中对应位置的元素
* 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); } /** * 移除数组中对应位置的元素
* 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); } /** * 移除数组中对应位置的元素
* 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); } /** * 移除数组中对应位置的元素
* 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); } /** * 移除数组中对应位置的元素
* 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); } /** * 移除数组中对应位置的元素
* 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 /** * 移除数组中指定的元素
* 只会移除匹配到的第一个元素 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)); } /** * 移除数组中指定的元素
* 只会移除匹配到的第一个元素 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)); } /** * 移除数组中指定的元素
* 只会移除匹配到的第一个元素 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)); } /** * 移除数组中指定的元素
* 只会移除匹配到的第一个元素 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)); } /** * 移除数组中指定的元素
* 只会移除匹配到的第一个元素 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)); } /** * 移除数组中指定的元素
* 只会移除匹配到的第一个元素 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)); } /** * 移除数组中指定的元素
* 只会移除匹配到的第一个元素 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)); } /** * 移除数组中指定的元素
* 只会移除匹配到的第一个元素 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; while (j > i) { swap(array, i, j); 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; while (j > i) { swap(array, i, j); 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; while (j > i) { swap(array, i, j); 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; while (j > i) { swap(array, i, j); 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; while (j > i) { swap(array, i, j); 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; while (j > i) { swap(array, i, j); 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; while (j > i) { swap(array, i, j); 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; while (j > i) { swap(array, i, j); 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; } // ---------------------------------------------------------------------- swap /** * 交换数组中两个位置的值 * * @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; } // ---------------------------------------------------------------------- asc and desc /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSorted(byte[] array) { return isSortedASC(array); } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedASC(byte[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] > array[i + 1]) { return false; } } return true; } /** * 检查数组是否降序,即array[i] >= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否降序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedDESC(byte[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] < array[i + 1]) { return false; } } return true; } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSorted(short[] array) { return isSortedASC(array); } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedASC(short[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] > array[i + 1]) { return false; } } return true; } /** * 检查数组是否降序,即array[i] >= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否降序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedDESC(short[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] < array[i + 1]) { return false; } } return true; } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSorted(char[] array) { return isSortedASC(array); } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedASC(char[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] > array[i + 1]) { return false; } } return true; } /** * 检查数组是否降序,即array[i] >= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否降序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedDESC(char[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] < array[i + 1]) { return false; } } return true; } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSorted(int[] array) { return isSortedASC(array); } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedASC(int[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] > array[i + 1]) { return false; } } return true; } /** * 检查数组是否降序,即array[i] >= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否降序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedDESC(int[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] < array[i + 1]) { return false; } } return true; } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSorted(long[] array) { return isSortedASC(array); } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedASC(long[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] > array[i + 1]) { return false; } } return true; } /** * 检查数组是否降序,即array[i] >= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否降序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedDESC(long[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] < array[i + 1]) { return false; } } return true; } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSorted(double[] array) { return isSortedASC(array); } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedASC(double[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] > array[i + 1]) { return false; } } return true; } /** * 检查数组是否降序,即array[i] >= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否降序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedDESC(double[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] < array[i + 1]) { return false; } } return true; } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSorted(float[] array) { return isSortedASC(array); } /** * 检查数组是否升序,即array[i] <= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否升序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedASC(float[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] > array[i + 1]) { return false; } } return true; } /** * 检查数组是否降序,即array[i] >= array[i+1],若传入空数组,则返回false * * @param array 数组 * @return 数组是否降序 * @author FengBaoheng * @since 5.5.2 */ public static boolean isSortedDESC(float[] array) { if (array == null) { return false; } for (int i = 0; i < array.length - 1; i++) { if (array[i] < array[i + 1]) { return false; } } return true; } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy