关于java:Java中javautilArrays参考指南

本文咱们将理解 java.util.Arrays。这是一个自 Java1.2 以来就存在的 Java 工具类。
应用 Arrays，咱们能够创立、比拟、排序、搜寻、流操作以及其余转换操作。

让咱们看一下通过 Arrays 创立数组的办法：copyOf、copyOfRange 和 fill。

应用 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 值来填充残余空间。

另一种形式，咱们能够应用 fill 创立一个固定长度的数组，当所有数组元素都一样的时候十分有用：

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

assertTrue(Stream.of(stutter).allMatch(el -> "once".equals(el));

setAll 是创立不同元素的数组。留神：咱们须要提前初始化数组在调用 fill 前。

当初让咱们来看一下应用 Arrays 进行比拟的办法。

咱们能够应用 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 只会比拟子数组的援用。
因而，应用自援用数组的调用十分危险。

咱们用 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 等数据结构做为数组元素时做低层运算的。

上面让咱们来看一下数据的排序和搜寻

如果咱们的元素是根本元素或实现了 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))。

在未排序的数组中搜寻是线性的，然而如果是排序的数组，咱们能够用二分查找在 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。

stream 办法让咱们像流一样调用 Stream API 来应用咱们的数组：

Assert.assertEquals(Arrays.stream(intro).count(), 4);

exception.expect(ArrayIndexOutOfBoundsException.class);
Arrays.stream(intro, 2, 1).count();

咱们能够传入在范畴内的索引或走出范畴的索引，超出范围会抛出 ArrayindexOutOfBoundsException。

最初，toString、asList 和 setAll 为咱们提供了几种不同办法来转换数组。

一个好的可读性很好的将根底类型数组转为字符串的办法：

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

同样咱们也能够用 deepToSTring 来打印对象类型的数组：

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

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 子类。

应用 setAll，设置一个生成器能够为数组初始化元素：

String[] longAgo = new String[4];
Arrays.setAll(longAgo, i -> intro[i]);
assertArrayEquals(longAgo, new String[]{"a", "long", "time", "ago"});

应用 lambda 表达式也是极易出异样的。

Arrays 在 Java8 引入的另一个新办法是 parallelPrefix。应用 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);
}

并行前缀计算通过比程序循环更高效，尤其对于大型数组。上面是一个基准测试后果：

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 中的增强。

关于java:Java中javautilArrays参考指南

一、介绍

二、创立

2.1. copyOf and copyOfRange

2.2. fill

三、比拟

3.1. equals and deepEquals

3.2. hashCode _and _deepHashCode

四、排序和搜寻

4.1. sort

4.2. binarySearch

五、流操作

5.1. stream

六、转换

6.1. toString and deepToString

6.2. asList

6.3. setAll

7. Parallel Prefix

7.1. parallelPrefix

7.2. Performance

八、总结