使用本教程可以确定使用JDK API两个数组相等还是不匹配。
抽丝剥茧 细说架构那些事——【优锐课】
检查两个数组是否相等
通过Arrays.equals()方法可以很容易地检查两个数组是否相等。对于原始类型，对象和泛型，此标志方法具有多种形式。它还支持比较器。让我们考虑以下三个整数数组：
1
int[] integers1 = {3, 4, 5, 6, 1, 5};
2
int[] integers2 = {3, 4, 5, 6, 1, 5};
3
int[] integers3 = {3, 4, 5, 6, 1, 3};
现在，让我们检查integers1是否等于integers2，以及integers1是否等于integers3。这很简单：
1
boolean i12 = Arrays.equals(integers1, integers2); // true
2
boolean i13 = Arrays.equals(integers1, integers3); // false
前面的示例检查两个数组是否相等，但是我们可以通过以下方法检查两个数组（或范围）是否相等：
1
boolean equals(int[] a, int aFromIndex,
2
int aToIndex, int[] b, int bFromIndex, int bToIndex)
因此，我们通过范围[aFromIndex，aToIndex）划分第一个数组的段，并通过范围[bFromIndex，bToIndex）划分第二个数组的段：
1
// true
2
boolean is13 = Arrays.equals(integers1, 1, 4, integers3, 1, 4);
现在，让我们假设三个Melon数组：
1
public class Melon {
2
3
private final String type;
4
private final int weight;
5
6
public Melon(String type, int weight) {
7
this.type = type;
8
this.weight = weight;
9
}
10
11
@Override
12
public int hashCode() {
13
int hash = 7;
14
hash = 83 * hash + Objects.hashCode(this.type);
15
hash = 83 * hash + this.weight;
16
return hash;
17
}
18
19
@Override
20
public boolean equals(Object obj) {
21
22
if (this == obj) {
23
return true;
24
}
25
26
if (obj == null) {
27
return false;
28
}
29
30
if (getClass() != obj.getClass()) {
31
return false;
32
}
33
34
final Melon other = (Melon) obj;
35
if (this.weight != other.weight) {
36
return false;
37
}
38
39
if (!Objects.equals(this.type, other.type)) {
40
return false;
41
}
42
43
return true;
44
}
45
}
46
47
Melon[] melons1 = {
48
new Melon("Horned", 1500), new Melon("Gac", 1000)
49
};
50
51
Melon[] melons2 = {
52
new Melon("Horned", 1500), new Melon("Gac", 1000)
53
};
54
55
Melon[] melons3 = {
56
new Melon("Hami", 1500), new Melon("Gac", 1000)
57
};
根据equals()约定或基于指定的Comparator，将两个对象数组视为相等。我们可以轻松地检查melons1是否等于melons2，以及melons1是否等于melons3，如下所示：
1
boolean m12 = Arrays.equals(melons1, melons2); // true
2
boolean m13 = Arrays.equals(melons1, melons3); // false
并且，在明确的范围内，我们可以使用以下方法：
1
boolean equals(Object[] a, int aFromIndex,
2
int aToIndex, Object[] b, int bFromIndex, int bToIndex)
例如：
1
boolean ms13 = Arrays.equals(melons1, 1, 2, melons3, 1, 2); // false
尽管这些示例依赖于Melon.equals()实现，但是以下两个示例依赖于以下两个Comparator：
1
Comparator<Melon> byType = Comparator.comparing(Melon::getType);
2
Comparator<Melon> byWeight = Comparator.comparing(Melon::getWeight);
使用boolean equals(T[] a, T[] a2, Comparator<? super T> cmp) ，我们具有以下内容：
1
boolean mw13 = Arrays.equals(melons1, melons3, byWeight); // true
2
boolean mt13 = Arrays.equals(melons1, melons3, byType); // false
并且，在明确的范围内，使用：
1
Comparator, <T> boolean equals(T[] a, int aFromIndex, int aToIndex, T[] b,
2
int bFromIndex, int bToIndex, Comparator<? super T> cmp)
我们有以下内容：
1
// true
2
boolean mrt13 = Arrays.equals(melons1, 1, 2, melons3, 1, 2, byType);
检查两个数组是否包含不匹配项
如果两个数组相等，则不匹配应返回-1。但是，如果两个数组不相等，则不匹配应返回两个给定数组之间第一个不匹配的索引。为了解决此问题，我们可以依靠JDK 9 Arrays.mismatch()方法。
例如，我们可以检查integers1和integers2之间的不匹配，如下所示：
1
int mi12 = Arrays.mismatch(integers1, integers2); // -1
结果为-1，因为integers1和integers2相等。但是，如果我们检查integers1和integers3，则会收到值5，这是这两者之间第一个不匹配的索引：
1
int mi13 = Arrays.mismatch(integers1, integers3); // 5
如果给定的数组具有不同的长度，而较小的数组是较大数组的前缀，则返回的不匹配项是较小数组的长度。
对于Object数组，还有专用的mismatch()方法。这些方法依靠equals()合约或给定的Comparator。我们可以检查melons1和melons2之间是否不匹配，如下所示：
1
int mm12 = Arrays.mismatch(melons1, melons2); // -1
如果在第一个索引上发生不匹配，则返回值为0。这在melons1和melons3的情况下发生：
1
int mm13 = Arrays.mismatch(melons1, melons3); // 0
与Arrays.equals()一样，我们可以使用Comparator在明确范围内检查不匹配情况：
1
// range [1, 2), return -1
2
int mms13 = Arrays.mismatch(melons1, 1, 2, melons3, 1, 2);
3
4
// Comparator by melon's weights, return -1
5
int mmw13 = Arrays.mismatch(melons1, melons3, byWeight);
6
7
// Comparator by melon's types, return 0
8
int mmt13 = Arrays.mismatch(melons1, melons3, byType);
9
10
// range [1,2) and Comparator by melon's types, return -1
11
int mmrt13 = Arrays.mismatch(melons1, 1, 2, melons3, 1, 2, byType);
OK!
感谢阅读！
另外近期整理了一套完整的Java架构思维导图，分享给同样正在认真学习的每位朋友~欢迎私信交流！
