陣列

陣列存盤相同型別值的序列，

宣告陣列

陣列是一種資料結構，用來存盤同一型別值的集合，通過一個整型下標(index，或稱索引)可以訪問陣列中的每一個值，例如，如果a是一個整型陣列，a[i]就是陣列中下標為i的整數，
在宣告陣列變數時，需要指出陣列型別(資料元素型別緊跟[])和陣列變數的名字，下面宣告了整型陣列a：

int[] a;

不過，這條陳述句只宣告了變數a，并沒有將a初始化為一個真正的陣列，應該使用new運算子創建陣列

int[] a = new int[100];

這條陳述句宣告并初始化了一個可以存盤100個整數的陣列，
陣列長度不要求是常量：new int[n]會創建一個長度為n的陣列，
一旦創建了陣列，就不能再改變它的長度，如果程式運行中需要經常擴展陣列的大小，就應該使用另一種資料結構---陣列串列(array list)

在Java中，提供了一種創建陣列物件并同時提供初始值的簡寫形式，如下：

int[] a = {2, 3, 5, 7, 11, 13};

請注意，這個語法不需要使用new，甚至不用指定長度，
最后一個值后面允許有逗號，如果你要不斷為陣列增加值，這會很方便：

String[] authors = {"James", "Kobe", "Curry", "Durant",};

當然，我們也可以宣告一個匿名陣列；

new int[] {17, 19, 23, 29, 31, 37}

這會分配一個新陣列并填入大括號中提供的值，它會統計初始值的個數，并相應地設定陣列大小，可以使用這種語法重新初始化一個陣列而無須創建新變數，例如：

smallPrimes = new int [] {17, 19, 23, 29, 31, 37};

注意
在Java中，允許有長度為0的陣列，在撰寫一個結果為陣列的方發時，如果碰巧結果為空，這樣一個長度為0的陣列就很有用，可以如下創建長度為0的陣列：

new elementType[0];
或
new elementType2[] {};

訪問陣列

前面的陣列元素的下標為從0~99(不是1~100)，一旦創建了陣列，就可以在陣列中填入元素，例如，使用一個回圈：

int[] a = new int[100];
for (int i = 0; i < 100; i++) {
    a[i] = i;
}

創建一個數字陣列時，所有元素都初始化為0，boolean陣列的元素會初始化為false，物件陣列的元素則初始化為一個特殊值null，表示這些元素還未存放任何物件，剛開始我們可能有些不了解，例如：

String[] names = new String[10];

我們會創建一個包含10個字串的陣列，所有字串都為null，如果希望這個陣列包含空串，必須為元素指定空串：

for (int i=0; i < 10; i++) names[i] = "";

注意：如果創建了一個100個元素的陣列，并且試圖訪問元素a[100](或在0~99之間的任何下標)，就會引發array index out of bounds例外，
如果我們想獲得陣列中的元素個數，可以使用array.length，例如：

for (int i=0; i<a.length; i++) {
  System.out.println(a[i]);
}

for each回圈

Java有一種功能很強的回圈結構，可以用來依次處理陣列(或者其他元素集合)中的每個元素，而不必考慮指定下標值，這種增強的for回圈的陳述句格式為：

for (variable: collection) statement

它定義一個變數用于暫存集合中的每一個元素，并執行相應的陳述句(當然，也可以是陳述句塊)，collection這一集合運算式必須是一個陣列或者是一個實作了Iterable介面的類物件(例如ArrayList)，例如：

int[] a = {2, 3, 4, 5, 6};
for (int element: a) {
    System.out.println(element);
}

列印陣列a的每一個元素，一個元素占一行，

這個回圈應該讀作"回圈a中的每一個元素"(for each element in a)，當然，使用傳統的for回圈也可以獲得同樣的效果：

for (int i = 0;i < a.length; i++) {
    System.out.println(a[i]);
}

但是，for each回圈陳述句顯得更加簡潔、更不易出錯，因為你不必為下標的起始值和終止值而操心，
for each回圈陳述句的回圈變數將會遍歷陣列中的每個元素，而不是下標值
總結：如果需要處理一個集合中的所有元素，for each回圈陳述句相對于傳統回圈陳述句所做的改進很讓人欣喜，然而，很多情況下還是需要使用傳統的for回圈，例如，如果不希望變數整個集合，或者在回圈內部需要使用下標值時，

陣列拷貝

在Java中，允許將一個陣列變數拷貝到另一個陣列變數，這時，兩個變數將參考同一個陣列：

public class SevenSample {
    public static void main(String[] args) {
        int[] smallPrimes = {2, 3, 4, 5, 6, 7, 8};
        // 拷貝smallPrimes
        int[] luckyNumbers = smallPrimes;
        System.out.println(Arrays.toString(luckyNumbers));
    }
}

結果

[2, 3, 4, 5, 6, 7]

下圖顯示了拷貝的結果，

如果希望將一個陣列的所有值拷貝到一個新的陣列中去，就要使用Arrays類的copyOf方法：

import java.util.Arrays;

public class SevenSample {
    public static void main(String[] args) {
        int[] smallPrimes = {2, 3, 4, 5, 6, 7};
        int[] copiedLuckyNumbers = Arrays.copyOf(smallPrimes, smallPrimes.length);
        System.out.println(Arrays.toString(copiedLuckyNumbers));
    }
}

結果如下：

[2, 3, 4, 5, 6, 7]

Array.copyOf方法中，第1個引數是拷貝的物件，第2個引數是新陣列的長度，這個方法通常用來增加陣列的大小：

luckNumbers = Arrays.copyOf(luckyNumbers, 2 * luckyNumbers.length);

①如果陣列元素是數值型，那么額外的元素將被賦值為0；

②如果陣列元素是布林值，那么額外的元素將被賦值為false，

③如果長度小于原始陣列的長度，則只拷貝前面的值

命令列引數

每一個Java應用程式都有一個帶String args[]引數的main方法，這個引數表明main方法將接收一個字串陣列，也就是命令列上指定的引數，
例如，來看下面的程式：

public class EightSample {
    public static void main(String[] args) {
        if (args.length == 0 || args[0].equals("-h"))
            System.out.print("Hello, ");
        else if (args[0].equals("-g"))
            System.out.print("Goodbye, ");
        for (int i = 1; i < args.length; i++)
            System.out.print(" " + args[i]);
        System.out.println("!");
    }
}

如果使用下面這種形式呼叫這個程式：

java EightSample -g cruel world

args陣列將包含以下內容：

args[0]: "-g"
args[1]: "cruel"
args[2]: "world"

這個程式會輸出下面的資訊：

陣列排序

要想對數值型陣列進行排序，可以使用Arrays類中的sort方法：

int[] a = new int[10000];
...
Arrays.sort(a)

這個方法使用了優化的快速排序演算法，快速排序演算法對于大多數資料集合來說都是效率比較高的，

實戰

寫一個程式，它產生一個抽彩游戲中的亂數字組合，我們加入抽彩是從49個數字中抽取6個，那么輸出的結果為：

下注以下組合，它會使你發財
8
30
32
43
46
49

具體代碼如下：

public class NinthSample {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        System.out.println("你要抽多少次？");
        int k = in.nextInt();

        System.out.println("你能抽取的最高數字是什么？");
        int n = in.nextInt();

        // 從數字1 2 3...n填入陣列numbers
        int[] numbers = new int[n];
        for (int i = 0; i < numbers.length; i++)
            numbers[i] = i + 1;

        // 抽取k次并放入第二個陣列中
        int[] result = new int[k];
        for (int i = 0; i < result.length; i++)
        {
            // 0到n-1之間創建一個隨機索引
            int r = (int) (Math.random() * n);

            // 從隨機的位置獲取元素
            result[i] = numbers[r];

            // 將最后一個元素移動到隨機位置
            numbers[r] = numbers[n - 1];
            n--;
        }

        Arrays.sort(result);
        System.out.println("下注以下組合，它會使你發財");
        for (int r: result)
            System.out.println(r);
    }
}

代碼邏輯分析
??要想選擇一個隨機的數字集合，就要首先將值1,2,...,n存入陣列numbers中：

int[] numbers = new int[n];
for (int i=0; i < numbers.length; i++)
    numbers[i] = i + 1;

??用第二個陣列存放抽取出來的數：

int[] result = new int[k];

??現在，就可以開始抽取k個數了，Math.random方法回傳一個0到1之間(包含0，不包含1)的隨機浮點數，用n乘以浮點數，就可以得到從0到n-1之間的一個亂數，

int r = (int) (Math.random() * n);

??下面將result的第i個元素設定為numbers[r]存放的數值，最初是r+1，但正如所看到的，numbers陣列的內容在每一次抽取之后都會發生變化，

result[i] = numbers[r];

??現在，必須確保不會再次抽取到那個數，因為所有抽彩的數必須不相同，因此，這里用陣列中的最后一個數覆寫number[r]，并將n減1，

numbers[r] = numbers[n - 1];
n--;

??關鍵在于每次抽取的都是下標，而不是實際的值，下標指向陣列中包含尚未抽取過的值，
??在抽取了k個數之后，可以對result陣列進行排序，這樣可以讓輸出效果更好：

Arrays.sort(result);
for (int r: result)
    System.out.println(r);

Arrays API

static String toString(xxx[] a)
回傳包含a中元素的一個字串，這些元素用中括號包圍、并用逗號分隔，在這個方法以及后面的方法中，陣列元素型別xxx可以是`int`、`long`、`short`、`char`、`byte`、`boolean`、`float`或`double`，

static xxx[] copyOf(xxx[] a, int end)
static xxx[] copyOfRange(xxx[] a, int start, int end)
回傳與a型別相同的一個陣列，其長度為`length`或者`end-start`，陣列元素為a的值，如果end大于`a.length`，結果會填充0或false值，

static void sort(xxx[] a)
使用優化的快速排序演算法對陣列進行排序

static int binarySearch(xxx[] a, xxx v)
static int binarySearch(xxx[] a, int start, int end, xxx v)
使用二分查找演算法在有序陣列a中查找值v，如果找到v，則回傳相應的下標：否則回傳同一個負數值r，`-r-1`是v應插入的位置(為保持a有序)，

static void fill(xxx[] a, xxx v)
將陣列的所有資料元素設定為v，

static boolean equals(xxx[] a, xxx[] b)
如果兩個陣列大小相同，并且下標相同的元素都對應相等，回傳true

多維陣列

多維陣列將使用多個下標訪問陣列元素，它適用于表示表格或更加復雜的排列形式，
假設需要建立一個數值表格，用來顯示不同利率下投資10000美元會增長多少，我們可以使用一個二維陣列(也稱為矩陣)來存盤這些資訊，陣列命名為balances，
在Java中，宣告一個二維陣列很簡單，如下：

double[][] balances;

對陣列進行初始化之前是不能使用的，我們可以像下面一樣進行初始化：

balances = new double[NYEARS][NRATES];

另外，如果知道陣列元素，就可以不呼叫new，而直接使用簡寫形式對多維陣列進行初始化：

int[][] magicSquare = 
{
  {1, 2, 3, 4},
  {5, 6, 7, 8}
};

一旦陣列初始化，就可以利用兩個中括號訪問各個元素，例如，balance[i][j]

實戰

public class ElevenSample {
    public static void main(String[] args) {
        // 初始利率
        final double STARTRATE = 10;
        // 列數
        final int NRATES = 6;
        // 行數
        final int NYEARS = 10;

        // 定義利息陣列，陣列長度為6
        double[] interestRate = new double[NRATES];
        for (int j = 0; j < interestRate.length; j++)
            interestRate[j] = (STARTRATE + j) / 100.0;

        // 定義余額陣列，一維表示年，二維表示利率
        double[][] balances=  new double[NYEARS][NRATES];
        Arrays.fill(balances[0], 10000);

        for (int i = 1; i < balances.length; i++) {
            for (int j = 0; j < balances[i].length; j++) {
                double oldBalance = balances[i - 1][j];
                double interest = oldBalance * interestRate[j];
                balances[i][j] = oldBalance + interest;
            }
        }

        for (int j = 0; j < interestRate.length; j++)
            System.out.printf("%9.0f%%", 100 * interestRate[j]);
        System.out.println();

        for (double[] row : balances) {
            for (double b: row)
                System.out.printf("%10.2f", b);
            System.out.println();
        }
    }
}

結果

不規則陣列

暫不講解

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/499460.html

標籤：其他

上一篇：JAVA 裝箱拆箱--到底指什么呢？

下一篇：新蔬菜專題

零基礎學Java（8）陣列

陣列