本章概要

• 數(shù)組特性
  • 用于顯示數(shù)組的實用程序
• 一等對象
• 返回數(shù)組

簡單來看，數(shù)組需要你去創(chuàng)建和初始化，你可以通過下標(biāo)對數(shù)組元素進行訪問，數(shù)組的大小不會改變。大多數(shù)時候你只需要知道這些，但有時候你必須在數(shù)組上進行更復(fù)雜的操作，你也可能需要在數(shù)組和更加靈活的 集合 (Collection)之間做出評估。因此本章我們將對數(shù)組進行更加深入的分析。

注意： 隨著 Java Collection 和 Stream 類中高級功能的不斷增加，日常編程中使用數(shù)組的需求也在變少，所以你暫且可以放心地略讀甚至跳過這一章。但是，即使你自己避免使用數(shù)組，也總會有需要閱讀別人數(shù)組代碼的那一天。那時候，本章依然在這里等著你來翻閱。

數(shù)組特性

明明還有很多其他的辦法來保存對象，那么是什么令數(shù)組如此特別？

將數(shù)組和其他類型的集合區(qū)分開來的原因有三：效率，類型，保存基本數(shù)據(jù)類型的能力。在 Java 中，使用數(shù)組存儲和隨機訪問對象引用序列是非常高效的。數(shù)組是簡單的線性序列，這使得對元素的訪問變得非?？?。然而這種高速也是有代價的，代價就是數(shù)組對象的大小是固定的，且在該數(shù)組的生存期內(nèi)不能更改。

速度通常并不是問題，如果有問題，你保存和檢索對象的方式也很少是罪魁禍?zhǔn)?。你?yīng)該總是從 ArrayList (來自 集合)開始，它將數(shù)組封裝起來。必要時，它會自動分配更多的數(shù)組空間，創(chuàng)建新數(shù)組，并將舊數(shù)組中的引用移動到新數(shù)組。這種靈活性需要開銷，所以一個 ArrayList 的效率不如數(shù)組。在極少的情況下效率會成為問題，所以這種時候你可以直接使用數(shù)組。

數(shù)組和集合(Collections)都不能濫用。不管你使用數(shù)組還是集合，如果你越界，你都會得到一個 RuntimeException 的異常提醒，這表明你的程序中存在錯誤。

在泛型前，其他的集合類以一種寬泛的方式處理對象（就好像它們沒有特定類型一樣）。事實上，這些集合類把保存對象的類型默認為 Object，也就是 Java 中所有類的基類。而數(shù)組是優(yōu)于 預(yù)泛型 (pre-generic)集合類的，因為你創(chuàng)建一個數(shù)組就可以保存特定類型的數(shù)據(jù)。這意味著你獲得了一個編譯時的類型檢查，而這可以防止你插入錯誤的數(shù)據(jù)類型，或者搞錯你正在提取的數(shù)據(jù)類型。

當(dāng)然，不管在編譯時還是運行時，Java都會阻止你犯向?qū)ο蟀l(fā)送不正確消息的錯誤。然而不管怎樣，使用數(shù)組都不會有更大的風(fēng)險。比較好的地方在于，如果編譯器報錯，最終的用戶更容易理解拋出異常的含義。

一個數(shù)組可以保存基本數(shù)據(jù)類型，而一個預(yù)泛型的集合不可以。然而對于泛型而言，集合可以指定和檢查他們保存對象的類型，而通過 自動裝箱 (autoboxing)機制，集合表現(xiàn)地就像它們可以保存基本數(shù)據(jù)類型一樣，因為這種轉(zhuǎn)換是自動的。

下面給出一例用于比較數(shù)組和泛型集合：

CollectionComparison.java

import java.util.*;import static com.example.test.ArrayShow.show;class BerylliumSphere {private static long counter;private final long id = counter++;@Overridepublic String toString() {return "Sphere " + id;}
}public class CollectionComparison {public static void main(String[] args) {BerylliumSphere[] spheres =new BerylliumSphere[10];for (int i = 0; i < 5; i++) {spheres[i] = new BerylliumSphere();}show(spheres);System.out.println(spheres[4]);List<BerylliumSphere> sphereList = Suppliers.create(ArrayList::new, BerylliumSphere::new, 5);System.out.println(sphereList);System.out.println(sphereList.get(4));int[] integers = {0, 1, 2, 3, 4, 5};show(integers);System.out.println(integers[4]);List<Integer> intList = new ArrayList<>(Arrays.asList(0, 1, 2, 3, 4, 5));intList.add(97);System.out.println(intList);System.out.println(intList.get(4));}
}

Suppliers.java

import java.util.Collection;
import java.util.function.BiConsumer;
import java.util.function.Supplier;
import java.util.stream.Stream;public class Suppliers {// Create a collection and fill it:public static <T, C extends Collection<T>> Ccreate(Supplier<C> factory, Supplier<T> gen, int n) {return Stream.generate(gen).limit(n).collect(factory, C::add, C::addAll);}// Fill an existing collection:public static <T, C extends Collection<T>>C fill(C coll, Supplier<T> gen, int n) {Stream.generate(gen).limit(n).forEach(coll::add);return coll;}// Use an unbound method reference to// produce a more general method:public static <H, A> H fill(H holder,BiConsumer<H, A> adder, Supplier<A> gen, int n) {Stream.generate(gen).limit(n).forEach(a -> adder.accept(holder, a));return holder;}
}

Suppliers.create() 方法在泛型一章中被定義。上面兩種保存對象的方式都是有類型檢查的，唯一比較明顯的區(qū)別就是數(shù)組使用 [ ] 來隨機存取元素，而一個 List 使用諸如 add() 和 get() 等方法。數(shù)組和 ArrayList 之間的相似是設(shè)計者有意為之，所以在概念上，兩者很容易切換。但是就像你在集合中看到的，集合的功能明顯多于數(shù)組。

隨著 Java 自動裝箱技術(shù)的出現(xiàn)，通過集合使用基本數(shù)據(jù)類型幾乎和通過數(shù)組一樣簡單。數(shù)組唯一剩下的優(yōu)勢就是效率。然而，當(dāng)你解決一個更加普遍的問題時，數(shù)組可能限制太多，這種情形下，您可以使用集合類。

用于顯示數(shù)組的實用程序

在本章中，我們處處都要顯示數(shù)組。Java 提供了 Arrays.toString() 來將數(shù)組轉(zhuǎn)換為可讀字符串，然后可以在控制臺上顯示。然而這種方式視覺上噪音太大，所以我們創(chuàng)建一個小的庫來完成這項工作。

import java.util.*;public interface ArrayShow {static void show(Object[] a) {System.out.println(Arrays.toString(a));}static void show(boolean[] a) {System.out.println(Arrays.toString(a));}static void show(byte[] a) {System.out.println(Arrays.toString(a));}static void show(char[] a) {System.out.println(Arrays.toString(a));}static void show(short[] a) {System.out.println(Arrays.toString(a));}static void show(int[] a) {System.out.println(Arrays.toString(a));}static void show(long[] a) {System.out.println(Arrays.toString(a));}static void show(float[] a) {System.out.println(Arrays.toString(a));}static void show(double[] a) {System.out.println(Arrays.toString(a));}// Start with a description:static void show(String info, Object[] a) {System.out.print(info + ": ");show(a);}static void show(String info, boolean[] a) {System.out.print(info + ": ");show(a);}static void show(String info, byte[] a) {System.out.print(info + ": ");show(a);}static void show(String info, char[] a) {System.out.print(info + ": ");show(a);}static void show(String info, short[] a) {System.out.print(info + ": ");show(a);}static void show(String info, int[] a) {System.out.print(info + ": ");show(a);}static void show(String info, long[] a) {System.out.print(info + ": ");show(a);}static void show(String info, float[] a) {System.out.print(info + ": ");show(a);}static void show(String info, double[] a) {System.out.print(info + ": ");show(a);}
}

第一個方法適用于對象數(shù)組，包括那些包裝基本數(shù)據(jù)類型的數(shù)組。所有的方法重載對于不同的數(shù)據(jù)類型是必要的。

第二組重載方法可以讓你顯示帶有信息 字符串 前綴的數(shù)組。

為了簡單起見，你通?？梢造o態(tài)地導(dǎo)入它們。

一等對象

不管你使用的什么類型的數(shù)組，數(shù)組中的數(shù)據(jù)集實際上都是對堆中真正對象的引用。數(shù)組是保存指向其他對象的引用的對象，數(shù)組可以隱式地創(chuàng)建，作為數(shù)組初始化語法的一部分，也可以顯式地創(chuàng)建，比如使用一個 new 表達式。數(shù)組對象的一部分（事實上，你唯一可以使用的方法）就是只讀的 length 成員函數(shù)，它能告訴你數(shù)組對象中可以存儲多少元素。[ ] 語法是你訪問數(shù)組對象的唯一方式。

下面的例子總結(jié)了初始化數(shù)組的多種方式，并且展示了如何給不同的數(shù)組對象分配數(shù)組引用。同時也可以看出對象數(shù)組和基元數(shù)組在使用上是完全相同的。唯一的不同之處就是對象數(shù)組存儲的是對象的引用，而基元數(shù)組則直接存儲基本數(shù)據(jù)類型的值。

import static com.example.test.ArrayShow.show;public class ArrayOptions {public static void main(String[] args) {// Arrays of objects:BerylliumSphere[] a; // Uninitialized localBerylliumSphere[] b = new BerylliumSphere[5];// The references inside the array are// automatically initialized to null:show("b", b);BerylliumSphere[] c = new BerylliumSphere[4];for (int i = 0; i < c.length; i++) {if (c[i] == null) // Can test for null reference{c[i] = new BerylliumSphere();}}// Aggregate initialization:BerylliumSphere[] d = {new BerylliumSphere(),new BerylliumSphere(),new BerylliumSphere()};// Dynamic aggregate initialization:a = new BerylliumSphere[]{new BerylliumSphere(), new BerylliumSphere(),};// (Trailing comma is optional)System.out.println("a.length = " + a.length);System.out.println("b.length = " + b.length);System.out.println("c.length = " + c.length);System.out.println("d.length = " + d.length);a = d;System.out.println("a.length = " + a.length);// Arrays of primitives:int[] e; // Null referenceint[] f = new int[5];// The primitives inside the array are// automatically initialized to zero:show("f", f);int[] g = new int[4];for (int i = 0; i < g.length; i++) {g[i] = i * i;}int[] h = {11, 47, 93};//  Compile error: variable e not initialized://- System.out.println("e.length = " + e.length);System.out.println("f.length = " + f.length);System.out.println("g.length = " + g.length);System.out.println("h.length = " + h.length);e = h;System.out.println("e.length = " + e.length);e = new int[]{1, 2};System.out.println("e.length = " + e.length);}
}

數(shù)組 a 是一個未初始化的本地變量，編譯器不會允許你使用這個引用直到你正確地對其進行初始化。數(shù)組 b 被初始化成一系列指向 BerylliumSphere 對象的引用，但是并沒有真正的 BerylliumSphere 對象被存儲在數(shù)組中。盡管你仍然可以獲得這個數(shù)組的大小，因為 b 指向合法對象。

這帶來了一個小問題：你無法找出到底有多少元素存儲在數(shù)組中，因為 length 只能告訴你數(shù)組可以存儲多少元素；這就是說，數(shù)組對象的大小并不是真正存儲在數(shù)組中對象的個數(shù)。然而，當(dāng)你創(chuàng)建一個數(shù)組對象，其引用將自動初始化為 null，因此你可以通過檢查特定數(shù)組元素中的引用是否為 null 來判斷其中是否有對象。基元數(shù)組也有類似的機制，比如自動將數(shù)值類型初始化為 0，char 型初始化為 (char)0，布爾類型初始化為 false。

數(shù)組 c 展示了創(chuàng)建數(shù)組對象后給數(shù)組中各元素分配 BerylliumSphere 對象。數(shù)組 d 展示了創(chuàng)建數(shù)組對象的聚合初始化語法（隱式地使用 new 在堆中創(chuàng)建對象，就像 c 一樣）并且初始化成 BeryliumSphere 對象，這一切都在一條語句中完成。

下一個數(shù)組初始化可以被看做是一個“動態(tài)聚合初始化”。 d 使用的聚合初始化必須在 d 定義處使用，但是使用第二種語法，你可以在任何地方創(chuàng)建和初始化數(shù)組對象。例如，假設(shè) hide() 是一個需要使用一系列的 BeryliumSphere對象。你可以這樣調(diào)用它：

hide(d);

你也可以動態(tài)地創(chuàng)建你用作參數(shù)傳遞的數(shù)組：

hide(new BerylliumSphere[]{new BerlliumSphere(),new BerlliumSphere()
});

很多情況下這種語法寫代碼更加方便。

表達式：

a = d;

顯示了你如何獲取指向一個數(shù)組對象的引用并將其分配給另一個數(shù)組對象。就像你可以處理其他類型的對象引用?，F(xiàn)在 a 和 d 都指向了堆中的同一個數(shù)組對象。

ArrayOptions.java 的第二部分展示了基元數(shù)組的語法就像對象數(shù)組一樣，除了基元數(shù)組直接保存基本數(shù)據(jù)類型的值。

返回數(shù)組

假設(shè)你寫了一個方法，這個方法不是返回一個元素，而是返回多個元素。對 C++/C 這樣的語言來說這是很困難的，因為你無法返回一個數(shù)組，只能是返回一個指向數(shù)組的指針。這會帶來一些問題，因為對數(shù)組生存期的控制變得很混亂，這會導(dǎo)致內(nèi)存泄露。

而在 Java 中，你只需返回數(shù)組，你永遠不用為數(shù)組擔(dān)心，只要你需要它，它就可用，垃圾收集器會在你用完后把它清理干凈。

下面，我們返回一個 字符串 數(shù)組：

import java.util.*;import static com.example.test.ArrayShow.show;public class IceCreamFlavors {private static SplittableRandom rand =new SplittableRandom(47);static final String[] FLAVORS = {"Chocolate", "Strawberry", "Vanilla Fudge Swirl","Mint Chip", "Mocha Almond Fudge", "Rum Raisin","Praline Cream", "Mud Pie"};public static String[] flavorSet(int n) {if (n > FLAVORS.length) {throw new IllegalArgumentException("Set too big");}String[] results = new String[n];boolean[] picked = new boolean[FLAVORS.length];for (int i = 0; i < n; i++) {int t;do {t = rand.nextInt(FLAVORS.length);}while (picked[t]);results[i] = FLAVORS[t];picked[t] = true;}return results;}public static void main(String[] args) {for (int i = 0; i < 7; i++) {show(flavorSet(3));}}
}

flavorset() 創(chuàng)建名為 results 的 String 類型的數(shù)組。 這個數(shù)組的大小 n 取決于你傳進方法的參數(shù)。然后從數(shù)組 FLAVORS 中隨機選擇 flavors 并且把它們放進 results 里并返回。返回一個數(shù)組就像返回其他任何對象一樣，實際上返回的是引用。數(shù)組是在 flavorSet() 中或者是在其他什么地方創(chuàng)建的并不重要。垃圾收集器會清理你用完的數(shù)組，你需要的數(shù)組則會保留。

如果你必須要返回一系列不同類型的元素，你可以使用 泛型 中介紹的 元組 。

注意，當(dāng) flavorSet() 隨機選擇 flavors，它應(yīng)該確保某個特定的選項沒被選中。這在一個 do 循環(huán)中執(zhí)行，它將一直做出隨機選擇直到它發(fā)現(xiàn)一個元素不在 picked 數(shù)組中。（一個字符串

比較將顯示出隨機選中的元素是不是已經(jīng)存在于 results 數(shù)組中）。如果成功了，它將添加條目并且尋找下一個（ i 遞增）。輸出結(jié)果顯示 flavorSet() 每一次都是按照隨機順序選擇 flavors。

一直到現(xiàn)在，隨機數(shù)都是通過 java.util.Random 類生成的，這個類從 Java 1.0 就有，甚至更新過以提供 Java 8 流?，F(xiàn)在我們可以介紹 Java 8 中的 SplittableRandom ,它不僅能在并行操作使用（你最終會學(xué)到），而且提供了一個高質(zhì)量的隨機數(shù)。這本書的剩余部分都使用 SplittableRandom 。