com.neko233.toolchain.common.base.ArrayUtils233 Maven / Gradle / Ivy
package com.neko233.toolchain.common.base;
import java.lang.reflect.Array;
import java.util.Arrays;
public class ArrayUtils233 {
/**
* 对象是否为数组对象
*
* @param obj 对象
* @return 是否为数组对象，如果为{@code null} 返回false
*/
public static boolean isArray(Object obj) {
return null != obj && obj.getClass().isArray();
}
/**
* 数组是否为空
*
* @param 数组元素类型
* @param array 数组
* @return 是否为空
*/
public static boolean isEmpty(T[] array) {
return array == null || array.length == 0;
}
/**
* 数组或集合转String
*
* @param obj 集合或数组对象
* @return 数组字符串，与集合转字符串格式相同
*/
public static String toString(Object obj) {
if (null == obj) {
return null;
}
if (obj instanceof long[]) {
return Arrays.toString((long[]) obj);
} else if (obj instanceof int[]) {
return Arrays.toString((int[]) obj);
} else if (obj instanceof short[]) {
return Arrays.toString((short[]) obj);
} else if (obj instanceof char[]) {
return Arrays.toString((char[]) obj);
} else if (obj instanceof byte[]) {
return Arrays.toString((byte[]) obj);
} else if (obj instanceof boolean[]) {
return Arrays.toString((boolean[]) obj);
} else if (obj instanceof float[]) {
return Arrays.toString((float[]) obj);
} else if (obj instanceof double[]) {
return Arrays.toString((double[]) obj);
} else if (ArrayUtils233.isArray(obj)) {
// 对象数组
try {
return Arrays.deepToString((Object[]) obj);
} catch (Exception ignore) {
//ignore
}
}
return obj.toString();
}
/**
* 交换数组中两个位置的值. 非基本类型
*
* @param 元素类型
* @param array 数组
* @param index1 位置1
* @param index2 位置2
* @return 交换后的数组，与传入数组为同一对象
*/
public static T[] swap(T[] array, int index1, int index2) {
if (isEmpty(array)) {
throw new IllegalArgumentException("Array must not empty !");
}
T tmp = array[index1];
array[index1] = array[index2];
array[index2] = tmp;
return array;
}
/**
* 交换数组中两个位置的值. 基本类型
*
* @param baseArray 数组对象
* @param index1 位置1
* @param index2 位置2
* @return 交换后的数组，与传入数组为同一对象
*/
public static Object swap(Object baseArray, int index1, int index2) {
if (ObjectUtils233.isAnyNull(baseArray)) {
throw new IllegalArgumentException("Array must not empty !");
}
Object tmp = get(baseArray, index1);
Array.set(baseArray, index1, Array.get(baseArray, index2));
Array.set(baseArray, index2, tmp);
return baseArray;
}
/**
* 获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值
* 如果数组下标越界，返回null
*
* @param 数组元素类型
* @param array 数组对象
* @param index 下标，支持负数
* @return 值
*/
@SuppressWarnings("unchecked")
public static T get(Object array, int index) {
if (null == array) {
return null;
}
if (index < 0) {
index += Array.getLength(array);
}
try {
return (T) Array.get(array, index);
} catch (ArrayIndexOutOfBoundsException e) {
return null;
}
}
/**
* 生成一个从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;
}
}