java提高篇(十八)-----數組之一：認識JAVA數組

一、什麽是數組

數組？什麽是數組？在我印象中的數組是應該這樣的：通過new關鍵字創建並組裝他們，通過使用整形索引值訪問它的元素，並且它的尺寸是不可變的！

但是這只是數組的最表面的東西！深一點？就是這樣：數組是一個簡單的復合數據類型，它是一系列有序數據的集合，它當中的每一個數據都具有相同的數據類型，我們通過數組名加上一個不會越界下標值來唯一確定數組中的元素。

還有更深的，那就是數組是一個特殊的對象！！（對於這個LZ理解的不是很好，對JVM也沒有看，所以見解有限）。以下參考文獻：http://developer.51cto.com/art/201001/176671.htm、http://www.blogjava.net/flysky19/articles/92763.html?opt=admin

不管在其他語言中數組是什麽，在java中它就是對象。一個比較特殊的對象。

public class Test {
    public static void main(String[] args) {
        int[] array = new int[10];
        System.out.println("array的父類是：" + array.getClass().getSuperclass());
        System.out.println("array的類名是：" + array.getClass().getName());
    }
}
 
-------Output:
array的父類是：class java.lang.Object
array的類名是：[I

從上面示例可以看出,數組的是Object的直接子類,它屬於“第一類對象”，但是它又與普通的java對象存在很大的不同，從它的類名就可以看出：[I，這是什麽東東？？在JDK中我就沒有找到這個類，話說這個"[I”都不是一個合法標識符。怎麽定義成類啊？所以我認為SUM那幫天才肯定對數組的底層肯定做了特殊的處理。

我們再看如下示例：

public class Test {
    public static void main(String[] args) {
        
 
int[] array_00 = new int[10];
        System.out.println("一維數組：" + array_00.getClass().getName());
        int[][] array_01 = new int[10][10];
        System.out.println("二維數組：" + array_01.getClass().getName());
        
        int[][][] array_02 = new int[10][10][10];
        System.out.println("三維數組：" + array_02.getClass().getName());
    }
}
-----------------Output:
一維數組：[I
二維數組：[[I
三維數組：[[[I

通過這個實例我們知道：[代表了數組的維度，一個[表示一維，兩個[表示二維。可以簡單的說數組的類名由若幹個‘[‘和數組元素類型的內部名稱組成。不清楚我們再看：

public class Test {
    public static void main(String[] args) {
        System.out.println("Object[]:" + Object[].class);
        System.out.println("Object[][]:" + Object[][].class);
        System.err.println("Object[][][]:" + Object[][][].class);
        System.out.println("Object:" + Object.class);
    }
}
---------Output:
Object[]:class [Ljava.lang.Object;
Object[][]:class [[Ljava.lang.Object;
Object[][][]:class [[[Ljava.lang.Object;
Object:class java.lang.Object

從這個實例我們可以看出數組的“廬山真面目”。同時也可以看出數組和普通的Java類是不同的，普通的java類是以全限定路徑名+類名來作為自己的唯一標示的，而數組則是以若幹個[+L+數組元素類全限定路徑+類來最為唯一標示的。這個不同也許在某種程度上說明了數組也普通java類在實現上存在很大的區別，也許可以利用這個區別來使得JVM在處理數組和普通java類時作出區分。

我們暫且不論這個[I是什麽東東，是由誰來聲明的，怎麽聲明的（這些我現在也不知道！但是有一點可以確認：這個是在運行時確定的）。先看如下：

public class Test {
    public static void main(String[] args) {
        int[] array = new int[10];
        Class clazz = array.getClass();   
        System.out.println(clazz.getDeclaredFields().length);   
        System.out.println(clazz.getDeclaredMethods().length);   
        System.out.println(clazz.getDeclaredConstructors().length);   
        System.out.println(clazz.getDeclaredAnnotations().length);   
        System.out.println(clazz.getDeclaredClasses().length);   
    }
}
----------------Output：
0
0
0
0
0

從這個運行結果可以看出，我們親愛的[I沒有生命任何成員變量、成員方法、構造函數、Annotation甚至連length成員變量這個都沒有，它就是一個徹徹底底的空類。沒有聲明length，那麽我們array.length時，編譯器怎麽不會報錯呢？確實，數組的length是一個非常特殊的成員變量。我們知道數組的是Object的直接之類，但是Object是沒有length這個成員變量的，那麽length應該是數組的成員變量，但是從上面的示例中，我們發現數組根本就沒有任何成員變量，這兩者不是相互矛盾麽？

打開class文件，得到main方法的字節碼：

    0 iconst_2                   //將int型常量2壓入操作數棧  
    1 newarray 10 (int)          //將2彈出操作數棧，作為長度，創建一個元素類型為int, 維度為1的數組，並將數組的引用壓入操作數棧  
    3 astore_1                   //將數組的引用從操作數棧中彈出，保存在索引為1的局部變量(即a)中  
    4 aload_1                    //將索引為1的局部變量(即a)壓入操作數棧  
    5 arraylength                //從操作數棧彈出數組引用(即a)，並獲取其長度(JVM負責實現如何獲取)，並將長度壓入操作數棧  
    6 istore_2                   //將數組長度從操作數棧彈出，保存在索引為2的局部變量(即i)中  
    7 return                     //main方法返回

在這個字節碼中我們還是沒有看到length這個成員變量，但是看到了這個:arraylength ,這條指令是用來獲取數組的長度的，所以說JVM對數組的長度做了特殊的處理，它是通過arraylength這條指令來實現的。

二、數組的使用方法

通過上面算是對數組是什麽有了一個初步的認識，下面將簡單介紹數組的使用方法。

數組的使用方法無非就是四個步驟：聲明數組、分配空間、賦值、處理。

聲明數組：就是告訴計算機數組的類型是什麽。有兩種形式：int[] array、int array[]。

分配空間：告訴計算機需要給該數組分配多少連續的空間，記住是連續的。array = new int[10];

賦值：賦值就是在已經分配的空間裏面放入數據。array[0] = 1 、array[1] = 2……其實分配空間和賦值是一起進行的，也就是完成數組的初始化。有如下三種形式：

int a[] = new int[2];    //默認為0,如果是引用數據類型就為null
        int b[] = new int[] {1,2,3,4,5};    
        int c[] = {1,2,3,4,5};

三、性能？請優先考慮數組

在java中有很多方式來存儲一系列數據，而且在操作上面比數組方便的多？但為什麽我們還需要使用數組，而不是替代它呢？數組與其他種類的容器之間的區別有三個方面：效率、類型和保存基本類型的能力。在java中，數組是一種效率最高的存儲和隨機訪問對象引用序列的方式。

在項目設計中數組使用的越來越少了，而且它確實是沒有List、Set這些集合使用方便，但是在某些方面數組還是存在一些優勢的，例如：速度，而且集合類的底層也都是通過數組來實現的。

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

下面利用數組和list來做一些操作比較。

一、求和

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基本類型，在這裏就產生了不必要的性能消耗。

所以在性能要求較高的場景中請優先考慮數組。

四、變長數組？

數組是定長的，一旦初始化聲明後是不可改變長度的。這對我們在實際開發中是非常不方便的，聰明的我們肯定是可以找到方法來實現的。就如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 );
    }
}

通過這種迂回的方式我們可以實現數組的擴容。因此在項目中如果確實需要變長的數據集，數組也是在考慮範圍之內的，我們不能因為他是固定長度而排斥他！

五、數組復制問題

以前在做集合拷貝的時候由於集合沒有拷貝的方法，所以一個一個的復制是非常麻煩的，所以我就幹脆使用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()方法也是，所以我們在使用拷貝方法的同時一定要註意淺拷貝這問題。

六、數組轉換為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中，它主要提供了如下幾個方法：

1、size：元素數量

2、toArray：轉換為數組，實現了數組的淺拷貝。

3、get：獲得指定元素。

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

所以綜上所述，asList返回的是一個長度不可變的列表。數組是多長，轉換成的列表是多長，我們是無法通過add、remove來增加或者減少其長度的。

Java - 數組解析