數組類，第 2 部分

1.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)

其中 first 和 last 是要填充的第一個和最後一個單元格的索引。

例子：

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

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


String str = Arrays.toString(x);

"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

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

2.Arrays.copyOf()

如您所知，數組創建後無法調整其大小。

但是，如果您真的想要怎麼辦？

好吧，如果你真的想，那麼你可以！

• 創建一個所需長度的新數組
• 將第一個數組中的所有元素複製到其中。

順便說一句，這正是該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);

"[1, 2, 3, 4, 5]"

"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.Arrays.copyOfRange()

如果你想從一個長度為 10 的數組中得到一個長度為 5 的數組，但你需要它包含最後 5 個元素而不是前 5 個元素怎麼辦？

在這種情況下，該類的另一個方法Arrays將派上用場—— Arrays.copyOfRange(). 這是我們調用它時的樣子：

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

此方法還創建一個新數組，但用原始數組中任意位置的元素填充它。其中 first 和 last 是應該放入新數組的第一個和最後一個元素的索引。

例子：

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);

"[16, 17, 18, 19, 20]"

"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

啊，最美味的享受：排序。數組在編程中經常被排序。使用數組時最常見的三個操作是：

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

這正是 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);

"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

太棒了，對吧？你調用了一個方法，現在你有一個排序數組。美麗的。

順便說一句，您不僅可以使用此方法對整個數組進行排序，還可以只對其中的一部分進行排序。這就是調用它的樣子：

Arrays.sort(name, first, last);

其中first和last是排序應該觸及的第一個和最後一個單元格的索引。

例子：

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

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

"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

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

對包含 1000 個元素的數組進行排序將涉及大約 3,000 次數組元素比較。對一百萬個元素的數組進行排序將涉及大約 600 萬次比較。

5.Arrays.binarySearch()

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

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

因為數組是有序的，所以一次比較就可以去掉一半。然後在下一步中，我們扔掉另一半，依此類推。

這種方法使二進制搜索非常快。在一百萬（！）個元素的數組中，它可以在僅 20 次比較中找到所需元素的索引。該方法的缺點是必須先對數組進行排序，排序也需要時間。

這就是調用它的樣子：

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

name數組的名稱在哪裡，必須傳遞已經排序（例如，使用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);

{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

如果數組包含被搜索元素的多個實例，那麼算法將簡單地返回其中一個的索引（不能保證它會是第一個，反之亦然——這些中的最後一個）重複元素）。”

如果在數組中找不到該元素，則索引將為負數。

6. 鏈接到關於該類的 OracleArrays文檔

如果您非常感興趣，可以Arrays在官方文檔 a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base 中閱讀有關該類及其所有方法的所有內容/java/util/Arrays.html">在 Oracle 網站上。

例如，您可以閱讀有關Arrays.mismatch()和Arrays.compare()方法的信息。也許您會發現它們以某種方式有用。

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