java基礎之 數組

什麼是數組

數組是用來存儲固定大小的同類型元素。

數組怎麼寫

格式：數據類型[] 數組變量名 = new 數據類型[數組長度];

栗子1：定義一個存放4個年齡的數組
int[] ages = new int[4];

栗子2：定義一個存放6個金額的數組
double[] prices = new double[6];

數組存值

數組變量名[數據的位置] = 值;

注意：在java中，數組的位置是從0開始的

ages[0] = 15;
ages[1] = 18;
ages[2] = 45;
ages[3] = 23;
System.out.println(Arrays.toString(ages));

//輸出
[15, 18, 45, 23]

根據上面存儲的數據，在java數組中的位置和數據對應的位置

0  1  2  3
15 18 45 23

數組的取值

數組變量名[數據的位置]

根據上面說明的位置，如果我們需要讀取45這個數據，我們應該使用 ages[2]；

System.out.println(ages[2]);
// 控制檯輸出 45

如果我們讀取了不存在的位置，程序就會報錯；

例如ages的位置只有0~3，如果我們輸入ages[4]，程序就會拋出 java.lang.ArrayIndexOutOfBoundsException 異常；

 System.out.println(ages[4]);

// 程序拋出異常
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
	at test.ArrayTest.main(ArrayTest.java:42)

數組有什麼用

我們在需要存放同類型的很多數據時，我們可以定義很多個變量，把這些值存起來。這樣會使我們定義大量的變量，使得程序變得異常複雜而且不便於我們使用這個數組。這時我們就可以使用數組，把這些數據存在數組中。

例如：我們存儲4個年齡

不用數組：

int age1 = 15;
int age2 = 18;
int age3 = 45;
int age4 = 23;

使用數組：

int[] ages = new int[4];
ages[0] = 15;
ages[1] = 18;
ages[2] = 45;
ages[3] = 23;

使用數組後，我們只要調用 ages 就可以操作這些數據，不用像第一個一樣，只能根據每一個變量的名字去操作數據。

數組的長度

如果我們得到的數組是一個變量，我們需要知道數組的長度，防止我們讀取到不存在的位置，這時我們可以使用 數組變量名.length 去獲取到數組的長度。

System.out.println(ages.length);
// 輸出 4

數據的靜態初始化

數據類型[] 數組變量名 = {變量1,變量2,...變量n};

靜態初始化的數據和普通方式設置的數據的使用方法是相同的。

栗子：我們修改ages爲靜態初始化方式

int[] ages = {15, 18, 45, 23};

數組的特點

• 數組的長度在創建時就固定了，不可進行修改。
• 數組存儲的數據類型只能是同一種類型的，不允許出現混合類型。
• 數組的類型可以是任何類型，基本類型、引用類型都可以。
• 數組的變量是引用類型，它是存放在堆中的。

數據的循環

我們可以根據數組的下標（位置）來讀取數組的元素。

如果我們需要讀取全部的元素，這時我們就可以使用for循環來讀取；

for (int i = 0; i < ages.length; i++) {
    System.out.print(ages[i] + " ");
}
System.out.println();
// 輸出：15 18 45 23

在 jdk1.5+ 可以使用增強for循環來循環數組；

for (int age : ages) {
    System.out.print(age + " ");
}
System.out.println();
// 輸出：15 18 45 23

多維數組

數組中可以存儲基礎類型的數據和引用類型的數據，而數組本身又是一個引用類型的數據，

所有我們可以把數組當做數據存到另外一個數組中，像這樣的多層的存儲數據，我們稱之爲多維數組，

數組有幾層就稱之爲幾維數組。

例如：我們定義5年齡數組，分別存放不同的年齡數據。

int[] ages1 = {10, 11, 12, 13, 14};
int[] ages2 = {20, 21, 22, 23, 24};
int[] ages3 = {30, 31, 32, 33, 34};
int[] ages4 = {40, 41, 42, 43, 44};

然後我們把這些數據放在一個名字叫 agess 的數組中。

數據的類型[] 表示的是數組，如果 數據的類型=int[]，那就變成int[][]了

int[][] agess = {ages1, ages2, ages3, ages4};
System.out.println(Arrays.deepToString(agess));
// 輸出 
[[10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]]

上面的寫法我們可以把定義變量的操作去掉，直接在使用的地方替換爲具體的值就變成下列的形式。

int[][] agess2 = {
    {10, 11, 12, 13, 14},
    {20, 21, 22, 23, 24},
    {30, 31, 32, 33, 34},
    {40, 41, 42, 43, 44}
};
System.out.println(Arrays.deepToString(agess2));
// 輸出 
[[10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]]

附錄：測試代碼

package test;

import java.util.Arrays;

/**
 * 數組測試
 *
 * @author lixin
 */
public class ArrayTest {

    public static void main(String[] args) {
        // 一、數組的定義
        // 格式：數據類型[] 數組變量名 = new 數據類型[數組長度];

        // 栗子1：定義一個存放4個年齡的數組
        int[] ages = new int[4];

        // 栗子2：定義一個存放6個金額的數組
        double[] prices = new double[6];

        // 二、數組的賦值
        // 數組變量名[數據的位置] = 值;
        // 注意：在java中，數組的位置是從0開始的
        ages[0] = 15;
        ages[1] = 18;
        ages[2] = 45;
        ages[3] = 23;
        System.out.println(Arrays.toString(ages));

        // 數組的位置和數據對應的位置
        // 0  1  2  3
        // 15 18 45 23

        // 三、數組的取值
        // 根據上面說明的位置，如果我們需要讀取45這個數據，我們應該使用 ages[2]
        // 控制檯就會輸出 45
        System.out.println(ages[2]);

        // 如果我們讀取了不存在的位置，程序就會報錯
        // 例如ages的位置只有0~3，如果我們輸入ages[4]，程序就會拋出 java.lang.ArrayIndexOutOfBoundsException 異常
        //System.out.println(ages[4]);

        // 四、數組的長度
        // 如果我們得到的數組是一個變量，我們需要知道數組的長度，防止我們讀取到不存在的位置，這時我們可以使用
        // 數組變量名.length 這個屬性去獲取到數組的長度
        // 例如下列就輸出 4
        System.out.println(ages.length);

        // 五、數組的循環
        // 我們可以根據數組的下標（位置）來讀取數組的元素，
        // 如果我們需要讀取全部的元素，這時我們就可以使用for循環來讀取
        for (int i = 0; i < ages.length; i++) {
            System.out.print(ages[i] + " ");
        }
        System.out.println();
        // 輸出：15 18 45 23

        // 在jdk1.5+ 可以使用增強for循環來循環數組
        for (int age : ages) {
            System.out.print(age + " ");
        }
        System.out.println();
        // 輸出：15 18 45 23

        // 實例1：計算數組的和
        System.out.println("數組的和=" + sum(ages));

        // 實例2：查找最大的元素
        System.out.println("查找最大的元素=" + max(ages));

        // 實例3：反轉數組
        int[] reverse = reverse(ages);
        for (int age : reverse) {
            System.out.print(age + " ");
        }
        System.out.println();
        // 輸出：23 45 18 15

        // 多維數組
        // 數組中可以存儲基礎類型的數據和引用類型的數據，而數組本身又是一個引用類型的數據，
        // 所有我們可以把數組當做數據存到另外一個數組中，像這樣的多層的存儲數據，
        // 我們稱之爲多維數組，數組有幾層就稱之爲幾維數組。
        // 例如：我們定義5年齡數組，分別存放不同的年齡數據
        int[] ages1 = {10, 11, 12, 13, 14};
        int[] ages2 = {20, 21, 22, 23, 24};
        int[] ages3 = {30, 31, 32, 33, 34};
        int[] ages4 = {40, 41, 42, 43, 44};

        // 然後我們把這些數據放在一個名字叫 agess 的數組中
        // 數據的類型[] 表示的是數組，如果 數據的類型=int[]，那就變成int[][]了
        int[][] agess = {ages1, ages2, ages3, ages4};
        System.out.println(Arrays.deepToString(agess));

        // 上面的寫法我們可以把定義變量的操作去掉，直接在使用的地方替換爲具體的值就變成下列的形式
        int[][] agess2 = {
                {10, 11, 12, 13, 14},
                {20, 21, 22, 23, 24},
                {30, 31, 32, 33, 34},
                {40, 41, 42, 43, 44}
        };
        System.out.println(Arrays.deepToString(agess2));

    }

    /**
     * 計算數組的和
     *
     * @param ages 數組
     * @return 數組的和
     */
    public static int sum(int[] ages) {
        int sum = 0;
        for (int i = 0; i < ages.length; i++) {
            sum += ages[i];
        }
        return sum;
    }

    /**
     * 查找最大的元素
     *
     * @param ages 數組
     * @return 數組中最大的元素
     */
    public static int max(int[] ages) {
        int max = ages[0];
        for (int age : ages) {
            if (age > max) {
                max = age;
            }
        }
        return max;
    }

    /**
     * 反轉數組
     *
     * @param ages 需要被反轉的數組
     * @return 反轉都的數組
     */
    public static int[] reverse(int[] ages) {
        int[] result = new int[ages.length];
        for (int i = 0; i < result.length; i++) {
            result[i] = ages[(ages.length - 1) - i];
        }
        return result;
    }
}