共计 5588 个字符，预计需要花费 14 分钟才能阅读完成。
一、介绍
本文咱们将理解 java.util.Arrays。这是一个自 Java1.2 以来就存在的 Java 工具类。
应用 Arrays，咱们能够创立、比拟、排序、搜寻、流操作以及其余转换操作。
二、创立
让咱们看一下通过 Arrays 创立数组的办法：copyOf、copyOfRange 和 fill。
2.1. copyOf and copyOfRange
应用 copyOfRange，咱们须要一个源数组和开始这索引与完结索引，前闭后开：
String[] intro = new String[]{"once", "upon", "a", "time"};
String[] abridgement = Arrays.copyOfRange(intro, 0, 3);
assertArrayEquals(new String[]{"once", "upon", "a"}, abridgement);
assertFalse(Arrays.equals(intro, abridgement));应用 copyOf，须要传递一个源数组和指标数组长度并且返回一个新数组，新数组长度为所传参数长度：
String[] intro = new String[]{"once", "upon", "a", "time"};
String[] revised = Arrays.copyOf(intro, 3);
String[] expanded = Arrays.copyOf(intro, 5);
assertArrayEquals(Arrays.copyOfRange(intro, 0, 3), revised);
assertNull(expanded[4]);留神：copyOf 后，如果返回数组长度大于源数组长度会用 null 值来填充残余空间。
2.2. fill
另一种形式，咱们能够应用 fill 创立一个固定长度的数组，当所有数组元素都一样的时候十分有用：
String[] stutter = new String[3];
Arrays.fill(stutter, "once");
assertTrue(Stream.of(stutter).allMatch(el -> "once".equals(el));setAll 是创立不同元素的数组。留神：咱们须要提前初始化数组在调用 fill 前。
三、比拟
当初让咱们来看一下应用 Arrays 进行比拟的办法。
3.1. equals and deepEquals
咱们能够应用 equals 对数组进行大小和内容的简略比拟。如果咱们向数组中增加了一个空元素，两个数组就不相等了。
String[] intro = new String[]{"once", "upon", "a", "time"};
assertTrue(Arrays.equals(new String[]{"once", "upon", "a", "time"}, intro));
assertFalse(Arrays.equals(new String[]{"once", "upon", "a", "null"}, intro));如果咱们比拟嵌套或多维数组，咱们能够应用 deepEquals 不仅比拟第一层元素，而且还会递归比拟对象元素：
String[] end = new String[]{"end"};
String[] intro = new String[]{"once", "upon", "a", "time"};
Object[] story =
new Object[]{intro, new String[]{"chapter one", "chapter two"}, end};
Object[] copy =
new Object[]{intro, new String[]{"chapter one", "chapter two"}, end};
assertTrue(Arrays.deepEquals(story, copy));
assertFalse(Arrays.equals(story, copy));上述代码，deepEquals 返回 true，equals 返回 false。
这是因为 deepEquals 每次比拟时都会调用本人，而 equals 只会比拟子数组的援用。
因而，应用自援用数组的调用十分危险。
3.2. hashCode _and _deepHashCode
咱们用 hashCode 办法来基于对象的内容计算出一个整数：
Object[] looping = new Object[]{intro, intro};
int hashBefore = Arrays.hasCode(looping);
int deepHashBefore = Arrays.deepHashCode(looping);当初，咱们将数组中一个元素置为空并从新获取它的 hash 值
intro[3] = null;
int hashAfter = Arrays.hashCode(looping);咱们再试试 deepHashCode，它查看数组的每个元素的内容。咱们从新来调用一次：
int deepHashAfter = Arrays.deepHashCode(looping);当初，咱们来看一些这两个办法有什么不同：
assertEquals(hashAfter, hashBefore);
assertNotEquals(deepHashAfter, deepHashBefore);deepHashCode 是咱们在 HashMap 和 HashSet 等数据结构做为数组元素时做低层运算的。
四、排序和搜寻
上面让咱们来看一下数据的排序和搜寻
4.1. sort
如果咱们的元素是根本元素或实现了 Compareable 的对象，咱们能够用 sort 来进行排序：
String[] sorted = Arrays.copyOf(intro, 4);
Arrays.sort(sorted);
assertArrayEquals(new String[]{"a", "once", "time", "upon"}, sorted);sort 依据数组不同的元素类型应用了不同的算法。根本类型应用了 dual-pivot quicksort，对象类型的数组应用了 Timsort。两者的工夫复杂度都是 O(nlog(n))。
4.2. binarySearch
在未排序的数组中搜寻是线性的，然而如果是排序的数组，咱们能够用二分查找在 O(logn)实现：
int exact = Arrays.binarySearch(sorted, "time");
int caseInsensitive =
Arrays.binarySearch(sorted, "TiMe", String::compareToIgnoreCase);
assertEquals("time", sorted[exact]);
assertEquals(2, exact);
assertEquals(exact, caseInsensitive);如果咱们不提供比拟器作为第三个参数，那么 binarySearch 将依赖于咱们元素类型的 Comparable。再次留神，应用 binarySearch 的前提是已排序数组。
五、流操作
之前提到过，Arrays 在 Java8 中进行了更新，提供了 Stream API 的办法，例如 parallelSort、stream 和 setAll。
5.1. stream
stream 办法让咱们像流一样调用 Stream API 来应用咱们的数组：
Assert.assertEquals(Arrays.stream(intro).count(), 4);
exception.expect(ArrayIndexOutOfBoundsException.class);
Arrays.stream(intro, 2, 1).count();咱们能够传入在范畴内的索引或走出范畴的索引，超出范围会抛出 ArrayindexOutOfBoundsException。
六、转换
最初，toString、asList 和 setAll 为咱们提供了几种不同办法来转换数组。
6.1. toString and deepToString
一个好的可读性很好的将根底类型数组转为字符串的办法：
assertEquals("[once, upon, a time]", Arrays.toString(storyIntro));同样咱们也能够用 deepToSTring 来打印对象类型的数组：
assertEquals("[[once, upon, a, time], [chapter one, chapter tow], [the, end]]",
Arrays.deepToString(story));6.2. asList
Arrays 办法中最不便的一个是 asList，它能够将数组转换为列表：
List<String> rets = Arrays.asList(intro);
assertTrue(rets.contains("upon"));
assertTrue(rets.contains("time"));
assertEquals(rets.size(), 4);然而，返回的 List 将是固定长度，因而咱们无奈增加或删除元素。留神：java.util.Arrays 的办法 asList 返回的是它本人的 ArrayList 子类。
6.3. setAll
应用 setAll，设置一个生成器能够为数组初始化元素：
String[] longAgo = new String[4];
Arrays.setAll(longAgo, i -> intro[i]);
assertArrayEquals(longAgo, new String[]{"a", "long", "time", "ago"});应用 lambda 表达式也是极易出异样的。
7. Parallel Prefix
Arrays 在 Java8 引入的另一个新办法是 parallelPrefix。应用 parallelPrefix , 咱们能够以累积的形式对输出数组的每个元素进行操作。
7.1. parallelPrefix
做一个累加操作像 [1, 2, 3, 4] 输入后果[1, 3, 6, 10]：
int[] arr = new int[]{1, 2, 3, 4};
Arrays.parallelPrefix(arr, (left, right) -> left + right);
assertThat(arr, is(new int[]{1, 3, 6, 10}));咱们也能够指定一个范畴：
int[] arr = new int[]{1, 2, 3, 4, 5};
Arrays.parallelPrefix(arr, 1, 4, (left, right) -> left + right);
assertThat(arr, is(new int[]{1, 2, 5, 9, 5}));留神：因为该办法是并行执行的，因而累积操作应该是无状态的。
对于非关联函数：
int nonassociativeFunc(int left, int right) {return left + right * left;}如下会产生不统一的状况：
@Test
public void whenPrefixNonAssociative_thenError() {
boolean consistent = true;
Random r = new Random();
for (int k = 0; k < 100_000; k++) {int[] arrA = r.ints(100, 1, 5).toArray();
int[] arrB = Arrays.copyOf(arrA, arrA.length);
Arrays.parallelPrefix(arrA, this::nonassociativeFunc);
for (int i = 1; i < arrB.length; i++) {arrB[i] = nonassociativeFunc(arrB[i - 1], arrB[i]);
}
consistent = Arrays.equals(arrA, arrB);
if(!consistent) break;
}
assertFalse(consistent);
}7.2. Performance
并行前缀计算通过比程序循环更高效，尤其对于大型数组。上面是一个基准测试后果：
Benchmark Mode Cnt Score Error Units
largeArrayLoopSum thrpt 5 9.428 ± 0.075 ops/s
largeArrayParallelPrefixSum thrpt 5 15.235 ± 0.075 ops/s
Benchmark Mode Cnt Score Error Units
largeArrayLoopSum avgt 5 105.825 ± 0.846 ops/s
largeArrayParallelPrefixSum avgt 5 65.676 ± 0.828 ops/s上面是基准测试代码：
@Benchmark
public void largeArrayLoopSum(BigArray bigArray, Blackhole blackhole) {for (int i = 0; i < ARRAY_SIZE - 1; i++) {bigArray.data[i + 1] += bigArray.data[i];
}
blackhole.consume(bigArray.data);
}
@Benchmark
public void largeArrayParallelPrefixSum(BigArray bigArray,
Blackhole blackhole) {Arrays.parallelPrefix(bigArray.data, (left, right) -> left + right);
blackhole.consume(bigArray.data);
}八、总结
本文中咱们理解了如何应用 java.util.Arrays 类创立、搜寻、排序和转换数组的一些办法。
该类在最新的 Java 版本中进行了扩大，包含 Java8 中引入了流和 Java9 中的增强。