数组类，第 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 个变体，它们仅在参数类型上有所不同。