【数组工具类】ArrayUtils

[ commons.lang3 ] ArrayUtils数组工具类

常量

public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];

public static final Class<?>[] EMPTY_CLASS_ARRAY = new Class[0];

public static final String[] EMPTY_STRING_ARRAY = new String[0];

public static final long[] EMPTY_LONG_ARRAY = new long[0];

public static final Long[] EMPTY_LONG_OBJECT_ARRAY = new Long[0];

public static final int[] EMPTY_INT_ARRAY = new int[0];

public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new Integer[0];

public static final short[] EMPTY_SHORT_ARRAY = new short[0];

public static final Short[] EMPTY_SHORT_OBJECT_ARRAY = new Short[0];

public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];

public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = new Byte[0];

public static final double[] EMPTY_DOUBLE_ARRAY = new double[0];

public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = new Double[0];

public static final float[] EMPTY_FLOAT_ARRAY = new float[0];

public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = new Float[0];

public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];

public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = new Boolean[0];

public static final char[] EMPTY_CHAR_ARRAY = new char[0];

public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = new Character[0];

public static final int INDEX_NOT_FOUND = -1;

 

ArrayUtils.isEmpty => 判读数组是否为空

ArrayUtils.isEmpty(new String[]{"A", "1"}); // false

 

ArrayUtils.isNotEmpty => 判读数组是否不为空

ArrayUtils.isNotEmpty(new String[]{"A", "1"}); // true

 

 ArrayUtils.isSameLength => 判断数组1和数组2大小是否相等，两个数组类型需一致

ArrayUtils.isSameLength(数组一, 数组二);

 

ArrayUtils.isSameType => 判断数组1和数组2类型是否一致

ArrayUtils.isSameType(数组一, 数组二);

 

ArrayUtils.isEquals => 判读数组1和数组2是否相等

 ArrayUtils.isEquals(数组一, 数组二);

 

ArrayUtils.toString => 数组序列化

ArrayUtils.toString(new String[]{"A", "1"});
// {"A", "1"}

 

ArrayUtils.clone => 克隆一份数组

String[] clone = ArrayUtils.clone(new String[]{"A", "1"});
// clone = ["A", "1"] 

 

ArrayUtils.subarray => 截取子数组，从第A索引开始截取到第N个索引(不包含N)

String[] subarray = ArrayUtils.subarray(new String[]{"A", "1"}, 0, 1);
// subarray = ["A"] 

 

ArrayUtils.indexOf => 查询对象在数组中的位置，从指定索引处开始搜索，找到返回索引，否则返回-1

int index = ArrayUtils.indexOf(new String[]{"A", "1"}, "A");
// index = 0 

 

ArrayUtils.lastIndexOf => 跟indexOf功能相似，但是从后往前找

int index = ArrayUtils.lastIndexOf(new String[]{"A", "1"}, "A");
// index = 0 

 

ArrayUtils.contains => 判读object是否在数组中存在，是否包含

boolean isExist = ArrayUtils.contains(new String[]{"A", "1"}, "A");
// isExist = true 

 

ArrayUtils.reverse => 反转数组

String[] reverse = ArrayUtils.reverse(new String[]{"A", "1"});
// reverse = ["1", "A"] 

 

ArrayUtils.add => 添加对象到数组

String[] add = ArrayUtils.add(new String[]{"A", "1"}, "B");
// add = ["A", "1", "B"] 

 

ArrayUtils.addAll => 合并两个数组

String[] addAll = ArrayUtils.reverse(new String[]{"A", "1"}, new String[]{"B", "2"});
// addAll = ["A", "1", "B", "2"]

 

ArrayUtils.remove => 删除数组某个索引位置的元素

String[] remove = ArrayUtils.remove(new String[]{"A", "1"}, 0);
// remove = ["1"] 

 

ArrayUtils.removeElement => 删除数组中某个对象

String[] removeElement = ArrayUtils.remove(new String[]{"A", "1"}, "A");
// removeElement = ["1"] 

ArrayUtils.hashCode => 获取数组哈希码

int hashCode = ArrayUtils.hashCode(tempStringArray);

 

ArrayUtils.isSorted => 判断数组是否已按照自然排序

boolean isSorted = ArrayUtils.isSorted(stringArray2);

 

ArrayUtils.nullToEmpty => 如果数组为null返回一个空数组

String[] arr = null;
String[] isNullToEmpty = ArrayUtils.nullToEmpty(arr);
// null无输出, 输出：empty
if(null == isNullToEmpty) {
    System.out.println("null");
}
if(isNullToEmpty.length == 0) {
    System.out.println("empty");
}

 

ArrayUtils.shift => 数组元素位置循环移位, 2 代表每个元素都向前移动2个位置，

String[] array = {"second", "third", "second", "first", "first"};
ArrayUtils.shift(array, 2);
// 移动后：array = {"second", "first", "second", "first", "third"}

 
ArrayUtils.swap => 交换数组中两个指定索引位置的元素，无返回值

String[] array = {"second", "third", "second", "first", "first"};
ArrayUtils.swap(array , 1, 4);

 

ArrayUtils.toObject => 将基本数据类型的数组转化为包装类型的数组

Boolean[] booleanArrays = ArrayUtils.toObject(new boolean[] {true, false});

 
ArrayUtils.toPrimitive => 将包装类型的数据转化为基本类型的数组

boolean[] primitiveArray = ArrayUtils.toPrimitive(new Boolean[0]);

 
ArrayUtils.toString => 序列化数组，将数组以 {,} 形式输出

System.out.print(ArrayUtils.toString(new String[]{"second","third"})); 
// {second,third}

        
ArrayUtils.toMap => 将二维数据转为MAP

Map colorMap = ArrayUtils.toMap(new String[][] {
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}});

 

ArrayUtils.removeAll => 删除指定位置上的元素，返回一个新的数组。

ArrayUtils.removeAll(new String[]{"a", "b", "c"}, 0, 2); // ["b"]
ArrayUtils.removeAll(new String[]{"a", "b", "c"}, 1, 2); // ["a"]

 

ArrayUtils.removeElements => 从该数组中删除指定数量的元素，返回一个新的数组。

ArrayUtils.removeElements(new String[]{"a", "b", "a"}, "a", "a"); // ["b"]

 

ArrayUtils.removeAllOccurences => 从该数组中删除指定的元素，返回一个新的数组。

ArrayUtils.removeAllOccurences(new String[]{"a", "b", "a"}, "a"); // ["b"]