java提升篇（十九）-----数组之二

      前面一节主要介绍了数组的基本概念，对什么是数组稍微深刻了一点点，在这篇博文中主要介绍数组的其余方面。

3、性能？请优先考虑数组

      在java中有不少方式来存储一系列数据，并且在操做上面比数组方便的多？但为何咱们还须要使用数组，而不是替代它呢？数组与其余种类的容器之间的区别有三个方面：效率、类型和保存基本类型的能力。在java中，数组是一种效率最高的存储和随机访问对象引用序列的方式。

      在项目设计中数组使用的愈来愈少了，并且它确实是没有List、Set这些集合使用方便，可是在某些方面数组仍是存在一些优点的，例如：速度，并且集合类的底层也都是经过数组来实现的。

--------这是ArrayList的add()------
    public boolean add(E e) {
    ensureCapacity(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
    }

      下面利用数组和list来作一些操做比较。

      1、求和

Long time1 = System.currentTimeMillis();
        for(int i = 0 ; i < 100000000 ;i++){
            sum += arrays[i%10];
        }
        Long time2 = System.currentTimeMillis();
        System.out.println("数组求和所花费时间：" + (time2 - time1) + "毫秒");
        Long time3 = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            sum  += list.get(i%10);
        }
        Long time4 = System.currentTimeMillis();
        System.out.println("List求和所花费时间：" + (time4 - time3) + "毫秒");
--------------Output:
数组求和所花费时间：696毫秒
List求和所花费时间：3498毫秒

      从上面的时间消耗上面来讲数组对于基本类型的求和计算的速度是集合的5倍左右。其实在list集合中，求和当中有一个致命的动做：list.get(i)。这个动做是进行拆箱动做，Integer对象经过intValue方法自动转换成一个int基本类型，在这里就产生了没必要要的性能消耗。

     因此在性能要求较高的场景中请优先考虑数组。

4、变长数组？

      数组是定长的，一旦初始化声明后是不可改变长度的。这对咱们在实际开发中是很是不方便的，聪明的咱们确定是能够找到方法来实现的。就如java不能实现多重继承同样，咱们同样能够利用内部类和接口来实现(请参考：java提升篇(九)-----实现多重继承)。

      那么如何来实现变长数组呢？咱们能够利用List集合add方法里面的扩容思路来模拟实现。下面是ArrayList的扩容方法:

public void ensureCapacity(int minCapacity) {
        modCount++;  
        int oldCapacity = elementData.length;
        /**
         * 若当前须要的长度超过数组长度时进行扩容处理
         */
        if (minCapacity > oldCapacity) {
            Object oldData[] = elementData;    
            int newCapacity = (oldCapacity * 3) / 2 + 1;    //扩容
            if (newCapacity < minCapacity)
                newCapacity = minCapacity;
            //拷贝数组，生成新的数组
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    }

      这段代码对咱们有用的地方就在于if语句后面。它的思路是将原始数组拷贝到新数组中，新数组是原始数组长度的1.5倍。因此模拟的数组扩容代码以下：

public class ArrayUtils {
    /**
     * @desc 对数组进行扩容
     * @author chenssy
     * @data 2013-12-8
     * @param <T>
     * @param datas 原始数组
     * @param newLen 扩容大小
     * @return T[]
     */
    public static <T> T[] expandCapacity(T[] datas,int newLen){
        newLen = newLen < 0 ? datas.length :datas.length + newLen;   
        //生成一个新的数组
        return Arrays.copyOf(datas, newLen);
    }
    
    /**
     * @desc 对数组进行扩容处理，1.5倍
     * @author chenssy
     * @data 2013-12-8
     * @param <T>
     * @param datas  原始数组
     * @return T[]
     */
    public static <T> T[] expandCapacity(T[] datas){
        int newLen = (datas.length * 3) / 2;      //扩容原始数组的1.5倍
        //生成一个新的数组
        return Arrays.copyOf(datas, newLen);
    }
    
    /**
     * @desc 对数组进行扩容处理，
     * @author chenssy
     * @data 2013-12-8
     * @param <T>
     * @param datas 原始数组
     * @param mulitiple 扩容的倍数
     * @return T[]
     */
    public static <T> T[] expandCapacityMul(T[] datas,int mulitiple){
        mulitiple = mulitiple < 0 ? 1 : mulitiple;
        int newLen = datas.length * mulitiple;
        return Arrays.copyOf(datas,newLen );
    }
}

      经过这种迂回的方式咱们能够实现数组的扩容。所以在项目中若是确实须要变长的数据集，数组也是在考虑范围以内的，咱们不能由于他是固定长度而排斥他！

5、数组复制问题

      之前在作集合拷贝的时候因为集合没有拷贝的方法，因此一个一个的复制是很是麻烦的，因此我就干脆使用List.toArray()方法转换成数组而后再经过Arrays.copyOf拷贝，在转换成集合，我的以为很是方便，却不知我已经陷入了其中的陷进！咱们知道若数组元素为对象，则数组里面数据是对象引用

public class Test {
    public static void main(String[] args) {
        Person person_01 = new Person("chenssy_01");
        
        Person[] persons1 = new Person[]{person_01};
        Person[] persons2 = Arrays.copyOf(persons1,persons1.length);
        
        System.out.println("数组persons1:");
        display(persons1);
        System.out.println("---------------------");
        System.out.println("数组persons2:");
        display(persons2);
        //改变其值
        persons2[0].setName("chessy_02");
        System.out.println("------------改变其值后------------");
        System.out.println("数组persons1:");
        display(persons1);
        System.out.println("---------------------");
        System.out.println("数组persons2:");
        display(persons2);
    }
    public static void display(Person[] persons){
        for(Person person : persons){
            System.out.println(person.toString());
        }
    }
}
-------------Output:
数组persons1:
姓名是：chenssy_01
---------------------
数组persons2:
姓名是：chenssy_01
------------改变其值后------------
数组persons1:
姓名是：chessy_02
---------------------
数组persons2:
姓名是：chessy_02

     从结果中发现,persons1中的值也发生了改变，这是典型的浅拷贝问题。因此经过Arrays.copyOf()方法产生的数组是一个浅拷贝。同时数组的clone()方法也是，集合的clone()方法也是，因此咱们在使用拷贝方法的同时必定要注意浅拷贝这问题。

      有关于深浅拷贝的博文，参考：

      渐析java的浅拷贝和深拷贝：http://www.cnblogs.com/chenssy/p/3308489.html。

      使用序列化实现对象的拷贝：http://www.cnblogs.com/chenssy/p/3382979.html。

6、数组转换为List注意地方

       咱们常常须要使用到Arrays这个工具的asList()方法将其转换成列表。方即是方便，可是有时候会出现莫名其妙的问题。以下：

public static void main(String[] args) {
        int[] datas = new int[]{1,2,3,4,5};
        List list = Arrays.asList(datas);
        System.out.println(list.size());
    }
------------Output:
1

      结果是1,是的你没有看错, 结果就是1。可是为何会是1而不是5呢？先看asList()的源码

public static <T> List<T> asList(T... a) {
        return new ArrayList<T>(a);
    }

      注意这个参数:T…a，这个参数是一个泛型的变长参数，咱们知道基本数据类型是不可能泛型化的，也是就说8个基本数据类型是不可做为泛型参数的，可是为何编译器没有报错呢？这是由于在java中，数组会当作一个对象来处理，它是能够泛型的，因此咱们的程序是把一个int型的数组做为了T的类型，因此在转换以后List中就只会存在一个类型为int数组的元素了。因此咱们这样的程序System.out.println(datas.equals(list.get(0)));输出结果确定是true。固然若是将int改成Integer，则长度就会变成5了。

      咱们在看下面程序：

enum Week{Sum,Mon,Tue,Web,Thu,Fri,Sat}
    public static void main(String[] args) {
        Week[] weeks = {Week.Sum,Week.Mon,Week.Tue,Week.Web,Week.Thu,Week.Fri};
        List<Week> list = Arrays.asList(weeks);
        list.add(Week.Sat);
    }

      这个程序很是简单，就是讲一个数组转换成list，而后改变集合中值，可是运行呢？

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractList.add(AbstractList.java:131)
    at java.util.AbstractList.add(AbstractList.java:91)
    at com.array.Test.main(Test.java:18)

     编译没错，可是运行居然出现了异常错误！UnsupportedOperationException ，当不支持请求的操做时，就会抛出该异常。从某种程度上来讲就是不支持add方法，咱们知道这是不可能的！什么缘由引发这个异常呢？先看asList()的源代码：

public static <T> List<T> asList(T... a) {
        return new ArrayList<T>(a);
    }

      这里是直接返回一个ArrayList对象返回，可是注意这个ArrayList并非java.util.ArrayList,而是Arrays工具类的一个内之类：

private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, java.io.Serializable{
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;
        ArrayList(E[] array) {
            if (array==null)
                throw new NullPointerException();
        a = array;
    }
       /** 省略方法 **/
    }

      可是这个内部类并无提供add()方法，那么查看父类：

public boolean add(E e) {
    add(size(), e);
    return true;
    }
    public void add(int index, E element) {
    throw new UnsupportedOperationException();
    }

         这里父类仅仅只是提供了方法，方法的具体实现却没有，因此具体的实现须要子类本身来提供，可是很是遗憾

这个内部类ArrayList并无提升add的实现方法。在ArrayList中，它主要提供了以下几个方法：

      一、size：元素数量

      二、toArray：转换为数组，实现了数组的浅拷贝。

      三、get：得到指定元素。

      四、contains：是否包含某元素。

      因此综上所述，asList返回的是一个长度不可变的列表。数组是多长，转换成的列表是多长，咱们是没法经过add、remove来增长或者减小其长度的。

 

      参考文献：《编写高质量代码--改善Java程序的151个建议》