精华内容
下载资源
问答
  • ArrayUtils

    2019-12-04 14:31:31
    ArrayUtils.toString(newint[] { 1, 4, 2, 3 });// {1,4,2,3} ArrayUtils.toString(new Integer[] { 1, 4, 2, 3 });// {1,4,2,3} ArrayUtils.toString(null, “I’m nothing!”);// I’m nothing! // 2.判断两个数组...

    // 1.打印数组
    ArrayUtils.toString(newint[] { 1, 4, 2, 3 });// {1,4,2,3}
    ArrayUtils.toString(new Integer[] { 1, 4, 2, 3 });// {1,4,2,3}
    ArrayUtils.toString(null, “I’m nothing!”);// I’m nothing!

    // 2.判断两个数组是否相等,采用EqualsBuilder进行判断
    // 只有当两个数组的数据类型,长度,数值顺序都相同的时候,该方法才会返回True
    // 2.1 两个数组完全相同
    ArrayUtils.isEquals(newint[] { 1, 2, 3 }, newint[] { 1, 2, 3 });// true
    // 2.2 数据类型以及长度相同,但各个Index上的数据不是一一对应
    ArrayUtils.isEquals(newint[] { 1, 3, 2 }, newint[] { 1, 2, 3 });//true
    // 2.3 数组的长度不一致
    ArrayUtils.isEquals(newint[] { 1, 2, 3, 3 }, newint[] { 1, 2, 3 });//false
    // 2.4 不同的数据类型
    ArrayUtils.isEquals(newint[] { 1, 2, 3 }, newlong[] { 1, 2, 3 });// false
    ArrayUtils.isEquals(new Object[] { 1, 2, 3 }, new Object[] { 1, (long) 2, 3 });// false
    // 2.5 Null处理,如果输入的两个数组都为null时候则返回true
    ArrayUtils.isEquals(newint[] { 1, 2, 3 }, null);// false
    ArrayUtils.isEquals(null, null);// true

    // 3.将一个数组转换成Map
    // 如果数组里是Entry则其Key与Value就是新Map的Key和Value,如果是Object[]则Object[0]为KeyObject[1]为Value
    // 对于Object[]数组里的元素必须是instanceof Object[]或者Entry,即不支持基本数据类型数组
    // 如:ArrayUtils.toMap(new Object[]{new int[]{1,2},new int[]{3,4}})会出异常
    ArrayUtils.toMap(new Object[] { new Object[] { 1, 2 }, new Object[] { 3, 4 } });// {1=2,
    // 3=4}
    ArrayUtils.toMap(new Integer[][] { new Integer[] { 1, 2 }, new Integer[] { 3, 4 } });// {1=2,
    // 3=4}

    // 4.拷贝数组
    ArrayUtils.clone(newint[] { 3, 2, 4 });// {3,2,4}

    // 5.截取数组
    ArrayUtils.subarray(newint[] { 3, 4, 1, 5, 6 }, 2, 4);// {1,5}
    // 起始index为2(即第三个数据)结束index为4的数组
    ArrayUtils.subarray(newint[] { 3, 4, 1, 5, 6 }, 2, 10);// {1,5,6}
    // 如果endIndex大于数组的长度,则取beginIndex之后的所有数据

    // 6.判断两个数组的长度是否相等
    ArrayUtils.isSameLength(new Integer[] { 1, 3, 5 }, new Long[] { 2L, 8L, 10L });// true

    // 7.获得数组的长度
    ArrayUtils.getLength(newlong[] { 1, 23, 3 });// 3

    // 8.判段两个数组的类型是否相同
    ArrayUtils.isSameType(newlong[] { 1, 3 }, newlong[] { 8, 5, 6 });// true
    ArrayUtils.isSameType(newint[] { 1, 3 }, newlong[] { 8, 5, 6 });// false

    // 9.数组反转
    int[] array =newint[] { 1, 2, 5 };
    ArrayUtils.reverse(array);// {5,2,1}

    // 10.查询某个Object在数组中的位置,可以指定起始搜索位置,找不到返回-1
    // 10.1 从正序开始搜索,搜到就返回当前的index否则返回-1
    ArrayUtils.indexOf(newint[] { 1, 3, 6 }, 6);// 2
    ArrayUtils.indexOf(newint[] { 1, 3, 6 }, 2);// -1
    // 10.2 从逆序开始搜索,搜到就返回当前的index否则返回-1
    ArrayUtils.lastIndexOf(newint[] { 1, 3, 6 }, 6);// 2

    // 11.查询某个Object是否在数组中
    ArrayUtils.contains(newint[] { 3, 1, 2 }, 1);// true
    // 对于Object数据是调用该Object.equals方法进行判断
    ArrayUtils.contains(new Object[] { 3, 1, 2 }, 1L);// false

    // 12.基本数据类型数组与外包型数据类型数组互转
    ArrayUtils.toObject(newint[] { 1, 2 });// new Integer[]{Integer,Integer}
    ArrayUtils.toPrimitive(new Integer[] { new Integer(1), new Integer(2) });// new int[]{1,2}

    // 13.判断数组是否为空(null和length=0的时候都为空)
    ArrayUtils.isEmpty(newint[0]);// true
    ArrayUtils.isEmpty(new Object[] { null });// false

    // 14.合并两个数组
    ArrayUtils.addAll(newint[] { 1, 3, 5 }, newint[] { 2, 4 });// {1,3,5,2,4}

    // 15.添加一个数据到数组
    ArrayUtils.add(newint[] { 1, 3, 5 }, 4);// {1,3,5,4}

    // 16.删除数组中某个位置上的数据
    ArrayUtils.remove(newint[] { 1, 3, 5 }, 1);// {1,5}

    // 17.删除数组中某个对象(从正序开始搜索,删除第一个)
    ArrayUtils.removeElement(newint[] { 1, 3, 5 }, 3);// {1,5}

    展开全文
  • ArrayUtils使用详解

    千次阅读 2018-11-02 15:29:48
    ArrayUtils 拥有以下方法:  toString  将一个数组转换成String,用于打印数组  isEquals  判断两个数组是否相等,采用EqualsBuilder进行判断  toMap  将一个数组转换成Map,如果数组里是Entry则其Key与Value就是...

    ArrayUtils 拥有以下方法: 
    toString 
    将一个数组转换成String,用于打印数组 
    isEquals 
    判断两个数组是否相等,采用EqualsBuilder进行判断 
    toMap 
    将一个数组转换成Map,如果数组里是Entry则其Key与Value就是新Map的Key和Value,如果是Object[]则Object[0]为KeyObject[1]为Value 
    clone 
    拷贝数组 
    subarray 
    截取子数组 
    isSameLength 
    判断两个数组长度是否相等 
    getLength 
    获得数组的长度 
    isSameType 
    判段两个数组的类型是否相同 
    reverse 
    数组反转 
    indexOf 
    查询某个Object在数组中的位置,可以指定起始搜索位置 
    lastIndexOf 
    反向查询某个Object在数组中的位置,可以指定起始搜索位置 
    contains 
    查询某个Object是否在数组中 
    toObject 
    将基本数据类型转换成外包型数据 
    isEmpty 
    判断数组是否为空(null和length=0的时候都为空) 
    addAll 
    合并两个数组 
    add 
    添加一个数据到数组 
    remove 
    删除数组中某个位置上的数据 
    removeElement 
    删除数组中某个对象(从正序开始搜索,删除第一个) 
    eg: 
            // 1.打印数组 
            ArrayUtils.toString(new int[] { 1, 4, 2, 3 });// {1,4,2,3} 
            ArrayUtils.toString(new Integer[] { 1, 4, 2, 3 });// {1,4,2,3} 
            ArrayUtils.toString(null, "I'm nothing!");// I'm nothing! 

            // 2.判断两个数组是否相等,采用EqualsBuilder进行判断 
            // 只有当两个数组的数据类型,长度,数值顺序都相同的时候,该方法才会返回True 
            // 2.1 两个数组完全相同 
            ArrayUtils.isEquals(new int[] { 1, 2, 3 }, new int[] { 1, 2, 3 });// true 
            // 2.2 数据类型以及长度相同,但各个Index上的数据不是一一对应 
            ArrayUtils.isEquals(new int[] { 1, 3, 2 }, new int[] { 1, 2, 3 });// true 
            // 2.3 数组的长度不一致 
            ArrayUtils.isEquals(new int[] { 1, 2, 3, 3 }, new int[] { 1, 2, 3 });// false 
            // 2.4 不同的数据类型 
            ArrayUtils.isEquals(new int[] { 1, 2, 3 }, new long[] { 1, 2, 3 });// false 
            ArrayUtils.isEquals(new Object[] { 1, 2, 3 }, new Object[] { 1, (long) 2, 3 });// false 
            // 2.5 Null处理,如果输入的两个数组都为null时候则返回true 
            ArrayUtils.isEquals(new int[] { 1, 2, 3 }, null);// false 
            ArrayUtils.isEquals(null, null);// true 

            // 3.将一个数组转换成Map 
            // 如果数组里是Entry则其Key与Value就是新Map的Key和Value,如果是Object[]则Object[0]为KeyObject[1]为Value 
            // 对于Object[]数组里的元素必须是instanceof Object[]或者Entry,即不支持基本数据类型数组 
            // 如:ArrayUtils.toMap(new Object[]{new int[]{1,2},new int[]{3,4}})会出异常 
            ArrayUtils.toMap(new Object[] { new Object[] { 1, 2 }, new Object[] { 3, 4 } });// {1=2, 
            // 3=4} 
            ArrayUtils.toMap(new Integer[][] { new Integer[] { 1, 2 }, new Integer[] { 3, 4 } });// {1=2, 
            // 3=4} 

            // 4.拷贝数组 
            ArrayUtils.clone(new int[] { 3, 2, 4 });// {3,2,4} 

            // 5.截取数组 
            ArrayUtils.subarray(new int[] { 3, 4, 1, 5, 6 }, 2, 4);// {1,5} 
            // 起始index为2(即第三个数据)结束index为4的数组 
            ArrayUtils.subarray(new int[] { 3, 4, 1, 5, 6 }, 2, 10);// {1,5,6} 
            // 如果endIndex大于数组的长度,则取beginIndex之后的所有数据 

            // 6.判断两个数组的长度是否相等 
            ArrayUtils.isSameLength(new Integer[] { 1, 3, 5 }, new Long[] { 2L, 8L, 10L });// true 

            // 7.获得数组的长度 
            ArrayUtils.getLength(new long[] { 1, 23, 3 });// 3 

            // 8.判段两个数组的类型是否相同 
            ArrayUtils.isSameType(new long[] { 1, 3 }, new long[] { 8, 5, 6 });// true 
            ArrayUtils.isSameType(new int[] { 1, 3 }, new long[] { 8, 5, 6 });// false 

            // 9.数组反转 
            int[] array = new int[] { 1, 2, 5 }; 
            ArrayUtils.reverse(array);// {5,2,1} 

            // 10.查询某个Object在数组中的位置,可以指定起始搜索位置,找不到返回-1 
            // 10.1 从正序开始搜索,搜到就返回当前的index否则返回-1 
            ArrayUtils.indexOf(new int[] { 1, 3, 6 }, 6);// 2 
            ArrayUtils.indexOf(new int[] { 1, 3, 6 }, 2);// -1 
            // 10.2 从逆序开始搜索,搜到就返回当前的index否则返回-1 
            ArrayUtils.lastIndexOf(new int[] { 1, 3, 6 }, 6);// 2 

            // 11.查询某个Object是否在数组中 
            ArrayUtils.contains(new int[] { 3, 1, 2 }, 1);// true 
            // 对于Object数据是调用该Object.equals方法进行判断 
            ArrayUtils.contains(new Object[] { 3, 1, 2 }, 1L);// false 

            // 12.基本数据类型数组与外包型数据类型数组互转 
            ArrayUtils.toObject(new int[] { 1, 2 });// new Integer[]{Integer,Integer} 
            ArrayUtils.toPrimitive(new Integer[] { new Integer(1), new Integer(2) });// new int[]{1,2} 

            // 13.判断数组是否为空(null和length=0的时候都为空) 
            ArrayUtils.isEmpty(new int[0]);// true 
            ArrayUtils.isEmpty(new Object[] { null });// false 

            // 14.合并两个数组 
            ArrayUtils.addAll(new int[] { 1, 3, 5 }, new int[] { 2, 4 });// {1,3,5,2,4} 

            // 15.添加一个数据到数组 
            ArrayUtils.add(new int[] { 1, 3, 5 }, 4);// {1,3,5,4} 

            // 16.删除数组中某个位置上的数据 
            ArrayUtils.remove(new int[] { 1, 3, 5 }, 1);// {1,5} 

            // 17.删除数组中某个对象(从正序开始搜索,删除第一个) 
            ArrayUtils.removeElement(new int[] { 1, 3, 5 }, 3);// {1,5} 

    from:http://yangchao20020.blog.163.com/blog/static/48382247200972715721456/

    http://zhangyinhu8680.iteye.com/blog/1886870

    展开全文
  • Java的ArrayUtils的常用方法

    千次阅读 2020-07-24 15:21:35
    // 如:ArrayUtils.toMap(new Object[]{new int[]{1,2},new int[]{3,4}})会出异常 ArrayUtils.toMap(new Object[] { new Object[] { 1, 2 }, new Object[] { 3, 4 } });// {1=2, // 3=4} ...

    toString

    将一个数组转换成String,用于打印数组

    isEquals

    判断两个数组是否相等,采用EqualsBuilder进行判断

    toMap

    将一个数组转换成Map,如果数组里是Entry则其Key与Value就是新Map的Key和Value,如果是Object[]则Object[0]为KeyObject[1]为Value

    clone

    拷贝数组

    subarray

    截取子数组

    isSameLength

    判断两个数组长度是否相等

    getLength

    获得数组的长度

    isSameType

    判段两个数组的类型是否相同

    reverse

    数组反转

    indexOf

    查询某个Object在数组中的位置,可以指定起始搜索位置

    lastIndexOf

    反向查询某个Object在数组中的位置,可以指定起始搜索位置

    contains

    查询某个Object是否在数组中

    toObject

    将基本数据类型转换成外包型数据

    isEmpty

    判断数组是否为空(null和length=0的时候都为空)

    addAll

    合并两个数组

    add

    添加一个数据到数组

    remove

    删除数组中某个位置上的数据

    removeElement

    删除数组中某个对象(从正序开始搜索,删除第一个)

    =============================================

       // 1.打印数组
            ArrayUtils.toString(new int[] { 1, 4, 2, 3 });// {1,4,2,3}
            ArrayUtils.toString(new Integer[] { 1, 4, 2, 3 });// {1,4,2,3}
            ArrayUtils.toString(null, "I'm nothing!");// I'm nothing!

            // 2.判断两个数组是否相等,采用EqualsBuilder进行判断
            // 只有当两个数组的数据类型,长度,数值顺序都相同的时候,该方法才会返回True
            // 2.1 两个数组完全相同
            ArrayUtils.isEquals(new int[] { 1, 2, 3 }, new int[] { 1, 2, 3 });// true
            // 2.2 数据类型以及长度相同,但各个Index上的数据不是一一对应
            ArrayUtils.isEquals(new int[] { 1, 3, 2 }, new int[] { 1, 2, 3 });// true
            // 2.3 数组的长度不一致
            ArrayUtils.isEquals(new int[] { 1, 2, 3, 3 }, new int[] { 1, 2, 3 });// false
            // 2.4 不同的数据类型
            ArrayUtils.isEquals(new int[] { 1, 2, 3 }, new long[] { 1, 2, 3 });// false
            ArrayUtils.isEquals(new Object[] { 1, 2, 3 }, new Object[] { 1, (long) 2, 3 });// false
            // 2.5 Null处理,如果输入的两个数组都为null时候则返回true
            ArrayUtils.isEquals(new int[] { 1, 2, 3 }, null);// false
            ArrayUtils.isEquals(null, null);// true

            // 3.将一个数组转换成Map
            // 如果数组里是Entry则其Key与Value就是新Map的Key和Value,如果是Object[]则Object[0]为KeyObject[1]为Value
            // 对于Object[]数组里的元素必须是instanceof Object[]或者Entry,即不支持基本数据类型数组
            // 如:ArrayUtils.toMap(new Object[]{new int[]{1,2},new int[]{3,4}})会出异常
            ArrayUtils.toMap(new Object[] { new Object[] { 1, 2 }, new Object[] { 3, 4 } });// {1=2,
            // 3=4}
            ArrayUtils.toMap(new Integer[][] { new Integer[] { 1, 2 }, new Integer[] { 3, 4 } });// {1=2,
            // 3=4}

            // 4.拷贝数组
            ArrayUtils.clone(new int[] { 3, 2, 4 });// {3,2,4}

            // 5.截取数组
            ArrayUtils.subarray(new int[] { 3, 4, 1, 5, 6 }, 2, 4);// {1,5}
            // 起始index为2(即第三个数据)结束index为4的数组
            ArrayUtils.subarray(new int[] { 3, 4, 1, 5, 6 }, 2, 10);// {1,5,6}
            // 如果endIndex大于数组的长度,则取beginIndex之后的所有数据

            // 6.判断两个数组的长度是否相等
            ArrayUtils.isSameLength(new Integer[] { 1, 3, 5 }, new Long[] { 2L, 8L, 10L });// true

            // 7.获得数组的长度
            ArrayUtils.getLength(new long[] { 1, 23, 3 });// 3

            // 8.判段两个数组的类型是否相同
            ArrayUtils.isSameType(new long[] { 1, 3 }, new long[] { 8, 5, 6 });// true
            ArrayUtils.isSameType(new int[] { 1, 3 }, new long[] { 8, 5, 6 });// false

            // 9.数组反转
            int[] array = new int[] { 1, 2, 5 };
            ArrayUtils.reverse(array);// {5,2,1}

            // 10.查询某个Object在数组中的位置,可以指定起始搜索位置,找不到返回-1
            // 10.1 从正序开始搜索,搜到就返回当前的index否则返回-1
            ArrayUtils.indexOf(new int[] { 1, 3, 6 }, 6);// 2
            ArrayUtils.indexOf(new int[] { 1, 3, 6 }, 2);// -1
            // 10.2 从逆序开始搜索,搜到就返回当前的index否则返回-1
            ArrayUtils.lastIndexOf(new int[] { 1, 3, 6 }, 6);// 2

            // 11.查询某个Object是否在数组中
            ArrayUtils.contains(new int[] { 3, 1, 2 }, 1);// true
            // 对于Object数据是调用该Object.equals方法进行判断
            ArrayUtils.contains(new Object[] { 3, 1, 2 }, 1L);// false

           

            // 12.基本数据类型数组与外包型数据类型数组互转
            ArrayUtils.toObject(new int[] { 1, 2 });// new Integer[]{Integer,Integer}
            ArrayUtils.toPrimitive(new Integer[] { new Integer(1), new Integer(2) });// new int[]{1,2}

            // 13.判断数组是否为空(null和length=0的时候都为空)
            ArrayUtils.isEmpty(new int[0]);// true
            ArrayUtils.isEmpty(new Object[] { null });// false

            // 14.合并两个数组
            ArrayUtils.addAll(new int[] { 1, 3, 5 }, new int[] { 2, 4 });// {1,3,5,2,4}

            // 15.添加一个数据到数组
            ArrayUtils.add(new int[] { 1, 3, 5 }, 4);// {1,3,5,4}

            // 16.删除数组中某个位置上的数据
            ArrayUtils.remove(new int[] { 1, 3, 5 }, 1);// {1,5}

            // 17.删除数组中某个对象(从正序开始搜索,删除第一个)
            ArrayUtils.removeElement(new int[] { 1, 3, 5 }, 3);// {1,5}

    展开全文
  • ArrayUtils是专门用来处理数组的工具类,提供很多有用的方法。下面将对ArraysUtils的使用做一下简单的介绍: 再使用前引入相关的maven依赖: <dependency> <groupId>org.apache.commons</...

    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));
        }
    }


    如有不当,忘指正。

    展开全文
  • 2、ArrayUtils中的方法: 3、举例 1、引入pom依赖 <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 --> <dependency> <groupId>org.apache.commons</groupId&...
  • Apache Commons Lang提供了一个ArrayUtils类,其中包含toString(Object)方法,该方法“将数组作为字符串输出”。 在本文中,我将研究当JDK提供Arrays.toString(Object [])方法[以及原始类型数组的Arrays类上该...
  • ArrayUtils中的方法: 1.add():将给定的数据添加到指定的数组中,返回一个新的数组。 2.addAll():合并两个数组。 3.contains():检查该数据在该数组中是否存在,返回一个boolean值。 4.getLength():返回该数组...
  • ArrayUtils.indexOf(array, value)) 获取 value在数组中对应的索引位置 Arrays.stream() 数组转流后的方法: map() 根据某种规则映射成一个新的数组(结合函数式接口lambda表达式) Arrays.stream(array).map(a ->...
  • [ 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 ...
  • java 工具类ArrayUtils基本使用

    千次阅读 2018-08-22 15:30:32
    ArrayUtils是专门用来处理数组的工具类,提供很多有用的方法,下面是其一个方法蓝图:   添加方法  add(boolean[] array,boolean element)等等  add(T[] array,int index,T element)等等  addAll(boolean...
  •  ArrayUtils.toMap(new Integer[][] { new Integer[] { 1, 2 }, new Integer[] { 3, 4 } });// {1=2,  // 3=4}  // 4.拷贝数组  ArrayUtils.clone(new int[] { 3, 2, 4 });// {3,2,4} ...
  • ArrayUtils常用方法

    2020-05-18 17:59:00
    /** * Contains * 如果某个数组包含某个值就返回true, 否则返回false */ public static void testContains() { int []array= {1,2,3};... System.out.println(ArrayUtils.contains(array, ...
  • arrut:ArrayUtils-源码

    2021-05-15 08:24:32
    ArrayUtils arrut.isEmpty var array = [ "a" , "b" , "c" ] ; var empty = arrut . isEmpty ( array ) ; // false 阿鲁特克隆 var array = [ "a" , "b" , "c" ] ; var clone = arrut . clone ( array ) ; // [...
  • /** * ArrayUtils常用方法除了下面的,还有isEmpty(),add(),indexOf(),isEquals()等 * */ public class TestArrayUtils { public static void main(String []args) { testToObject(); } /** * Contains * ...
  • ArrayUtils 方法

    2019-09-25 03:52:36
     ArrayUtils.toString( new   int [] {  1 ,  4 ,  2 ,  3  }); //  {1,4,2,3}  ArrayUtils.toString( new  Integer[] {  1 ,  4 ,  2 ,  3  }); //  {1,4,2,3}  ArrayUtils.toString( null ,  ...
  • ArrayUtils 拥有以下方法: toString 将一个数组转换成String,用于打印数组 isEquals 判断两个数组是否相等,采用EqualsBuilder进行判断 toMap 将一个数组转换成Map,如果数组里是Entry则其Key与Value就是新Map...
  • ArrayUtils提供了很多方便操作数组的方法,并且这些方法都是空指针安全的。它提供了很多基本类型及引用类型的重载。 API static T[] add(T[] array, T element) 复制给定的数组,并且将给定的元素添加到新数组的...
  • commons-lang3:ArrayUtils

    2018-04-26 10:00:00
    ArrayUtils.add([true, false], true) = [true, false, true] add(boolean[] array, int index, boolean element)  将给定的数据添加到指定的数组下标中,返回一个新的数组。 ArrayUtils.add(null, 0, true) ...
  • ArrayUtils工具类 常用方法 ArrayUtils.add(array,ele) 向数组尾部添加一个元素 ArrayUtils.addAll(array,ele1,…,elen) 向数组尾部,同时添加多个数据 ArrayUtils.insert(index,array,elel,…,elen) 向数组指定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,057
精华内容 3,222
关键字:

arrayutils