Java中java.util.Arrays参考指南

一、介绍

本文我们将了解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));
1
2
3
4
5

使用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]);
1
2
3
4
5

注意：copyOf后，如果返回数组长度大于源数组长度会用null值来填充剩余空间。

2.2. fill

另一种方式，我们可以使用fill创建一个固定长度的数组，当所有数组元素都一样的时候非常有用：

String[] stutter = new String[3];
Arrays.fill(stutter, "once");

assertTrue(Stream.of(stutter).allMatch(el -> "once".equals(el));
1
2
3
4

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));
1
2
3

如果我们比较嵌套或多维数组，我们可以使用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));
1
2
3
4
5
6
7
8

上述代码，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);
1
2
3

现在，我们将数组中一个元素置为空并重新获取它的hash值

intro[3] = null;
int hashAfter = Arrays.hashCode(looping);
1
2

我们再试试deepHashCode，它检查数组的每个元素的内容。我们重新来调用一次：

int deepHashAfter = Arrays.deepHashCode(looping);
1

现在，我们来看一些这两个方法有什么不同：

assertEquals(hashAfter, hashBefore);
assertNotEquals(deepHashAfter, deepHashBefore);
1
2

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);
1
2
3
4

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);
1
2
3
4
5
6
7

如果我们不提供比较器作为第三个参数，那么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();
1
2
3
4

我们可以传入在范围内的索引或走出范围的索引，超出范围会抛出ArrayindexOutOfBoundsException。

六、转换

最后，toString、asList和setAll为我们提供了几种不同方法来转换数组。

6.1. toString and deepToString

一个好的可读性很好的将基础类型数组转为字符串的方法：

assertEquals("[once, upon, a time]", Arrays.toString(storyIntro));
1

同样我们也可以用deepToSTring来打印对象类型的数组：

assertEquals(
"[[once, upon, a, time], [chapter one, chapter tow], [the, end]]",
Arrays.deepToString(story));
1
2
3

6.2. asList

Arrays方法中最方便的一个是asList，它可以将数组转换为列表：

List<String> rets = Arrays.asList(intro);

assertTrue(rets.contains("upon"));
assertTrue(rets.contains("time"));
assertEquals(rets.size(), 4);
1
2
3
4
5

但是，返回的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"});
1
2
3

使用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}));
1
2
3

我们也可以指定一个范围：

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}));
1
2
3

注意：因为该方法是并行执行的，因此累积操作应该是无状态的。
对于非关联函数：

int nonassociativeFunc(int left, int right) {
    return left + right * left;
}
1
2
3

如下会产生不一致的情况：

@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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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
1
2
3
4
5
6
7

下面是基准测试代码：

@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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

八、总结

本文中我们了解了如何使用java.util.Arrays类创建、搜索、排序和转换数组的一些方法。
该类在最新的Java版本中进行了扩展，包括Java8中引入了流和Java9中的加强。