Chinaunix首页 | 论坛 | 博客
  • 博客访问: 3252423
  • 博文数量: 530
  • 博客积分: 13360
  • 博客等级: 上将
  • 技术积分: 5473
  • 用 户 组: 普通用户
  • 注册时间: 2006-07-13 13:32
文章分类

全部博文(530)

文章存档

2017年(1)

2015年(2)

2013年(24)

2012年(20)

2011年(97)

2010年(240)

2009年(117)

2008年(12)

2007年(8)

2006年(9)

分类: Java

2010-08-16 12:05:10

更新日期:2010年9月4日
ArrayUtils类概述
数组是我们经常需要使用到的一种数据结构,但是由于Java本身并没有提供很好的API支持,使得很多操作实际上做起来相当繁琐,以至于我们实际编码中甚至 会不惜牺牲性能去使用Collections API,用Collection当然能够很方便的解决我们的问题,但是我们一定要以性能为代价吗?ArrayUtils帮我们解决了处理类似情况的大部分问题。

代码版本:apache.commons.lang3.0

1 add()
2.1 添加一个基本数据类型的数据到数组最后
         boolean[] add(boolean[] array, boolean element)
         byte[] add(byte[] array, byte element)
         char[] add(char[] array, char element)
         double[] add(double[] array, double element)
         float[] add(float[] array, float element)
         int[] add(int[] array, int element)
         long[] add(long[] array, long element)
         short[] add(short[] array, short element)
功能:添加一个元素到数组,所有元素必须是同一类型
         生成一个新的数组,将新元素添加到数组的最后,而不改变原来数组的长度

代码精解
Object copyArrayGrow1(Object array, Class newArrayComponentType)函数
        if (array != null) {
            int arrayLength = Array.getLength(array);//获取数组长度
            //创建一个新数组,并设置数组的类型和长度
            Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
            //将数组的内容复制到新数组中
            System.arraycopy(array, 0, newArray, 0, arrayLength);
            return newArray;
        }      
        //如果数组为null,则需要外部传递元素类型,并将长度设置为1
        return Array.newInstance(newArrayComponentType, 1);
add函数
        int[] newArray = (int[])copyArrayGrow1(array, Integer.TYPE);//传递数组引用和元素类型
        newArray[newArray.length - 1] = element;//将新元素直接赋值到最后一个
例:
       ArrayUtils.add(null, '0')       结果为 ['0']
       ArrayUtils.add(['1'], '0')       结果为 ['1', '0']
       ArrayUtils.add(['1', '0'], '1')  结果为 ['1', '0', '1']

2.2 添加一个对象到数组最后
       T[] add(T[] array, T element)
功能:复制给定的数组中所有的元素,并将新元素插入到新数组的最后
         所有的元素必须是同一类型
         生成一个新的数组,将新元素添加到数组的最后,而不改变原来数组的长度
代码精解
        Class type;
        if (array != null){
            type = array.getClass();   //如果数组不为null,获取数组中的元素类型
        } else if (element != null) {
            type = element.getClass(); //如果数组为空但元素不为null,获取元素类型
        }
        T[] newArray = (T[]) copyArrayGrow1(array, type);
例:
        ArrayUtils.add(null, null)      结果为 [null]
        ArrayUtils.add(null, "a")       结果为 ["a"]
        ArrayUtils.add(["a"], null)     结果为 ["a", null]
        ArrayUtils.add(["a"], "b")     结果为 ["a", "b"]
        ArrayUtils.add(["a", "b"], "c")结果为 ["a", "b", "c"]

2.3 添加一个基本数据元素到数组中的指定位置
        char[] add(char[] array, int index, char element)
        boolean[] add(boolean[] array, int index, boolean element)
        byte[] add(byte[] array, int index, byte element
        short[] add(short[] array, int index, short element)
        int[] add(int[] array, int index, int element)
        long[] add(long[] array, int index, long element)
        float[] add(float[] array, int index, float element)
        double[] add(double[] array, int index, double element)
功能:添加一个基本类型的数据到数组中指定位置
         生成一个新的数组,将新元素添加到数组的指定位置,而不改变原来数组的长度
代码精解
        return (int[]) add(array, index, Integer.valueOf(element), Integer.TYPE);
Object add(Object array, int index, Object element, Class clss)
        int length = Array.getLength(array);  //获取数组长度
        if (index > length || index < 0) {    //如果指定位置错误,则抛出异常
            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
        }
        Object result = Array.newInstance(clss, length + 1);//创建一个新数组,长度比旧的多一个
        System.arraycopy(array, 0, result, 0, index); //将数组中所有元素复制到新数组中
        Array.set(result, index, element);  //将指定元素赋值给到新数组的指定位置,实际上覆盖了一个数据
        if (index < length) {
            //重新将数组中index之后的数据复制到新数组的index+1
            System.arraycopy(array, index, result, index + 1, length - index);
        }
例:
        ArrayUtils.add([1], 0, 2)         结果为 [2, 1]
        ArrayUtils.add([2, 6], 2, 10)    结果为 [2, 6, 10]
        ArrayUtils.add([2, 6], 0, -4)    结果为 [-4, 2, 6]
        ArrayUtils.add([2, 6, 3], 2, 1)  结果为 [2, 6, 1, 3]

2.4 添加一个对象到数组中的指定位置
        T[] add(T[] array, int index, T element)
功能:添加一个对象到数组中指定位置
         生成一个新的数组,将新元素添加到数组的指定位置,而不改变原来数组的长度
代码精解
       Class clss = null;
        if (array != null) {
            clss = array.getClass().getComponentType();//如果数组不为空,获取数组中的元素类型
        } else if (element != null) {
            clss = element.getClass();//如果数组为空但元素为空,则获取插入元素的类型
        }
        final T[] newArray = (T[]) add(array, index, element, clss);
例:
       ArrayUtils.add(null, 0, null)      = [null]
       ArrayUtils.add(null, 0, "a")       = ["a"]
       ArrayUtils.add(["a"], 1, null)     = ["a", null]
       ArrayUtils.add(["a"], 1, "b")      = ["a", "b"]
       ArrayUtils.add(["a", "b"], 3, "c") = ["a", "b", "c"]

注意:
       1.元素类型的参数类型用Class表示
       2.System.arraycopy的速度比直接赋值的速度快,复制的内容越多,就越多,详见http://www.blogjava.net/needjava/archive/2007/09/16/145513.html


2.addAll
2.1 合并以基本类型为元素的数组
格式
       boolean[] addAll(boolean[] array1, boolean... array2)
       char[] addAll(char[] array1, char... array2)
       byte[] addAll(byte[] array1, byte... array2)
       short[] addAll(short[] array1, short... array2)
       int[] addAll(int[] array1, int... array2)
       long[] addAll(long[] array1, long... array2)
       float[] addAll(float[] array1, float... array2)
       double[] addAll(double[] array1, double... array2)
功能
       合并两个数组,首先包含array1,再包含array2,返回的是新数组,不改变已有的两个数组
代码精解
       if (array1 == null) {
            return clone(array2); //array1为空,且直接复制array2
        } else if (array2 == null) {
            return clone(array1);//array2为空,且直接复制array1
        }
        //生成一个新数组
        char[] joinedArray = new char[array1.length + array2.length];
        分别将两个数组内容复制到新数组
        System.arraycopy(array1, 0, joinedArray, 0, array1.length);
        System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);

        ArrayUtils.addAll(array1, null)   结果为 cloned copy of array1
        ArrayUtils.addAll(null, array2)   结果为 cloned copy of array2
        ArrayUtils.addAll([], [])         结果为 []

2.2合并以对象为元素的数组
格式
        T[] addAll(T[] array1, T... array2)
功能
        合并两个数组,首先包含array1,再包含array2,返回的是新数组,不改变已有的两个数组
代码精解
        //获取array1的类型
        final Class type1 = array1.getClass().getComponentType();
        @SuppressWarnings("unchecked") // 忽略类型检查
        //创建一个新数组,分别复制两个数组的内容到新数组
        T[] joinedArray = (T[]) Array.newInstance(type1, array1.length + array2.length);
        System.arraycopy(array1, 0, joinedArray, 0, array1.length);
        System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);

3.ArrayUtils.clone
格式
        T[] clone(T[] array)
        long[] clone(long[] array)
        int[] clone(int[] array)
        short[] clone(short[] array)
        char[] clone(char[] array)
        byte[] clone(byte[] array)
        double[] clone(double[] array)
        float[] clone(float[] array)
        boolean[] clone(boolean[] array)
功能
        克隆一个数组,如果数组为空,则返回null
代码精解
        if (array == null) {
            return null;
        }
        return array.clone();

4.ArrayUtils.contains
格式
       boolean contains(Object[] array, Object objectToFind)
       boolean contains(long[] array, long valueToFind)
       boolean contains(int[] array, int valueToFind)
       boolean contains(short[] array, short valueToFind)
       boolean contains(char[] array, char valueToFind)
       boolean contains(byte[] array, byte valueToFind)
       boolean contains(double[] array, double valueToFind)
       boolean contains(float[] array, float valueToFind)
       boolean contains(boolean[] array, boolean valueToFind)
功能
       检查一个元素是否在array中
代码精解
       return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
       INDEX_NOT_FOUND的值为-1
       return indexOf(array, objectToFind, 0);

       int indexOf(Object[] array, Object objectToFind, int startIndex)
       //如果数组的类型与objectToFind的类型相同
       if (array.getClass().getComponentType().isInstance(objectToFind)) {
            for (int i = startIndex; i < array.length; i++) {
                if (objectToFind.equals(array[i])) {
                    return i;
                }
            }
       }


5.ArrayUtils.indexOf
格式
       int indexOf(int[] array, int valueToFind)
功能
       从数组的第0位置开始,检查valueToFind相同值的第一个元素出现的位置,
代码精解
       for (int i = startIndex; i < array.length; i++) {
            if (valueToFind == array[i]) {
                return i;
            }
       }

6.ArrayUtils.isEmpty
格式
      boolean isEmpty(T[] array)
      boolean isEmpty(long[] array)
      boolean isEmpty(int[] array)
      boolean isEmpty(short[] array)
      boolean isEmpty(char[] array)
      boolean isEmpty(byte[] array)
      boolean isEmpty(double[] array)
      boolean isEmpty(float[] array)
      boolean isEmpty(boolean[] array)
功能
      检查数组是否为空
代码精解
       if (array == null || array.length == 0) {
            return true;
        }
        return false;

7.ArrayUtils.isEquals
格式
        boolean isEquals(Object array1, Object array2)
功能
        比较两个数组是否相同
关键代码
        return new EqualsBuilder().append(array1, array2).isEquals();
例:
        Object[] array3 = new Object[]{new String(new char[]{'A', 'B'})};
        Object[] array4 = new Object[]{"AB"};
        assertEquals(true, ArrayUtils.isEquals(array3, array3));
        assertEquals(true, ArrayUtils.isEquals(array3, array4));

8.ArrayUtils.isSameLength
格式
       boolean isSameLength(Object[] array1, Object[] array2)
       boolean isSameLength(long[] array1, long[] array2)
       boolean isSameLength(int[] array1, int[] array2)
       boolean isSameLength(short[] array1, short[] array2)
       boolean isSameLength(char[] array1, char[] array2)
       boolean isSameLength(byte[] array1, byte[] array2)
       boolean isSameLength(double[] array1, double[] array2)
       boolean isSameLength(float[] array1, float[] array2)
       boolean isSameLength(boolean[] array1, boolean[] array2)
功能
       比较两个数组长度是否相同
代码精解
        if ((array1 == null && array2 != null && array2.length > 0) ||
            (array2 == null && array1 != null && array1.length > 0) ||
            (array1 != null && array2 != null && array1.length != array2.length)) {
                return false;
        }
        return true;

9.ArrayUtils.lastIndexOf
格式
        int lastIndexOf(Object[] array, Object objectToFind)
        int lastIndexOf(boolean[] array, boolean valueToFind)
        int lastIndexOf(long[] array, long valueToFind)
        int lastIndexOf(int[] array, int valueToFind)
        int lastIndexOf(short[] array, short valueToFind)
        int lastIndexOf(char[] array, char valueToFind)
        int lastIndexOf(byte[] array, byte valueToFind)
功能
       获取给定元素在数组中的最后位置
代码精解
       return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
       Integer.MAX_VALUE:整数的最大值

       int lastIndexOf(byte[] array, byte valueToFind, int startIndex) {
        if (array == null) {
            return INDEX_NOT_FOUND;
        }
        if (startIndex < 0) {
            return INDEX_NOT_FOUND;
        } else if (startIndex >= array.length) {
            startIndex = array.length - 1;//从数组的最后开始找
        }
        for (int i = startIndex; i >= 0; i--) {
            if (valueToFind == array[i]) {
                return i;
            }
        }
        return INDEX_NOT_FOUND;

10.ArrayUtils.remove
格式
       T[] remove(T[] array, int index)
       boolean[] remove(boolean[] array, int index)
       byte[] remove(byte[] array, int index)
       char[] remove(char[] array, int index)
       double[] remove(double[] array, int index)
       float[] remove(float[] array, int index)
       int[] remove(int[] array, int index)
       long[] remove(long[] array, int index)
       short[] remove(short[] array, int index)
功能
      移除指定位置的元素
代码精解
      //先将数组转换为Object类型
      return (T[]) remove((Object) array, index);
      return (char[]) remove((Object) array, index);

      Object remove(Object array, int index)
      int length = getLength(array);//获取数组长度
      //创建一个新数组
      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;

      ArrayUtils.remove(["a"], 0)           的结果为 []
      ArrayUtils.remove(["a", "b"], 0)     的结果为["b"]
      ArrayUtils.remove(["a", "b"], 1)     的结果为 ["a"]
      ArrayUtils.remove(["a", "b", "c"], 1) 的结果为 ["a", "c"]

11. 移除数组中的指定元素
格式
       T[] removeElement(T[] array, Object element)
       boolean[] removeElement(boolean[] array, boolean element)
       byte[] removeElement(byte[] array, byte element)
       char[] removeElement(char[] array, char element)
       double[] removeElement(double[] array, double element)
       float[] removeElement(float[] array, float element)
       int[] removeElement(int[] array, int element)
       long[] removeElement(long[] array, long element)
       short[] removeElement(short[] array, short element)
功能
       首先找到元素在数组中的第一个位置,在将这个元素移除,返回一个新数组
代码精解
       int index = indexOf(array, element);
       if (index == INDEX_NOT_FOUND) {
            return clone(array);
       }
       return remove(array, index);

       ArrayUtils.removeElement(null, "a")          的结果为 null
       ArrayUtils.removeElement([], "a")             的结果为 []
       ArrayUtils.removeElement(["a"], "b")         的结果为 ["a"]
       ArrayUtils.removeElement(["a", "b"], "a")   的结果为 ["b"]
       ArrayUtils.removeElement(["a", "b", "a"], "a") 的结果为 ["b", "a"]

12.ArrayUtils.reverse
格式
       void reverse(Object[] array)
       void reverse(long[] array)
       void reverse(int[] array)
       void reverse(short[] array)
       void reverse(char[] array)
       void reverse(byte[] array)
       void reverse(double[] array)
       void reverse(float[] array)
       void reverse(boolean[] array)
功能
       颠倒数组,注意操作是在原数组上进行的
代码精解
        int i = 0;
        int j = array.length - 1;
        Object tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }

13.ArrayUtils.subarray
13.1基本数组类型
格式
       long[] subarray(long[] array, int startIndexInclusive, int endIndexExclusive)
       int[] subarray(int[] array, int startIndexInclusive, int endIndexExclusive)
       short[] subarray(short[] array, int startIndexInclusive, int endIndexExclusive)
       char[] subarray(char[] array, int startIndexInclusive, int endIndexExclusive)
       byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive)
       double[] subarray(double[] array, int startIndexInclusive, int endIndexExclusive)
       float[] subarray(float[] array, int startIndexInclusive, int endIndexExclusive)
       boolean[] subarray(boolean[] array, int startIndexInclusive, int endIndexExclusive)
功能
       根据起始位置和终止位置获取一个子数组,原数组不变,返回null,array[0],array[n]
关键代码
        int newSize = endIndexExclusive - startIndexInclusive; //获取新数组长度
        if (newSize <= 0) {
            return EMPTY_INT_ARRAY;
        }
        int[] subarray = new int[newSize];
        System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); //复制数组
        return subarray;

13.2 对象数据类型
格式
       T[] subarray(T[] array, int startIndexInclusive, int endIndexExclusive)
功能
       根据起始位置和终止位置获取一个子数组,原数组不变,返回null,T[0],T[n]
关键代码
        int newSize = endIndexExclusive - startIndexInclusive;
        Class type = array.getClass().getComponentType();
        if (newSize <= 0) {
            @SuppressWarnings("unchecked") // OK, because array is of type T
            final T[] emptyArray = (T[]) Array.newInstance(type, 0);//创建一个长度为0的对象数组
            return emptyArray;
        }
        @SuppressWarnings("unchecked") // OK, because array is of type T
        T[] subarray = (T[]) Array.newInstance(type, newSize);
        System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
        return subarray;

14.ArrayUtils.toMap
格式
       Map toMap(Object[] array)
功能
       将一个2维数组转换成Map,array至少是个二维数组
关键代码
       //创新一个HashMap,长度为array.length的1.5倍??
       final Map map = new HashMap((int) (array.length * 1.5));

       Object object = array[i];//获取一个数据,是一个长度为2的一维数组
       if (object instanceof Map.Entry) { //如果可以转换为Entry
              Map.Entry entry = (Map.Entry) object; //强制将一维数组转换为Map.Entry对象
              map.put(entry.getKey(), entry.getValue());
       }
例子:
       Map map = ArrayUtils.toMap(new String[][] {{"foo", "bar"}, {"hello", "world"}});
        map.get("foo")的值为bar

15.ArrayUtils.toString
格式
       String toString(Object array)
       String toString(Object array, String stringIfNull)
功能
       将数组转换成字符串
关键代码
        if (array == null) {
            return stringIfNull;
        }
        return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();

        assertEquals("{}", ArrayUtils.toString(null));
        assertEquals("{}", ArrayUtils.toString(new Object[0]));
        assertEquals("{}", ArrayUtils.toString(new String[0]));
        assertEquals("{pink,blue}", ArrayUtils.toString(new String[] {"pink","blue"}));

16.ArrayUtils.ToArray
格式
        T[] toArray(final T... items)
功能
        将多个参数转换成数组,参数的类型必须一致
关键代码
        return items; //直接返回items,items就是数组

        String[] array = ArrayUtils.toArray("foo", "bar");





阅读(2526) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~