java比较两个数组是否相等_Java如何判断两个集合的元素是否完全相等

一，实现

1. 最简单粗暴的方法，遍历循环

1 packagelist.demo;2

3 importjava.io.Serializable;4 import java.util.*;5 importjava.util.stream.Collectors;6

7 /**

8 * 判断两个集合是否相等9 */

10 public class CheckDiffList implementsSerializable {11 public static voidmain(String[] args) {12 List list = new ArrayList<>();13 List list1 = new ArrayList<>();14 for (int i = 0; i < 1000; i++) {15 list.add("test" +i);16 list1.add("test" + (i * 2));17 }18 System.out.println(checkDiffrent(list, list1));19 }20

21 /**

22 * 方法一：使用循环遍历23 */

24 private static boolean checkDiffrent(List list, Listlist1) {25 long st =System.nanoTime();26 if(list.size() !=list1.size()) {27 System.out.println("消耗时间：" + (System.nanoTime() -st));28 return false;29 }30 for(String str : list) {31 if(!list1.contains(str)) {32 System.out.println("消耗时间：" + (System.nanoTime() -st));33 return false;34 }35 }36 System.out.println("消耗时间：" + (System.nanoTime() -st));37 return true;38 }39 }

返回结果为：

消耗时间为： 16657988

false

2. 使用List的retainAll方法进行比较

1 packagelist.demo;2

3 importjava.io.Serializable;4 import java.util.*;5 importjava.util.stream.Collectors;6

7 /**

8 * 判断两个集合是否相等9 */

10 public class CheckDiffList implementsSerializable {11 public static voidmain(String[] args) {12 List list = new ArrayList<>();13 List list1 = new ArrayList<>();14 for (int i = 0; i < 1000; i++) {15 list.add("test" +i);16 list1.add("test" + (i * 2));17 }18 System.out.println(checkDiffrent1(list, list1));19 }20

21 /**

22 * 方法2：利用List的 retainAll的方法进行判断23 */

24 private static boolean checkDiffrent1(List list, Listlist1) {25 long st =System.nanoTime();26 System.out.println("消耗时间为：" + (System.nanoTime() -st));27 return !list.retainAll(list1);28 }29

30 }

返回结果为：

消耗时间为：7711

false

但是这个retainAll这个方法有缺陷，如果集合A数组的大小没有改变，则返回false。如果集合A和集合B是完全相同的集合，也会返回false。两个集合没有交集，才会返回true。简单来说，判断两个集合是否有交集，有则返回false，无则返回true(这句话不严谨)。总结来说只有两个任何一个元素都不相等时才会返回true，否则返回false。

3. 利用HashMap的唯一性，把元素当做key，value可以重复。把list存到HashMap中

我们的需求是判断两个List中的元素是否相同,那么可以这样考虑：用一个map存放list的所有元素，其中的key为list1的各个元素，value为该元素出现的次数,接着把list2的所有元素也放到map里，如果已经存在则value+1，一旦value停止+1，说明有元素不同了，返回false。否则一直遍历直至list2中所有元素，返回true。这样我们只需循环m+n次，大大减少了循环的次数。

1 packagelist.demo;2

3 importjava.io.Serializable;4 import java.util.*;5 importjava.util.stream.Collectors;6

7 /**

8 * 判断两个集合是否相等9 */

10 public class CheckDiffList implementsSerializable {11 public static voidmain(String[] args) {12 List list = new ArrayList<>();13 List list1 = new ArrayList<>();14 for (int i = 0; i < 1000; i++) {15 list.add("test" +i);16 list1.add("test" + (i * 2));17 }18 System.out.println(checkDiffrent1(list, list1));19 }20

21 /**

22 * 方法323 * 利用HashMap key唯一，value可以重复的特点，把list中各种元素放到hashMap中24 */

25 private static boolean checkDiffrent2(List list, Listlist1) {26 long st =System.nanoTime();27 Map map = new HashMap<>(list.size() +list1.size());28 if (list.size() !=list1.size()) {29 System.out.println("消耗时间为： " + (System.nanoTime() -st));30 return false;31 }32 for(String str : list) {33 map.put(str, 1);34 }35 for(String str : list1) {36 Integer cc =map.get(str);37 if (null !=cc) {38 continue;39 }40 System.out.println("消耗时间为： " + (System.nanoTime() -st));41 return false;42 }43 System.out.println("消耗时间为： " + (System.nanoTime() -st));44 return true;45 }46 }

结果：

消耗时间为： 4243019

false

此方法使用了HashMap中key必须唯一，但是value可以重复的原因。但是HashMap是不同步的，所以线程不安全。

4. 利用MD5加密法来判断两个集合是否相等

1 packagelist.demo;2

3 importjava.io.Serializable;4 import java.util.*;5 importjava.util.stream.Collectors;6

7 /**

8 * 判断两个集合是否相等9 */

10 public class CheckDiffList implementsSerializable {11 public static voidmain(String[] args) {12 List list = new ArrayList<>();13 List list1 = new ArrayList<>();14 for (int i = 0; i < 1000; i++) {15 list.add("test" +i);16 list1.add("test" + (i * 2));17 }18 System.out.println(checkDiffrent1(list, list1));19 }20

21 /**

22 * md5加密法使用23 * 方法424 */

25 private static boolean getDiffrent3(List list, Listlist1) {26 long st =System.nanoTime();27 /**使用Security的md5方法进行加密*/

28 String str =SecureUtil.md5(list.toString());29 String str1 =SecureUtil.md5(list1.toString());30 System.out.println("消耗时间为： " + (System.nanoTime() -st));31 returnstr.equals(str1);32 }33 }

结果：

消耗时间为： 88603223

false

这个方法很新奇吧，是我没有想到的，最好不要用这种方法，如果你在实际项目中使用这种方法，被打死了，请不要找我emmm~

5. 使用Java8的新特性steam流去比较两个数组是否相等

1 packagelist.demo;2

3 importjava.io.Serializable;4 import java.util.*;5 importjava.util.stream.Collectors;6

7 /**

8 * 判断两个集合是否相等9 */

10 public class CheckDiffList implementsSerializable {11 public static voidmain(String[] args) {12 List list = new ArrayList<>();13 List list1 = new ArrayList<>();14 for (int i = 0; i < 1000; i++) {15 list.add("test" +i);16 list1.add("test" + (i * 2));17 }18 System.out.println(checkDiffrent4(list, list1));19 }20

21 /**

22 * 使用stream流去比较两个数组是否相等23 * 方法524 */

25 private static boolean checkDiffrent4(List list, Listlist1) {26 long st =System.nanoTime();27 System.out.println("消耗时间为： " + (System.nanoTime() -st));28 /**先将集合转成stream流进行排序然后转成字符串进行比较*/

29 returnlist.stream().sorted().collect(Collectors.joining())30 .equals(list1.stream().sorted().collect(Collectors.joining()));31 }32 }

结果：

99273484

false

利用了Java8的新特性然后用collect(Collectors.joining())进行比较，虽然比较耗时，但是很好用是真的。

6. 使用list转成字符串进行比较是否相等

1 packagelist.demo;2

3 importjava.io.Serializable;4 import java.util.*;5 importjava.util.stream.Collectors;6

7 /**

8 * 判断两个集合是否相等9 */

10 public class CheckDiffList implementsSerializable {11 public static voidmain(String[] args) {12 List list = new ArrayList<>();13 List list1 = new ArrayList<>();14 for (int i = 0; i < 1000; i++) {15 list.add("test" +i);16 list1.add("test" + (i * 2));17 }18 System.out.println(checkDiffrent4(list, list1));19 }20

21 /**

22 * 使用list自带的sort方法先进性排序，然后转成toString去判断两个集合是否相等23 * 方法624 */

25 private static boolean checkDiffrent5(List list, Listlist1) {26 long st =System.nanoTime();27 System.out.println("消耗时间为： " + (System.nanoTime() -st));28 list.sort(Comparator.comparing(String::hashCode));29 list1.sort(Comparator.comparing(String::hashCode));30 returnlist.toString().equals(list1.toString());31 }32 }

结果：

2570

false

个人感觉先将集合转成字符串，然后进行equal(),进行判断是一个比较优秀的方法， 比起用循环编辑要简洁很多。

二，总结

上面的六种方法的耗时时间依次是checkDiffrent5 < checkDiffrent1 < checkDiffrent2 < checkDiffrent < checkDiffrent3 < checkDiffrent4。所以最好的方法是使用list.sort()方法来进行排序，在用toString进行equal比较。

Security源代码地址：Security地址

附下我写的所有代码：

1 packagelist.demo;2

3 importjava.io.Serializable;4 import java.util.*;5 importjava.util.stream.Collectors;6

7 /**

8 * 判断两个集合是否相等9 */

10 public class CheckDiffList implementsSerializable {11 public static voidmain(String[] args) {12 List list = new ArrayList<>();13 List list1 = new ArrayList<>();14 for (int i = 0; i < 1000; i++) {15 list.add("test" +i);16 list1.add("test" + (i * 2));17 }18 System.out.println(checkDiffrent(list, list1));19 }20

21 /**

22 * 方法一：使用循环遍历23 */

24 private static boolean checkDiffrent(List list, Listlist1) {25 long st =System.nanoTime();26 if(list.size() !=list1.size()) {27 System.out.println("消耗时间：" + (System.nanoTime() -st));28 return false;29 }30 for(String str : list) {31 if(!list1.contains(str)) {32 System.out.println("消耗时间：" + (System.nanoTime() -st));33 return false;34 }35 }36 System.out.println("消耗时间：" + (System.nanoTime() -st));37 return true;38 }39

40 /**

41 * 方法2：利用List的 retainAll的方法进行判断42 */

43 private static boolean checkDiffrent1(List list, Listlist1) {44 long st =System.nanoTime();45 System.out.println("消耗时间为：" + (System.nanoTime() -st));46 return !list.retainAll(list1);47 }48

49 /**

50 * 方法351 * 利用HashMap key唯一，value可以重复的特点，把list中各种元素放到hashMap中52 */

53 private static boolean checkDiffrent2(List list, Listlist1) {54 long st =System.nanoTime();55 Map map = new HashMap<>(list.size() +list1.size());56 if (list.size() !=list1.size()) {57 System.out.println("消耗时间为： " + (System.nanoTime() -st));58 return false;59 }60 for(String str : list) {61 map.put(str, 1);62 }63 for(String str : list1) {64 Integer cc =map.get(str);65 if (null !=cc) {66 continue;67 }68 System.out.println("消耗时间为： " + (System.nanoTime() -st));69 return false;70 }71 System.out.println("消耗时间为： " + (System.nanoTime() -st));72 return true;73 }74

75 /**

76 * md5加密法使用77 * 方法478 */

79 private static boolean getDiffrent3(List list, Listlist1) {80 long st =System.nanoTime();81 /**使用Security的md5方法进行加密*/

82 String str =SecureUtil.md5(list.toString());83 String str1 =SecureUtil.md5(list1.toString());84 System.out.println("消耗时间为： " + (System.nanoTime() -st));85 returnstr.equals(str1);86 }87

88 /**

89 * 使用stream流去比较两个数组是否相等90 * 方法591 */

92 private static boolean checkDiffrent4(List list, Listlist1) {93 long st =System.nanoTime();94 System.out.println("消耗时间为： " + (System.nanoTime() -st));95 /**先将集合转成stream流进行排序然后转成字符串进行比较*/

96 returnlist.stream().sorted().collect(Collectors.joining())97 .equals(list1.stream().sorted().collect(Collectors.joining()));98 }99

100 /**

101 * 使用list自带的sort方法先进性排序，然后转成toString去判断两个集合是否相等102 * 方法6103 */

104 private static boolean checkDiffrent5(List list, Listlist1) {105 long st =System.nanoTime();106 System.out.println("消耗时间为： " + (System.nanoTime() -st));107 list.sort(Comparator.comparing(String::hashCode));108 list1.sort(Comparator.comparing(String::hashCode));109 returnlist.toString().equals(list1.toString());110 }111 }112

原文链接：https://blog.csdn.net/Ecloss/article/details/86154344