Java程序 基礎之（三）---數組類型

數組類型

如果我們有一組類型相同的變量，例如，5位同學的成績，可以這么寫：

public class Main {
    public static void main(String[] args) {
        // 5位同學的成績:
        int n1 = 68;
        int n2 = 79;
        int n3 = 91;
        int n4 = 85;
        int n5 = 62;
    }
}

但其實沒有必要定義5個int變量。可以使用數組來表示“一組”int類型。代碼如下：

// 數組 

public class Main {
    public static void main(String[] args) {
        // 5位同學的成績:
        int[] ns = new int[5];
        ns[0] = 68;
        ns[1] = 79;
        ns[2] = 91;
        ns[3] = 85;
        ns[4] = 62;
    }
}

定義一個數組類型的變量，使用數組類型“類型[]”，例如，int[]。和單個基本類型變量不同，數組變量初始化必須使用new int[5]表示創建一個可容納5個int元素的數組。

Java的數組有幾個特點：

• 數組所有元素初始化為默認值，整型都是0，浮點型是0.0，布爾型是false；
• 數組一旦創建后，大小就不可改變。

要訪問數組中的某一個元素，需要使用索引。數組索引從0開始，例如，5個元素的數組，索引范圍是0~4。

可以修改數組中的某一個元素，使用賦值語句，例如，ns[1] = 79;。

可以用數組變量.length獲取數組大小：

public class Main {
    public static void main(String[] args) {
        // 5位同學的成績:
        int[] ns = new int[5];
        System.out.println(ns.length); // 5
    }
}

數組是引用類型，在使用索引訪問數組元素時，如果索引超出范圍，運行時將報錯：

public class Main {
    public static void main(String[] args) {
        // 5位同學的成績:
        int[] ns = new int[5];
        int n = 5;
        System.out.println(ns[n]); // 索引n不能超出范圍
    }
}

也可以在定義數組時直接指定初始化的元素，這樣就不必寫出數組大小，而是由編譯器自動推算數組大小。例如：

 

// 數組

public class Main {
    public static void main(String[] args) {
        // 5位同學的成績:
        int[] ns = new int[] { 68, 79, 91, 85, 62 };
        System.out.println(ns.length); // 編譯器自動推算數組大小為5
    }
}

還可以進一步簡寫為：

int[] ns = { 68, 79, 91, 85, 62 };

注意數組是引用類型，並且數組大小不可變。我們觀察下面的代碼：

public class Main {
    public static void main(String[] args) {
        // 5位同學的成績:
        int[] ns;
        ns = new int[] { 68, 79, 91, 85, 62 };
        System.out.println(ns.length); // 5
        ns = new int[] { 1, 2, 3 };
        System.out.println(ns.length); // 3
    }
}

數組大小變了嗎？看上去好像是變了，但其實根本沒變。

對於數組ns來說，執行ns = new int[] { 68, 79, 91, 85, 62 };時，它指向一個5個元素的數組：

     ns
      │
      ▼
┌───┬───┬───┬───┬───┬───┬───┐
│   │68 │79 │91 │85 │62 │   │
└───┴───┴───┴───┴───┴───┴───┘

執行ns = new int[] { 1, 2, 3 };時，它指向一個新的3個元素的數組：

     ns ──────────────────────┐
                              │
                              ▼
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│   │68 │79 │91 │85 │62 │   │ 1 │ 2 │ 3 │   │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

但是，原有的5個元素的數組並沒有改變，只是無法通過變量ns引用到它們而已。

字符串數組

如果數組元素不是基本類型，而是一個引用類型，那么，修改數組元素會有哪些不同？

字符串是引用類型，因此我們先定義一個字符串數組

String[] names = {
    "ABC", "XYZ", "zoo"
};

對於String[]類型的數組變量names，它實際上包含3個元素，但每個元素都指向某個字符串對象：

          ┌─────────────────────────┐
    names │   ┌─────────────────────┼───────────┐
      │   │   │                     │           │
      ▼   │   │                     ▼           ▼
┌───┬───┬─┴─┬─┴─┬───┬───────┬───┬───────┬───┬───────┬───┐
│   │░░░│░░░│░░░│   │ "ABC" │   │ "XYZ" │   │ "zoo" │   │
└───┴─┬─┴───┴───┴───┴───────┴───┴───────┴───┴───────┴───┘
      │                 ▲
      └─────────────────┘

對names[1]進行賦值，例如names[1] = "cat";，效果如下：

          ┌─────────────────────────────────────────────────┐
    names │   ┌─────────────────────────────────┐           │
      │   │   │                                 │           │
      ▼   │   │                                 ▼           ▼
┌───┬───┬─┴─┬─┴─┬───┬───────┬───┬───────┬───┬───────┬───┬───────┬───┐
│   │░░░│░░░│░░░│   │ "ABC" │   │ "XYZ" │   │ "zoo" │   │ "cat" │   │
└───┴─┬─┴───┴───┴───┴───────┴───┴───────┴───┴───────┴───┴───────┴───┘
      │                 ▲
      └─────────────────┘

這里注意到原來names[1]指向的字符串"XYZ"並沒有改變，僅僅是將names[1]的引用從指向"XYZ"改成了指向"cat"，其結果是字符串"XYZ"再也無法通過names[1]訪問到了。

對“指向”有了更深入的理解后，試解釋如下代碼：

public class Main {
    public static void main(String[] args) {
        String[] names = {"ABC", "XYZ", "zoo"};
        String s = names[1];
        names[1] = "cat";
        System.out.println(s); // s是"XYZ"還是"cat"?
    }
}

小結

數組是同一數據類型的集合，數組一旦創建后，大小就不可變；

可以通過索引訪問數組元素，但索引超出范圍將報錯；

數組元素可以是值類型（如int）或引用類型（如String），但數組本身是引用類型