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

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/Ecloss/article/details/86154344

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


    博主最近在工作的时候遇到了这样的一个需求,前端的页面提交一个表单数据,传到后台,我需要做判断这个表单和已有的表单数据是否有完全相同的,如果有相同的数据,那么就返回一个false,这一个表单不能被保存,如果不同,就可以保存到数据库中。

一,实现

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比较。
Security源代码地址:Security地址

附下我写的所有代码:

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());
    }
 }
展开阅读全文

没有更多推荐了,返回首页