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