java 數組定義和循環詳解

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. public class TestD  {   
2.         
3.    public static void main(String args[]) {        
4.        int a[] ;        
5.        a = new int[3] ;     
6.        a[0] = 0 ;  
7.        a[1] = 1 ;  
8.        a[2] = 2 ;   
9.        Date days[] ;  
10.        days = new Date[3] ;   
11.        days[0] = new Date(2008,4,5) ;       
12.        days[1] = new Date(2008,2,31) ;   
13.        days[2] = new Date(2008,4,4) ;  
14.     }   
15. }     
16. class Date  {        
17.  int year,month,day ;     
18.     Date(int year ,int month ,int day) {  
19.            this.year = year ;  
20.            this.month = month ;  
21.            this.day = day ;  
22.        }  
23.   }    

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

1. public class TestS {  
2.        public static void 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.         
8. class Time｛  
9.           int hour,min,sec ;  
10.           Time(int hour ,int min ,int sec) {  
11.               this.hour = hour ;  
12.               this.min = min ;  
13.               this.sec = sec ;  
14.           }  
15.      }      

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

1. public class TestDefault {  
2.          public static void main(String args[]）  
3. {  
4.             int a [] = new int [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個元素的值相加，然後賦值給當前元素即可。後面使用一個循環，輸出數組中所有的元素，元素和元素之間有一個間隔的空格，在輸出所有的元素以後換行。