关于apache工具类ArrayUtils的简单应用

ArrayUtils是专门用来处理数组的工具类，提供很多有用的方法。下面将对ArraysUtils的使用做一下简单的介绍：
再使用前引入相关的maven依赖：
    

<dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.5</version>
    </dependency>

主要方法及说明详见如下代码（代码中的类型以int为例，实际方法中会根据不同类型（包括对象）选用不同的参数）：

import org.apache.commons.lang3.ArrayUtils;

import java.util.Map;

public class ArrayUtilsDemo {
    public static void main(String[] args) {
        int[] intArrays = {1, 2, 3};
        //检查该数据在该数组中是否存在，返回一个boolean值。
        testContains(intArrays);
        //将数组输出为Stirng,返回一个字符串。
        testToString(intArrays);
        //将给定的数据添加到指定的数组中，返回一个新的数组。
        testAdd(intArrays);
        //判断一个数组是否按照自然排序，返回boolean。
        testIsSorted(intArrays);
        //合并两个数组，返回一个新的数组
        testAddAll(intArrays);
        //返回数组的长度，返回数据类型为int
        testGetLength(intArrays);
        //将原数组复制成一个新的数组
        testClone(intArrays);
        //从数组的第一位开始查询该数组中是否有指定的数值，存在返回index的数值，否则返回-1。
        testIndexOf(intArrays);
        //从数组的最后一位开始往前查询该数组中是否有指定的数值，存在返回index的数值，否则返回-1。
        testLastIndexOf(intArrays);
        //判断该数组是否为空，返回一个boolean值。
        testIsEmpty(intArrays);
        //判断两个数组长度是否一致，返回boolean
        testIsSameLength(intArrays);
        //判断两个数组类型是否一致，返回boolean
        testIsSameType(intArrays);
        //null转换成空数组
        testNullToEmpty();
        //删除该数组指定位置上的元素，返回一个新的数组。
        testRemove(intArrays);
        //从该数组中删除第一次出现的指定元素，返回一个新的数组
        testRemoveElement(intArrays);
        //从该数组中删除指定数量的元素，返回一个新的数组，重复元素只删除第一次出现的元素
        testRemoveElements(intArrays);
        //从该数组中删除指定下标位置的元素，指定下标可以是数组或者散列下标，返回一个新的数组
        testRemoveAll(intArrays);
        //数组反转，可以指定反转区间（包头不包尾）。
        testReverse(intArrays);
        //截取数组（包头不包尾），返回一个新的数组。
        testSubArray(intArrays);
        //数组类型转换
        testTypeTrance(intArrays);
        //对指定位置元素进行位置交换
        testSwap(intArrays);
    }

    public static void testContains(int[] intArrays) {
        System.out.println("==========================testContains=========================");
        System.out.println("数组中是否含有3：" + ArrayUtils.contains(intArrays, 3));
        System.out.println("数组中是否含有4：" + ArrayUtils.contains(intArrays, 4));
    }

    public static void testToString(int[] intArrays){
        System.out.println("==========================testToString=========================");
        System.out.println(ArrayUtils.toString(intArrays));
        //如果数组为空，那么就打印指定的字符串stringIfNull
        System.out.println(ArrayUtils.toString(null,"I'm nothing"));
    }

    public static void testAdd(int[] intArrays) {
        System.out.println("==========================testAdd=========================");
        //新增元素默认置于数组最后
        int[] newIntArrays1 = ArrayUtils.add(intArrays, 5);
        System.out.println(ArrayUtils.toString(newIntArrays1));
        //新增元素置于指定位置
        int[] newIntArrays2 = ArrayUtils.add(intArrays, 1, 5);
        System.out.println(ArrayUtils.toString(newIntArrays2));
        //在给定的数组副本中加入传入的数组和给定的元素，如果给定的数组是null，那么会返回一个包含给定元素的数组
        System.out.println(ArrayUtils.toString(ArrayUtils.add(null,"我是新来的元素")));
    }

    public static void testIsSorted(int[] intArrays){
        System.out.println("==========================testIsSorted=========================");
        System.out.println("该数组({1,2,3})是否按照自然排序："+ArrayUtils.isSorted(intArrays));
        int[] intArrays1 = {1,4,3};
        System.out.println("该数组({1,4,3})是否按照自然排序："+ArrayUtils.isSorted(intArrays1));
        int[] intArrays2 = {3,2,1};
        System.out.println("该数组({3,2,1})是否按照自然排序："+ArrayUtils.isSorted(intArrays2));
    }


    public static void testAddAll(int[] intArrays) {
        System.out.println("==========================testAddAll=========================");
        int[] intArrays1 = {4,5,6};
        int[] newIntArrays = ArrayUtils.addAll(intArrays,intArrays1);
        System.out.println(ArrayUtils.toString(newIntArrays));
    }

    public static void testGetLength(int[] intArrays){
        System.out.println("==========================testGetLength=========================");
        System.out.println("数组长度为："+ArrayUtils.getLength(intArrays));
    }

    public static void testClone(int[] intArrays){
        System.out.println("==========================testClone=========================");
        int[] newIntArrays = ArrayUtils.clone(intArrays);
        System.out.println(ArrayUtils.toString(newIntArrays));
    }

    public static void testIndexOf(int[] intArrays){
        //查询某个Object在数组中的位置,可以指定起始搜索位置,找不到返回-1
        //从正序开始搜索,搜到就返回当前的index否则返回-1
        System.out.println("==========================testIndexOf=========================");
        System.out.println(ArrayUtils.indexOf(intArrays,2));
        System.out.println(ArrayUtils.indexOf(intArrays,5));
        //指定开始startIndex位置进行元素的查找
        System.out.println(ArrayUtils.indexOf(intArrays,2,1));
        System.out.println(ArrayUtils.indexOf(intArrays,2,2));
        System.out.println(ArrayUtils.indexOf(intArrays,5,1));
    }

    public static void testLastIndexOf(int[] intArrays){
        //查询某个Object在数组中的位置,可以指定起始搜索位置,找不到返回-1
        //从逆序开始搜索,搜到就返回当前的index否则返回-1
        System.out.println("==========================testLastIndexOf=========================");
        System.out.println(ArrayUtils.lastIndexOf(intArrays,2));
        System.out.println(ArrayUtils.lastIndexOf(intArrays,5));
        //指定开始startIndex位置(这里的startIndex位置并非从元素末端开始计数统计，还是从始端开始计数统计)进行元素的查找
        System.out.println(ArrayUtils.lastIndexOf(intArrays,2,0));
        System.out.println(ArrayUtils.lastIndexOf(intArrays,2,2));
        System.out.println(ArrayUtils.lastIndexOf(intArrays,2,3));
        System.out.println(ArrayUtils.lastIndexOf(intArrays,5,1));
    }

    public static void testIsEmpty(int[] intArrays){
        System.out.println("==========================testIsEmpty=========================");
        System.out.println(ArrayUtils.isEmpty(intArrays));
        System.out.println(ArrayUtils.isNotEmpty(intArrays));
        int[] intArrays1 = {};
        System.out.println("空数组({})是为空："+ArrayUtils.isEmpty(intArrays1)+"，数组长度为："+ArrayUtils.getLength(intArrays1));
        int[] intArrays2 = null;
        System.out.println("空数组(null)是为空："+ArrayUtils.isEmpty(intArrays2)+"，数组长度为："+ArrayUtils.getLength(intArrays2));
        System.out.println("空对象数组(new Object[]{}))是否为空："+ArrayUtils.isEmpty(new Object[]{})+"，数组长度为："+ArrayUtils.getLength(new Object[]{}));
        System.out.println("空对象数组(new Object[]{null}))是否为空："+ArrayUtils.isEmpty(new Object[]{null})+"，数组长度为："+ArrayUtils.getLength(new Object[]{null}));
    }

    public static void testIsSameLength(int[] intArrays){
        System.out.println("==========================testIsSameLength=========================");
        int[] intArrays1 = {4,5,6};
        int[] intArrays2 = {5,6};
        System.out.println(ArrayUtils.isSameLength(intArrays1,intArrays));
        System.out.println(ArrayUtils.isSameLength(intArrays2,intArrays));
    }

    public static void testIsSameType(int[] intArrays){
        System.out.println("==========================testIsSameType=========================");
        int[] intArrays1 = {4,5,6};
        long[] intArrays2 = {5,6};
        System.out.println(ArrayUtils.isSameType(intArrays1,intArrays));
        System.out.println(ArrayUtils.isSameType(intArrays2,intArrays));
    }

    public static void testNullToEmpty(){
        System.out.println("==========================testNullToEmpty=========================");
        int[] intArrays1 = null;
        int[] intArrays2 = ArrayUtils.nullToEmpty(intArrays1);
        System.out.println(ArrayUtils.toString(intArrays2));
    }

    public static void testRemove(int[] intArrays){
        System.out.println("==========================testRemove=========================");
        int[] intArrays1 = {2,3,4,5,6};
        int[] intArrays2 = ArrayUtils.addAll(intArrays,intArrays1);
        System.out.println("删除前："+ArrayUtils.toString(intArrays2));
        //删除指定下标位置的元素
        int[] intArrays3 = ArrayUtils.remove(intArrays2,1);
        System.out.println("删除后："+ArrayUtils.toString(intArrays3));

    }

    public static void testRemoveElement(int[] intArrays){
        System.out.println("==========================testRemoveElement=========================");
        int[] intArrays1 = {2,3,4,5,6};
        int[] intArrays2 = ArrayUtils.addAll(intArrays,intArrays1);
        System.out.println("删除前："+ArrayUtils.toString(intArrays2));
        //删除指定下标位置的元素
        int[] intArrays3 = ArrayUtils.removeElement(intArrays2,3);
        System.out.println("删除后："+ArrayUtils.toString(intArrays3));
    }

    public static void testRemoveElements(int[] intArrays){
        System.out.println("==========================testRemoveElements=========================");
        int[] intArrays1 = {2,3,4,5,6};
        int[] deleteArrays = {3,5,4};
        int[] intArrays2 = ArrayUtils.addAll(intArrays,intArrays1);
        System.out.println("删除前："+ArrayUtils.toString(intArrays2));
        //删除数组中出现的所有元素，若为重复元素，只删除第一次出现的元素
        int[] intArrays3 = ArrayUtils.removeElements(intArrays2,deleteArrays);
        System.out.println("删除后："+ArrayUtils.toString(intArrays3));
    }

    public static void testRemoveAll(int[] intArrays){
        System.out.println("==========================testRemoveAll=========================");
        int[] intArrays1 = {2,3,4,5,6};
        int[] intArrays2 = ArrayUtils.addAll(intArrays,intArrays1);
        System.out.println("删除前："+ArrayUtils.toString(intArrays2));
        //删除所有指定下标位置的元素
        //直接指定下标
        int[] intArrays3 = ArrayUtils.removeAll(intArrays2,3,5,7);

        //通过数组指定下标
        int[] indexArrays = {3,5,7};
        int[] intArrays4 = ArrayUtils.removeAll(intArrays2,indexArrays);

        System.out.println("删除后："+ArrayUtils.toString(intArrays3));
    }

    public static void testReverse(int[] intArrays){
        System.out.println("==========================testReverse=========================");
        ArrayUtils.reverse(intArrays);
        System.out.println(ArrayUtils.toString(intArrays));
        int[] intArrays1 = {4,5,6,7,8};
        int[] intArrays2 = ArrayUtils.addAll(intArrays,intArrays1);
        System.out.println("反转前："+ArrayUtils.toString(intArrays2));
        //指定范围的反转数组，包含开始位置，排除结束位置
        ArrayUtils.reverse(intArrays2,2,6);
        System.out.println("反转后："+ArrayUtils.toString(intArrays2));
    }

    public static void testSubArray(int[] intArrays){
        System.out.println("==========================testSubArray=========================");
        int[] intArrays1 = {4,5,6,7,8};
        int[] intArrays2 = ArrayUtils.addAll(intArrays,intArrays1);
        System.out.println("截取前："+ArrayUtils.toString(intArrays2));
        //截取范围，包含开始位置，排除结束位置
        int[] intArrays3 = ArrayUtils.subarray(intArrays2,3,7);
        System.out.println("截取后："+ArrayUtils.toString(intArrays3));
        //结束位置小于开始位置，那么结果为null
        int[] intArrays4 = ArrayUtils.subarray(intArrays2,3,2);
        System.out.println("截取后："+ArrayUtils.toString(intArrays4));
        //结束位置大于数组总长度，将截取开始位置后的所有数据
        int[] intArrays5 = ArrayUtils.subarray(intArrays2,3,10);
        System.out.println("截取后："+ArrayUtils.toString(intArrays5));
    }

    public static void testTypeTrance(int[] intArrays){
        System.out.println("==========================testTypeTrance=========================");
        //基本数据类型数组与外包型数据类型数组互转
        System.out.println("转换前："+ArrayUtils.toString(intArrays));
        Integer[] newIntegerArrays = ArrayUtils.toObject(intArrays);
        System.out.println("转换后："+ArrayUtils.toString(newIntegerArrays));
        int[] newIntArrays = ArrayUtils.toPrimitive(newIntegerArrays);
        System.out.println("转换后："+ArrayUtils.toString(newIntArrays));

        //二维数组转换为Map对象
        String[][] newArrays = {{"1","张三"},{"2","李四"},{"3","王五"}};
        Map mapName = ArrayUtils.toMap(newArrays);
        for (Object key:mapName.keySet()){
            System.out.println("Key = " + key + ", Value = " + mapName.get(key));
        }

        String[] newStringList = {"张三","李四","王五"};
        String[] newStringArrays1 = ArrayUtils.toArray(newStringList);
        System.out.println(ArrayUtils.toString(newStringArrays1));
        String[] newStringArrays2 = ArrayUtils.toArray("1","2","3");
        System.out.println(ArrayUtils.toString(newStringArrays2));
        String[] newStringArrays3 = ArrayUtils.<String>toArray("张三","李四","王五");
        System.out.println(ArrayUtils.toString(newStringArrays3));
        Number[] newStringArrays4 = ArrayUtils.<Number>toArray(1,2,3,4,5,6);
        System.out.println(ArrayUtils.toString(newStringArrays4));
    }

    public static void testSwap(int[] intArrays){
        System.out.println("==========================testSwap=========================");
        int[] intArrays1 = {4,5,6,7,8};
        int[] intArrays2 = ArrayUtils.addAll(intArrays,intArrays1);
        //指定位置的两个元素交换位置
        System.out.println("交换前："+ArrayUtils.toString(intArrays2));
        ArrayUtils.swap(intArrays2,4,7);
        System.out.println("交换后："+ArrayUtils.toString(intArrays2));
        //指定位置，指定长度，对元素位置进行交换
        ArrayUtils.swap(intArrays2,1,4,3);
        System.out.println("交换后："+ArrayUtils.toString(intArrays2));
    }
}

如有不当，忘指正。