Java陣列（一）

什麼是陣列

1. 陣列是最簡單的資料結構

2. 陣列是相同型別資料的有序集合

3. 陣列描述的是相同型別的若干個資料，按照一定的先後次序排列組合而成

4. 其中，每一個數據稱作一個陣列元素，每個陣列元素可以通過一個下標（索引）來訪問它們

5. 陣列的下標（索引）是從0開始的

   例如int型別陣列a：

   int a[]={2,4,5,7}//定義了4個空間，空間裡放了4個數據

   則陣列a中存入了4個值：

   第一個值a[0]=2;//下標為0，元素為2

   第二個值a[1]=4;//下標為1，元素為4

   第三個值a[2]=5;

   第四個值a[3]=7;

6. 陣列是定義了一個一定空間的

陣列的特點

1. 陣列長度是固定的，陣列一旦被確定，它的大小就不可改變
2. 其元素必須是相同型別，不允許出現混合型別
3. 陣列中的元素可以是任何資料型別，包括基本型別和引用型別
4. 陣列變數屬於引用型別，陣列也可以看成是物件，陣列中每個元素相當於該物件的成員變數
5. 陣列本身就是物件，Java中物件是在堆中的，因此陣列無論儲存原始型別還是其他物件型別，陣列物件本身是在堆中的

陣列的宣告和建立

陣列宣告的兩種方式 ：

注：//dataType代表資料型別，arrayRefVar代表變數名

• dataType[] arrayRefVar；//首選方法（推薦方法）

  public class ArrayDemo01 {
      public static void main(String[] args) {
          int[] a;//宣告陣列a
      }
  }
   
  

• dataType arrayRefVar[]；//效果相同，但不是首選方法，這是當初為了讓C和C++程式設計師適應才加入的

  public class ArrayDemo01 {
      public static void main(String[] args) {
          int b[];//宣告陣列b
      }
  }
  

陣列的建立：

注：//arraySize代表了在陣列中建立的空間個數

dataType[] arrayRefVar = new dataType[arraySize];

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] a;//定義陣列a
        a = new int[5];//在陣列a中建立5個空間（能放5個元素）
        int b[];//定義陣列b
        b=new int[10];//在陣列b中建立10個空間（能放10個元素）
    }
}
 

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] a = new int[5];//定義陣列a並在陣列a中建立5個空間（能放5個元素）
        int b[] = new int[10];//定義陣列b並在陣列b中建立10個空間（能放10個元素）
    }
}

1. 獲取陣列的長度：

   array.length //array代表陣列名

   public class ArrayDemo01 {
       public static void main(String[] args) {
           int[] a;//定義
           a = new int[5];//建立空間
           //為陣列a賦值（陣列下標從0開始）
           a[0] = 1;
           a[1] = 3;
           a[2] = 2;
           a[3] = 6;
           a[4] = 7;
           //取值
           //輸出第四個（下標為3）的值
           System.out.println(a[3]);
           //輸出陣列a的長度
           System.out.println("陣列a的長度為："+a.length);
           //輸出全部的值
           System.out.println("輸出全部值：");
           for (int i=0;i<a.length;i++){
               System.out.println("a["+i+"]="+a[i]);
           }
       }
   }
   //輸出：
   第四個值a[3]=6
   陣列a的長度為：5
   輸出全部值：
   a[0]=1
   a[1]=3
   a[2]=2
   a[3]=6
   a[4]=7
   

Java記憶體分析

堆

1. 存放new的物件和陣列
2. 可以被所有的執行緒共享，不會存放別的物件引用

棧

1. 存放基本變數型別（會包含這個基本型別的具體數值）
2. 引用物件的變數（會存放這個引用在堆裡面的具體地址）

方法區

1. 可以被所有的執行緒共享
2. 包含了所有的class和static變數

堆、棧、方法區舉例

//宣告陣列
int[] array = null;//將array放入棧中
//建立陣列
array = new int[10];//由棧中的array在堆裡面開闢了空間，空間分成10個小塊（只能放int型別，且只能放10個元素）
//給陣列中元素賦值
array[0]=1//在空間中放入元素值

陣列的三種初始化狀態

靜態初始化

//方式一
int[] a = {1,2,3};
//方式二
Man[] mans = {new Man(1,1),new Man(2,2)};//Man是引用型別

動態初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

int[] a;
a = new int[2];
a[0] = 1;
a[1] = 2;

預設初始化

1. 動態初始化包含預設初始化

2. 陣列是引用型別，它的元素相當於類的例項變數，因此陣列一經分配空間，其中的每個元素也被按照例項變數同樣的方式被隱式初始化

3. 舉例：

   int[] a;
   a = new int[2];
   //沒有賦值時，由於a是int[]型別的陣列，裡面的元素均是int型別，且例項變數中int的預設值為0，所以陣列a中沒有被賦值的空間均預設是0
   

陣列越界

1. 建立一個數組a[x]，陣列長度是x，則陣列的合法區間為[0,x-1]

   舉例：定義了a[10],則只能在陣列a中放入10個元素，且只能在下標0和9之間存放（包括a[0]和a[9]），越界就會報錯（ArrayIndexOutOfBoundsException）

2. 舉例：

   public class ArrayDemo02 {
       public static void main(String[] args) {
           int[] a = new int[10];//下標0到9的10個空間
           a[10] = 9;//只能在0到9下標儲存，a[10]越界了
           a[11] = 1;//只能在0到9下標儲存，a[11]越界了
       }
   }
   //輸出：
       報錯ArrayIndexOutOfBoundsException
   

   public class ArrayDemo02 {
       public static void main(String[] args) {
           int[] a = new int[10];//下標0到9的10個空間
           a[8] = 9;//只能在0到9下標儲存，a[8]沒越界
           System.out.println(a[8]);
       }
   }
   //輸出：
       9
   

陣列的使用

普通For迴圈使用

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
        System.out.println("================");
    }
}
//輸出：
1
2
3
4
5
================

For-Each迴圈

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        //在For-Each迴圈中，i自動遍歷array陣列中的每一個元素
        for (int i : array) {
            System.out.println(i);
        }
    }
}
//輸出：
1
2
3
4
5

陣列作方法入參

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[] x = {1,2,3,4};
        s1(x);
    }
    //方法，將陣列傳入
    public static void s1(int[] a){
        for (int i : a) {
            System.out.println(i);
        }
    }
}
//輸出：
1
2
3
4

陣列作返回值

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] x;//定義int[]型別的陣列
        //s2方法裡返回陣列型別和接收（被賦值）的陣列型別要一致
        x=s2(2,5,6);//通過s2方法將int[]型別的陣列返回給int[]型別的陣列x
        //通過For-Each輸出陣列中的元素
        for (int i : x) {
            System.out.println(i);
        }
    }
    //寫出一個返回型別為int陣列的方法
    public static int[] s2(int a,int b,int c){
        int[] array;
        array = new int[3];
        array[0]=a;
        array[1]=b;
        array[2]=c;
        return array;//返回陣列array
    }
}
//輸出：
2
5
6

多維陣列

• 多維陣列就是陣列的陣列，比如二維陣列就是特殊的一維陣列

二維陣列

二維陣列定義

//a[x][y]陣列，相當於先建立了一個a[x]一維陣列，a[x]陣列中的每個元素又建立了一個數組，類似於a[0][y],a[1][y].....

int[][] array;
array = new int[4][3];//建立了一個二維陣列相當於先建立了一個array[4]陣列，而其中每個元素佔5個空間（每個元素又是一個一維陣列）

若將一維陣列看作是一個一維列表，則二維陣列可以看成是一個二維列表

舉例：

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
    }
}
//輸出：
1 2 3 4 5

存入array中的5個數據可以看作：

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[][] a;
        a = new int[2][3];
        a[0][0]=1;
        a[0][1]=2;
        a[0][2]=5;
        a[1][0]=3;
        a[1][1]=4;
        a[1][2]=2;
        //相當於a[0]={1,2,5},a[1]={3,4,2}
        for (int[] ints : a) {
            //相當於ints[0]={1,2,5}(第一次遍歷),ints[1]={3,4,2}（第二次遍歷）
            for(int i=0;i<ints.length;i++){
                System.out.print(ints[i]+" ");
            }
            System.out.println("");
        }
    }
}
//輸出：
1 2 5 
3 4 2 

存入a中的6個數據可以看作：

相當於：

• a[0]={1,2,5}
• a[1]={3,4,2}