其他分享
首页 > 其他分享> > 检查两个数组是否相等或包含不匹配项

检查两个数组是否相等或包含不匹配项

作者:互联网

使用本教程可以确定使用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架构思维导图,分享给同样正在认真学习的每位朋友~欢迎私信交流!

课程大纲优锐课水印简版_副本_副本.jpg

标签:相等,匹配,Arrays,equals,int,数组,Melon,melons1
来源: https://blog.51cto.com/14667019/2479570