1．關於陣列的特點

1）在Java中，無論使用陣列或集合，都有邊界檢查。如果越界操作就會得到一個RuntimeException異常。

2）陣列只能儲存特定型別。陣列可以儲存原生資料型別，集合則不能。集合不以具體的型別來處理物件，它們將所有物件都按Object型別處理，集合中存放的是物件的引用而不是物件本身。

3）集合類只能儲存物件的引用。而陣列既可以建立為直接儲存原生資料型別，也可以儲存物件的引用。在集合中可以使用包裝類（Wrapper Class），如Integer、Double等來實現儲存原生資料型別值。

例碼：int a = 10;

         Integer integer = new Integer(a);

         int b = integer.intValue();

         System.out.println(a = b);

4）物件陣列和原生資料型別陣列在使用上幾乎是相同的；唯一的區別是物件陣列儲存的是引用，原生資料型別陣列儲存原生資料型別的值。

2．關於陣列定義

     1）一維陣列的宣告方式：  type var[];      或type[] var;

         宣告陣列時不能指定其長度（陣列中元素的個數），

         Java中使用關鍵字new建立陣列物件，格式為：   陣列名 = new 陣列元素的型別 [陣列元素的個數]

         例碼：int num[];

            num=new int[3];

             或  int num[]=new int[3];

2）可以這樣定義二維陣列。

     例碼：

            int [][] num;

            num=new int[3][];

            num[0]=new int[5];

            num[1]=new int[3];

            num[2]=new int[2];

          //定義了一個二維陣列num,這個陣列有三行，第一行5個元素，第二行3個元素，第三行2個元素。

3）關於陣列初始化

*動態初始化：陣列定義與為陣列分配空間和賦值的操作分開進行；
      

1. publicclass TestD  {   
2.    publicstaticvoid main(String args[]) {        
3.        int a[] ;        
4.        a = newint[3] ;     
5.        a[0] = 0 ;  
6.        a[1] = 1 ;  
7.        a[2] = 2 ;   
8.        Date days[] ;  
9.        days = new Date[3] ;   
10.        days[0] = new Date(2008,4,5) ;       
11.        days[1] = new Date(2008,2,31) ;   
12.        days[2] = new Date(2008,4,4) ;  
13.     }   
14. }     
15. class Date  {        
16.  int year,month,day ;     
17.     Date(int year ,int month ,int day) {  
18.            this.year = year ;  
19.            this.month = month ;  
20.            this.day = day ;  
21.        }  
22.   }    

*靜態初始化：在定義數字的同時就為陣列元素分配空間並賦值；

1. publicclass TestS {  
2.        publicstaticvoid main(String args[]) {     
3.              int a[] = {0,1,2} ;  
4.              Time times [] = {new Time(19,42,42),new Time(1,23,54),new Time(5,3,2)} ;  
5.      }  
6. }  
7. class Time｛  
8.           int hour,min,sec ;  
9.           Time(int hour ,int min ,int sec) {  
10.               this.hour = hour ;  
11.               this.min = min ;  
12.               this.sec = sec ;  
13.           }  
14.      }      

      *預設初始化：陣列是引用型別，它的元素相當於類的成員變數，因此陣列分配空間後，每個元素也被按照成員變數的規則被隱士初始化。

1. publicclass TestDefault {  
2.          publicstaticvoid main(String args[]）  
3. {  
4.             int a [] = newint [5];  
5.             System.out.println("" + a[3]);  
6.      }  
7. }     

3.關於陣列的相關操作

1）在Java中，所有的陣列都有一個預設的屬性length，用於獲取陣列中元素的個數。

2）陣列的複製：System.arraycopy()。

3）陣列的排序：Arrays.sort()。

4）在已排序的陣列中查詢某個元素：Arrays.binarySearch()。

4.陣列使用示例：

1） 迴圈初始化陣列元素
             要求：初始化一個長度為100的int陣列，陣列中的元素依次為1-100。
             這是一個基本的使用，主要是熟悉陣列的語法，在實際編寫時，需要發現數組下標和陣列元素值之間的規律即可。
             第一種思路：迴圈陣列的下標0-99，則和下標對應的元素的值比陣列下標多1。
             則實現程式碼如下：
                       int[] m = new int[100];
                       for(int i = 0;i < m.length;i++){
                                m[i] = i + 1;
                       }
             程式碼說明：宣告並初始化一個長度是100的陣列，使用迴圈迴圈陣列的下標，下標的區間是[0,m.length-1]，其中m.length表示陣列的長度。在實際賦值時，把陣列的下標做成變數，則當i的值為0時，則m[i]就是m[0]，依次類推，按照題目的要求，則數值的規律是i+1，這樣迴圈結束以後，陣列m中的值就依次是1-100了。
             第二種思路：迴圈陣列的值1-100，則下標比陣列的值下1。
             則實現的程式碼如下：
                       int[] m = new int[100];
                       for(int i = 1;i <= 100;i++){
                                m[i – 1] = i;
                       }
             該程式碼中迴圈變數i的值從1迴圈到100，則陣列的下標是i – 1，這樣也可以實現題目要求的功能。
    2）輸出數列
             要求：輸出1 1 2 3 5 8 13……這樣的數列，輸出該數列的前20個數字。
             該題是一個基本的數字邏輯，在實際解決該問題時，首先要發現該數字的規律，然後按照該規律來設計陣列即可。
             實現思路：數字的規律是除了數列裡的前兩個數字以外，其它的數字都滿足該數字等於前兩個數字的和，由於題目要求輸出前20個數字，所以需要一個長度為20的陣列，第一個和第二個數字直接賦值，後續的數字通過前兩個數字元素得到。
             則實現的程式碼如下：
                       int[] num = new int[20];
                       num[0] = 1;
                       num[1] = 1;
                       //迴圈初始化
    for(int i = 2;i < num.length;i++){
                                num[i] = num[i – 1] + num[i – 2];
                       }
                       //迴圈輸出
    for(int i = 0;i < num.length;i++){
                                System.out.print(num[i]);
                                System.out.print(‘ ‘);
                       }
                       System.out.println(); //換行

在該程式碼中，初始化一個長度為20的陣列，首先將陣列中的前兩個元素賦值成1，然後迴圈對後續的元素的賦值，如果當前元素的下標是i，則它前一個元素的下標是i-1，再前面一個元素的下標是i-2，只需要將這2個元素的值相加，然後賦值給當前元素即可。後面使用一個迴圈，輸出陣列中所有的元素，元素和元素之間有一個間隔的空格，在輸出所有的元素以後換行。