Java如何判断两个集合的元素是否完全相等

2021-05-21 10:58:03 阅读：212 来源： 互联网

标签：相等 Java list1 list System st 集合 List nanoTime

一，实现

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

package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
* 判断两个集合是否相等
*/
public class CheckDiffList implements Serializable {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
List<String> list1 = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add("test" + i);
list1.add("test" + (i * 2));
}
System.out.println(checkDiffrent(list, list1));
}

/**
* 方法一：使用循环遍历
*/
private static boolean checkDiffrent(List<String> list, List<String> list1) {
long st = System.nanoTime();
if(list.size() != list1.size()) {
System.out.println("消耗时间：" + (System.nanoTime() - st));
return false;
}
for(String str : list) {
if(!list1.contains(str)) {
System.out.println("消耗时间：" + (System.nanoTime() - st));
return false;
}
}
System.out.println("消耗时间：" + (System.nanoTime() - st));
return true;
}
}

返回结果为：

消耗时间为： 16657988
false

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

package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
* 判断两个集合是否相等
*/
public class CheckDiffList implements Serializable {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
List<String> list1 = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add("test" + i);
list1.add("test" + (i * 2));
}
System.out.println(checkDiffrent1(list, list1));
}

/**
* 方法2：利用List的 retainAll的方法进行判断
*/
private static boolean checkDiffrent1(List<String> list, List<String> list1) {
long st = System.nanoTime();
System.out.println("消耗时间为：" + (System.nanoTime() - st));
return !list.retainAll(list1);
}

}

返回结果为：

消耗时间为：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次，大大减少了循环的次数。

package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
* 判断两个集合是否相等
*/
public class CheckDiffList implements Serializable {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
List<String> list1 = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add("test" + i);
list1.add("test" + (i * 2));
}
System.out.println(checkDiffrent1(list, list1));
}

/**
* 方法3
* 利用HashMap key唯一，value可以重复的特点，把list中各种元素放到hashMap中
*/
private static boolean checkDiffrent2(List<String> list, List<String> list1) {
long st = System.nanoTime();
Map<String, Integer> map = new HashMap<>(list.size() + list1.size());
if (list.size() != list1.size()) {
System.out.println("消耗时间为： " + (System.nanoTime() - st));
return false;
}
for (String str : list) {
map.put(str, 1);
}
for (String str : list1) {
Integer cc = map.get(str);
if (null != cc) {
continue;
}
System.out.println("消耗时间为： " + (System.nanoTime() - st));
return false;
}
System.out.println("消耗时间为： " + (System.nanoTime() - st));
return true;
}
}

结果：

消耗时间为： 4243019
false

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

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

package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
* 判断两个集合是否相等
*/
public class CheckDiffList implements Serializable {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
List<String> list1 = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add("test" + i);
list1.add("test" + (i * 2));
}
System.out.println(checkDiffrent1(list, list1));
}

/**
* md5加密法使用
* 方法4
*/
private static boolean getDiffrent3(List<String> list, List<String> list1) {
long st = System.nanoTime();
/** 使用Security的md5方法进行加密 */
String str = SecureUtil.md5(list.toString());
String str1 = SecureUtil.md5(list1.toString());
System.out.println("消耗时间为： " + (System.nanoTime() - st));
return str.equals(str1);
}
}

结果：

消耗时间为： 88603223
false

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

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

package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
* 判断两个集合是否相等
*/
public class CheckDiffList implements Serializable {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
List<String> list1 = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add("test" + i);
list1.add("test" + (i * 2));
}
System.out.println(checkDiffrent4(list, list1));
}

/**
* 使用stream流去比较两个数组是否相等
* 方法5
*/
private static boolean checkDiffrent4(List<String> list, List<String> list1) {
long st = System.nanoTime();
System.out.println("消耗时间为： " + (System.nanoTime() - st));
/** 先将集合转成stream流进行排序然后转成字符串进行比较 */
return list.stream().sorted().collect(Collectors.joining())
.equals(list1.stream().sorted().collect(Collectors.joining()));
}
}

结果：

99273484
false

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

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

package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
* 判断两个集合是否相等
*/
public class CheckDiffList implements Serializable {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
List<String> list1 = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add("test" + i);
list1.add("test" + (i * 2));
}
System.out.println(checkDiffrent4(list, list1));
}

/**
* 使用list自带的sort方法先进性排序，然后转成toString去判断两个集合是否相等
* 方法6
*/
private static boolean checkDiffrent5(List<String> list, List<String> list1) {
long st = System.nanoTime();
System.out.println("消耗时间为： " + (System.nanoTime() - st));
list.sort(Comparator.comparing(String::hashCode));
list1.sort(Comparator.comparing(String::hashCode));
return list.toString().equals(list1.toString());
}
}

结果：

2570
false

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

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

附下我写的所有代码：

package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
* 判断两个集合是否相等
*/
public class CheckDiffList implements Serializable {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
List<String> list1 = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add("test" + i);
list1.add("test" + (i * 2));
}
System.out.println(checkDiffrent(list, list1));
}

/**
* 方法一：使用循环遍历
*/
private static boolean checkDiffrent(List<String> list, List<String> list1) {
long st = System.nanoTime();
if(list.size() != list1.size()) {
System.out.println("消耗时间：" + (System.nanoTime() - st));
return false;
}
for(String str : list) {
if(!list1.contains(str)) {
System.out.println("消耗时间：" + (System.nanoTime() - st));
return false;
}
}
System.out.println("消耗时间：" + (System.nanoTime() - st));
return true;
}

/**
* 方法2：利用List的 retainAll的方法进行判断
*/
private static boolean checkDiffrent1(List<String> list, List<String> list1) {
long st = System.nanoTime();
System.out.println("消耗时间为：" + (System.nanoTime() - st));
return !list.retainAll(list1);
}

/**
* 方法3
* 利用HashMap key唯一，value可以重复的特点，把list中各种元素放到hashMap中
*/
private static boolean checkDiffrent2(List<String> list, List<String> list1) {
long st = System.nanoTime();
Map<String, Integer> map = new HashMap<>(list.size() + list1.size());
if (list.size() != list1.size()) {
System.out.println("消耗时间为： " + (System.nanoTime() - st));
return false;
}
for (String str : list) {
map.put(str, 1);
}
for (String str : list1) {
Integer cc = map.get(str);
if (null != cc) {
continue;
}
System.out.println("消耗时间为： " + (System.nanoTime() - st));
return false;
}
System.out.println("消耗时间为： " + (System.nanoTime() - st));
return true;
}

/**
* md5加密法使用
* 方法4
*/
private static boolean getDiffrent3(List<String> list, List<String> list1) {
long st = System.nanoTime();
/** 使用Security的md5方法进行加密 */
String str = SecureUtil.md5(list.toString());
String str1 = SecureUtil.md5(list1.toString());
System.out.println("消耗时间为： " + (System.nanoTime() - st));
return str.equals(str1);
}

/**
* 使用stream流去比较两个数组是否相等
* 方法5
*/
private static boolean checkDiffrent4(List<String> list, List<String> list1) {
long st = System.nanoTime();
System.out.println("消耗时间为： " + (System.nanoTime() - st));
/** 先将集合转成stream流进行排序然后转成字符串进行比较 */
return list.stream().sorted().collect(Collectors.joining())
.equals(list1.stream().sorted().collect(Collectors.joining()));
}

/**
* 使用list自带的sort方法先进性排序，然后转成toString去判断两个集合是否相等
* 方法6
*/
private static boolean checkDiffrent5(List<String> list, List<String> list1) {
long st = System.nanoTime();
System.out.println("消耗时间为： " + (System.nanoTime() - st));
list.sort(Comparator.comparing(String::hashCode));
list1.sort(Comparator.comparing(String::hashCode));
return list.toString().equals(list1.toString());
}
}

标签：相等,Java,list1,list,System,st,集合,List,nanoTime
来源： https://blog.csdn.net/zhangleiyes123/article/details/117111960

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Java如何判断两个集合的元素是否完全相等

一，实现