數組類，第 2 部分

“Rishi，我真的很期待了解 Arrays 類的其餘方法。

“這樣的學習熱情不能不讓你的老老師高興！但是，如果你真的想知道一切，一個名叫谷歌的好心嚮導會日以繼夜地幫助你。”

“呃……”

“開個玩笑。有點。當然，我會更好地解釋一切，但如果有任何事情發生 - 記住好巫師。我將以方法開始今天的Arrays.fill課程

“在處理數組時，Java 程序員經常需要用相同的值填充數組。當然，您可以編寫一個循環，並簡單地為循環中數組的每個單元格分配一些值：

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

“或者您可以調用該方法來代替所有這些Arrays.fill()，它做完全相同的事情：它用傳遞的值填充傳遞的數組。這是它的樣子：

Arrays.fill(name, value)

上面例子中的代碼可以做得更緊湊和更清晰一點：

int[] x = new int[100];
Arrays.fill(x, 999);

“美麗的！”

“您也可以使用該Arrays.fill()方法來填充不是整個數組，而是其中的一部分，具有一些值：

Arrays.fill(name, first, last, value)

“第一個和最後一個是要填充的第一個和最後一個單元格的索引。

"按照 Java 好的（或壞的）舊傳統，請記住最後一個元素不包含在範圍內。

例子：

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

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

“該Arrays.fill()方法僅適用於一維數組。如果將二維數組傳遞給該方法，它將被視為一維數組，並產生所有隨之而來的後果。

Arrays.copyOf()

“朋友，請問數組創建後如何改變數組的大小？”

“嗯……這是個騙人的問題，對吧？我又不是那麼沒經驗了。正確答案是你不能！數組創建後不能調整大小。”

“但如果你真的想要呢？”

“還是不可能！

“實際上，如果你真的想要，那麼你可以！借助編程技巧：

1. 首先，您創建一個所需長度的新數組
2. 然後將第一個數組中的所有元素複製到其中。

“這些是該方法所做的兩件事Arrays.copyOf()。這就是調用它的樣子：

Type[] name2 = Arrays.copyOf(name, length);

“這個方法並沒有改變現有的數組，而是創建了一個新數組，並將舊數組的元素複製到其中。”

“如果新數組的長度小於現有數組的長度怎麼辦？

“好問題，阿米戈！如果元素不適合，那麼多餘的值就會被忽略。”

“相反，如果有額外的細胞，它們的初始值是多少？

“如果新數組的長度大於舊數組的長度，則單元格用零填充。

例子：

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

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

Arrays.copyOfRange()

“如果你想從一個長度為 10 的數組中得到一個長度為 5 的數組，但你需要它包含最後 5 個元素而不是前 5 個元素怎麼辦？在這種情況下，你需要該類的另一個方法。它Arrays是Arrays.copyOfRange().這就是調用它的樣子：

Type[] name2 = Arrays.copyOfRange(name, first, last);

“此方法還創建了一個新數組，但用原始數組中任意位置的元素填充它。first和last是應該放入新數組的第一個和最後一個元素的索引。你能告訴我是否最後一個元素包含在這個範圍內嗎？”

“哈！正如我偉大的老師曾經說過的那樣，‘根據 Java 好的（或壞的）古老傳統，記住最後一個元素不包含在範圍內’。”

“朋友，你正在我們眼前成長。

例子：

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

Arrays.sort()

“最後，我把最……嗯……令人愉快的方法留到最後：排序。數組在編程中經常被排序。以下是使用數組時最常用的前 3 個操作：

• 排序數組
• 查找數組的最小（或最大）元素
• 確定數組中元素的索引（查找數組中的元素）

“我必須說，性能良好的排序算法並不那麼容易編寫。更準確地說，這是一項標準任務，作為一名學生，有時練習編寫排序算法不會對你造成傷害。但在工作中，它是最好不要浪費時間重新發明輪子。Java 的創建者sort()在Arrays類中包含了該方法。這就是調用它的樣子：

Arrays.sort(name);

此方法按升序對傳遞的數組進行排序。

例子：

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);
String str = Arrays.toString(x);

“太棒了！我只調用了一個方法，數組就排序了。真是太棒了！”

“順便說一下，你不僅可以對整個數組進行排序，還可以只對其中的一部分進行排序。這就是調用它的樣子：

Arrays.sort(name, first, last);

“第一個和最後一個是排序應該接觸的第一個和最後一個單元格的索引。並且......

“我已經知道你要說什麼了！‘按照 Java 好的（或壞的）老傳統，記住最後一個元素不包含在範圍內’。

例子：

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

“為了對數組進行排序，Java 使用了最快的排序算法——QuickSort 。其計算複雜度取決於數組的大小，並使用公式 N log(N) 進行計算。

“對 1000 個元素的數組進行排序將涉及大約 10,000 次數組元素比較。對 100 萬個元素的數組進行排序將涉及大約 2000 萬次比較。”

“考慮到元素的數量，就不要太多比較了！”

“這正是我要說的。QuickSort算法非常高效。

Arrays.binarySearch()

“好吧，這個類的最後一個最有趣的方法Arrays是能夠在數組中搜索給定的值。這不是普通的搜索——它是深受喜愛的二進制搜索。它歸結為：

• 首先，對數組進行排序。
• 然後將數組的中間元素與我們要查找的元素進行比較。
• 如果元素大於中間元素，則在數組的右半部分繼續搜索。
• 如果我們要查找的元素小於中間元素，則在數組的左半部分繼續查找。

“因為數組是排序好的，一次比較就可以淘汰掉一半，那麼下一步，我們再折騰掉一半，以此類推。”

“太棒了！我們很快就直奔目標了！”

“沒錯。在一百萬（！）個元素的數組中，二分查找算法只需比較 20 次就可以找到所需元素的索引。該算法的缺點是必須先對數組進行排序，排序也需要時間。

這就是調用它的樣子：

int index = Arrays.binarySearch(name, value);

"wherename是數組的名字，必須傳入已經排序好的（比如使用方法Arrays.sort()）。並且value是我們要在數組中查找的元素。方法返回的結果就是要查找的數組元素的索引.

例子：

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

“如果所需元素在數組中出現多次怎麼辦？”

“這是一個有效的問題，阿米戈。在這種情況下，算法將返回其中一個的索引（不能保證它會是，比如說，第一個，反之亦然——這些重複元素中的最後一個） ”

“如果數組根本不包含所需的元素怎麼辦？”

“在這種情況下，算法將返回一個負數索引。

文檔

“一切都清楚了，Rishi！這很有趣。”

“如果您真的覺得這很有趣，那麼請在閒暇時瀏覽一下Oracle 網站Arrays上該類及其方法的官方文檔。

“你可以仔細看看，例如，Arrays.mismatch()和Arrays.compare()方法。你很可能能夠很好地利用它們。

“不要被方法的數量搞糊塗了。每個方法都有 5-10 種變體，它們僅在參數類型上有所不同。”