Java中的數組常見操作

數組越界異常

public static void main(String[] args) {
        int[] array = {15, 25, 35};
        System.out.println(array[0]); //15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 35

        // 錯誤寫法
        // 并不存在3号元素，是以發生異常
        System.out.println(array[3]);
    }
           

建立數組，指派3個元素，數組的索引就是15，25，35，沒有3索引，是以我們不能通路數組中不存在的索引，程式運作後，将會抛出 ArrayIndexOutOfBoundsException 數組越界異常。在開發中，數組的越界異常是不能出現的，一旦出現了，就必須要修改我們編寫的代碼。

15
25
35
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
	at com.zjq.javabase.base05.demo03.Demo01ArrayIndex.main(Demo01ArrayIndex.java:25)
           

數組空指針異常

觀察一下代碼，運作後會出現什麼結果。

public static void main(String[] args) {
        int[] array = null;
//        array = new int[3];
        System.out.println(array[0]);
    }
           

array= null 這行代碼，意味着變量arr将不會在儲存數組的記憶體位址，也就不允許再操作數組了，是以運作的時候

會抛出NullPointerException 空指針異常。在開發中，數組的越界異常是不能出現的，一旦出現了，就必須要修

改我們編寫的代碼。

Exception in thread "main" java.lang.NullPointerException
	at com.zjq.javabase.base05.demo03.Demo02ArrayNull.main(Demo02ArrayNull.java:20)
           

數組周遊

數組周遊： 就是将數組中的每個元素分别擷取出來，就是周遊。周遊也是數組操作中的基石。

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    System.out.println(arr[3]);
    System.out.println(arr[4]);
}
           

以上代碼是可以将數組中每個元素全部周遊出來，但是如果數組元素非常多，這種寫法肯定不行，是以我們需要改造成循環的寫法。數組的索引是0 到lenght-1 ，可以作為循環的條件出現。

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
           

數組擷取最大值元素

最大值擷取：從數組的所有元素中找出最大值。

實作思路：

• 定義變量，儲存數組0索引上的元素
• 周遊數組，擷取出數組中的每個元素
• 将周遊到的元素和儲存數組0索引上值的變量進行比較
• 如果數組元素的值大于了變量的值，變量記錄住新的值
• 數組循環周遊結束，變量儲存的就是數組中的最大值

代碼實作如下：

public static void main(String[] args) {
        int[] array = { 5, 15, 30, 20, 10000, 30, 35 };

        int max = array[0]; // 比武擂台
        for (int i = 1; i < array.length; i++) {
            // 如果目前元素，比max更大，則換人
            if (array[i] > max) {
                max = array[i];
            }
        }
        // 誰最後最厲害，就能在max當中留下誰的戰鬥力
        System.out.println("最大值：" + max);
    }
           

數組反轉

數組的反轉： 數組中的元素颠倒順序，例如原始數組為1,2,3,4,5，反轉後的數組為5,4,3,2,1

實作思想：數組最遠端的元素互換位置。

• 實作反轉，就需要将數組最遠端元素位置交換
• 定義兩個變量，儲存數組的最小索引和最大索引
• 兩個索引上的元素交換位置
• 最小索引++，最大索引--，再次交換位置
• 最小索引超過了最大索引，數組反轉操作結束

代碼實作：

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    /*
    循環中定義變量min=0最小索引
    max=arr.length‐1最大索引
    min++,max‐‐
    */
    for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {
        //利用第三方變量完成數組中的元素交換
        int temp = arr[min];
        arr[min] = arr[max];
        arr[max] = temp;
    }
    // 反轉後，周遊數組
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
           

數組作為方法參數和傳回值

數組作為方法參數

以前的方法中我們學習了方法的參數和傳回值，但是使用的都是基本資料類型。那麼作為引用類型的數組能否作為方法的參數進行傳遞呢，當然是可以的。

數組作為方法參數傳遞，傳遞的參數是數組記憶體的位址。

public static void main(String[] args) {
    int[] arr = { 1, 3, 5, 7, 9 };
    //調用方法，傳遞數組
    printArray(arr);
}
/*
建立方法，方法接收數組類型的參數
進行數組的周遊
*/
public static void printArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
           

數組作為方法傳回值

public static void main(String[] args) {
    //調用方法，接收數組的傳回值
    //接收到的是數組的記憶體位址
    int[] arr = getArray();
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
/**
    建立方法，傳回值是數組類型
    return傳回數組的位址
*/
public static int[] getArray() {
    int[] arr = { 1, 3, 5, 7, 9 };
    //傳回數組的位址，傳回到調用者
    return arr;
}