數組(array)：是一種用於存儲多個相同數據類型的存儲模型(可以理解為容器)

數組定義和靜態初始化

數組的兩種定義格式：

  格式1：

    數據類型[] 變數名;

    範例： int[] arr; // 定義了一個int類型的數組，數組名是arr

  格式2：

    數據類型 變數名[];

    範例： int arr[]; 定義了一個int類型的變數，變數名是arr數組

public class Test {
public static void main(String args[ ]) {
    int[ ] s; // 聲明數組；
    s = new int[10]; // 動態初始化。給數組分配空間；
    for (int i = 0; i < 10; i++) {  // 遍曆數組
        s[i] = 2 * i + 1;//給數組元素賦值； 數組是對象，數組中的元素就是對象的屬性
        System.out.println(s[i]);
        } 
    }
}

靜態初始化

  初始化時指定每個數組元素的初始值，由系統決定數組長度

  格式：

    數據類型[] 變數名 = new 數據類型[]{數據1,數據2,數據3,…};

    範例：int[] arr = new int[]{1,2,3};

　　簡化格式：

    數據類型[] 變數名 = {數據1,數據2,數據3,…};

    範例：int[] arr = {1,2,3};

動態初始化

　　動態初始化：初始化時只指定數組長度，由系統為數組分配初始值     

　　格式：

　　　　數據類型[ ] 變數名 = new 數據類型 [數組長度];       // new：開闢數組記憶體空間

　　範例：

　　　　int[] arr = new int[3]; 表示我們定義了一個int類型的數組，初始化為3個元素。

• 靜態初始化：開始就存入元素值，適合一開始就能確定元素值的業務場景
• 動態初始化：指定數組長度，後期賦值，適合開始知道數據的數量，但是不確定具體元素值的業務場景
• 註意：兩種初始化的方式是獨立的，不可以混用

　　數組使用中的兩個小問題

　　　　1：索引越界：訪問了數組中不存在的索引對應的元素，造成索引越界問題

　　　　　　　　　　　　ArrayIndexOutOfBoundsException

　　　　2：空指針異常：對象不再指向堆記憶體，還想繼續訪問數據，訪問失敗

　　　　　　　　　　　　NullPointerException

　　　　3：null：空值，引用數據類型的預設值，表示不指向任何有效對象

數組的遍歷

 　　　　　　　　　數組特征：

　　　　　　①：索引從0開始

　　　　　　②：索引是連續的

　　　　　　③：索引逐一增加，每次加1

 數組元素下標的合法區間：[0, length-1]。我們可以通過下標來遍曆數組中的元素，遍 歷時可以讀取元素的值或者修改元素的值。

使用迴圈初始化和遍曆數

public class Test {
    public static void main(String[ ] args) {
        int[ ] a = new int[4]; // 動態初始化
//初始化數組元素的值
        for(int i=0;i<a.length;i++){
            a[i] = 100*i;
        }
//讀取元素的值
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
} 

for-each 迴圈

for-each 專門用於讀取數組或容器中所有的元素。

public class Test {
    public static void main(String[ ] args) {
        String[ ] ss = { "aa", "bbb", "ccc", "ddd" }; // 【靜態初始化】定義一個字元串數組
        for (String temp : ss) {
            System.out.println(temp);
        }
    }
}

• for-each 增強 for 迴圈在遍曆數組過程中不能修改數組中某元素的值。 
• for-each 僅適用於遍歷，不涉及有關索引（下標）的操作。

數組常見操作之獲取最大值

public class ArrayTest {
    public static void main(String[] args) {
//定義數組
        int[] arr = {12, 45, 98, 73, 60};
//定義變數max存儲最大值，取第一個數據為變數的初始值
        int max = arr[0];
//將這個max初始值與數組中剩餘數據逐個比對，每次比對將最大值覆蓋到變數max中
        for (int i=1; i<arr.length; i++) {
            if(arr[i] > max) {
                max = arr[i];
            }
        }
//迴圈結束後輸出變數max的值
        System.out.println("max:" + max);
    }
}

數組常見操作之元素打亂

public class ArrayTesttwo {
    public static void main(String[] args) {
//定義數組
        int[] arr = {12, 45, 98, 73, 60}; // 靜態初始化一個整型數組
        Random r = new Random();  // 生成隨機數
        for (int i = 0; i < arr.length; i++) {
            int index = r.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
//遍曆數組
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

關於random類的一些方法

import java.util.Random;

public class Test06 {
    public static void main(String[] args) {
        Random r = new Random();
        double d1 = r.nextDouble(); // 生成[0,1.0]區間的小數
        double d2 = r.nextDouble() * 7; // 生成[0,7.0]區間的小數 
　　　　 // 如果是加“+”，則區間裡面的數都要加“例如 * 7 改為 + 1，區間裡面為99，--則最終區間範圍為：1-100”

　　　　 double d2 = r.nextDouble() + 1;  // 則最終區間範圍為：1-100

        int i1 = r.nextInt(10); // 生成[0,10]區間的整數
        int i2 = r.nextInt(18) - 3; // 生成[-3,15)區間的整數
        long l1 = r.nextLong(); // 生成一個隨機長整型值
        boolean b1 = r.nextBoolean(); // 生成一個隨機布爾型值
        float f1 = r.nextFloat(); // 生成一個隨機浮點型值
        System.out.println("生成的[0,1.0]區間的小數是：" + d1);
        System.out.println("生成的[0,7.0]區間的小數是：" + d2);
        System.out.println("生成的[0,10]區間的整數是：" + i1);
        System.out.println("生成的[-3,15]區間的整數是：" + i2);
        System.out.println("生成一個隨機長整型值：" + l1);
        System.out.println("生成一個隨機布爾型值：" + b1);
        System.out.println("生成一個隨機浮點型值：" + f1);
        System.out.print("下期七星彩開獎號碼預測：");
        for (int i = 1; i < 8; i++) {
            int num = r.nextInt(9); // 生成[0,9]區間的整數
            System.out.print(num);
        }
    }
}

本實例每次運行時結果都不相同，這就實現了隨機產生數據的功能。該程式的運行結果如下：
生成的[0,1.0]區間的小數是：0.8773165855918825
生成的[0,7.0]區間的小數是：6.407083074782282
生成的[0,10]區間的整數是：5
生成的[-3,15]區間的整數是：4
生成一個隨機長整型值：-8462847591661221914
生成一個隨機布爾型值：false
生成一個隨機浮點型值：0.6397003
下期七星彩開獎號碼預測：0227168

數組的拷貝

　　System.arraycopy（object src，int srcpos，object dest， int destpos，int length）

　　該方法可以將 src 數組裡的元素值賦給 dest 數組的元素，其中 srcpos 指定從 src 數組的第幾個 元素 開始賦值，

　　length 參數指定將 src 數組的多少個元素賦給 dest 數組的元素

public class Test {
    public static void main(String args[ ]) {
　　　　　// 一個靜態初始化數組，一個賦有值，一個動態初始化數組，只分配數組記憶體空間
        String[ ] s = {"阿裡","位元組","京東","搜狐","網易"};
        String[ ] sBak = new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        for (int i = 0; i < sBak.length; i++) {
            System.out.print(sBak[i]+ "\t");
        }
    }
}

java.util.Arrays 類

Arrays 類包含了：排序、查找、填充、列印內容等常見的數組操作。

import java.util.Arrays;
public class Test {
    public static void main(String args[ ]) {
        int[ ] a = { 1, 2 }; // 靜態初始化一個2個元素的int型
        System.out.println(a); // 列印數組引用的值；
        System.out.println(Arrays.toString(a)); // 列印數組元素的值；
    }
}

直接列印a，出來的是其地址；Arrays.toString(a)直接遍歷列印出數組的元素

此處的 Arrays.toString()方法是 Arrays 類的靜態方法，不是前面講的 Object 的 toString() 方法。

使用 Arrays 類對數組元素進行排序

import java.util.Arrays;

class Test {
    public static void main(String args[]) {
        int[] a = {1, 2, 323, 23, 543, 12, 59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a); // sort(); 排序方法 將指定數組按升序排序。
        System.out.println(Arrays.toString(a));
    }
}

 使用 Arrays 類對數組進行填充 

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] a = {1, 2, 323, 23, 543, 12, 59};
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 2, 4, 100); //把數組a中的2到4索引的元素替換為100;     
        System.out.println(Arrays.toString(a)); 
    }
}