Java中判断集合是否相等

        工作中经常会遇到这样一个需要：写一个定时任务每隔5s监听一个接口所发送的数据并存储转发。只需要一个全局变量和一个局部变量即可实现，两者不相同则将数据赋值给全局变量，相同则不变。因此在这里整理了几种判断集合是否相同的方法。

方法一：使用list中的containsAll方法

此方法是判断list2是否是list的子集，即list2包含于list

    //方法一：使用list中的containsAll方法，此方法是判断list2是否是list的子集，即list2包含于list
    public static void compareByContainsAll(List list,List list2){
        boolean flag = false;
        if (list.size()==list2.size()){
                if (list.containsAll(list2)){
                    flag = true;
                }
        }
        System.out.println("方法一："+flag);
    }

方法二：使用for循环遍历+contains方法

  //方法二：使用for循环遍历+contains方法
    public static void compareByFor(List list,List list2){
        boolean flag = false;
        if (list.size()==list2.size()){
            for (String str :list){
                if (!list2.contains(str)){
                    System.out.println(flag);
                    return;
                }
            }
            flag = true;
        }
        System.out.println("方法二："+flag);
    }

方法三：将list先排序再转为String进行比较

（此方法由于涉及同集合内的排序，因此需要该集合内数据类型一致）

    //方法三：将list先排序再转为String进行比较（此方法由于涉及同集合内的排序，因此需要该集合内数据类型一致）
    public static void compareByString(List list,List list2){
        boolean flag = false;
        if (list.size()==list2.size()){
            //使用外部比较器Comparator进行排序，并利用Java8中新添加的特性方法引用来简化代码
            list.sort(Comparator.comparing(String::hashCode));
            //使用集合的sort方法对集合进行排序，本质是将集合转数组，再使用比较器进行排序
            Collections.sort(list2);
            if (list.toString().equals(list2.toString())){
                flag = true;
            }
        }
        System.out.println("方法三："+flag);
    }

如果涉及到引用数据的排序比如里面的一个个对象数据，则需要实现Comparable接口,并重写CompareTo方法,在此方法中指定排序原则

package com.example.demo.utils;


import lombok.Data;


@Data
public class Student  implements Comparable{
    private int id;
    private String name;
    private int age;
    private String sex;

    public Student() {
    }

    public Student(int id, String name, int age, String sex) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    @Override
    public int compareTo(Student o) {
        //按照年龄排序
        int result=this.getAge()-o.getAge();
        return result;
    }
}

 

    //如果涉及到引用数据的排序比如里面的一个个对象数据，则需要实现Comparable接口,并重写CompareTo方法,在此方法中指定排序原则
    public static void compareBySort(){
        ArrayList stus=new ArrayList();
        Student stu1=new Student(1,"张三",23,"男");
        Student stu2=new Student(2,"李四",21,"女");
        Student stu3=new Student(3,"王五",22,"女");
        Student stu4=new Student(4,"赵六",22,"女");

        stus.add(0,stu1);
        stus.add(1,stu2);
        stus.add(2,stu3);
        stus.add(3,stu4);

        System.out.println("原始顺序："+stus);
        Collections.sort(stus);
        System.out.println("排序后："+stus);

    }

方法四：使用list.retainAll()方法

如果集合list2中的元素都在集合list中则list2中的元素不做移除操作，反之如果只要有一个不在list中则会进行移除操作。即：list进行移除操作返回值为：true反之返回值则为false。

    //方法四：使用list.retainAll()方法，此方法本质上是判断list是否有移除操作，如果list2是list的子集则不进行移除返回false，否则返回true
    //如果集合list2中的元素都在集合list中则list2中的元素不做移除操作，反之如果只要有一个不在list中则会进行移除操作。即：list进行移除操作返回值为：true反之返回值则为false。
    public static void compareByRetainAll(List list,List list2){
        boolean flag = false;
        if (list.size()==list2.size()){
            if (!list.retainAll(list2)){
                flag = true;
            }
            System.out.println("方法四："+flag);
        }
    }

方法五：使用MD5加密方式 使用MD5加密方式判断是否相同，这也算是list转String的一个变化，将元素根据加密规则转换为String加密字符串具有唯一性故可以进行判断； 根据唯一性可以想到map中的key也是具有唯一性的，将list中的元素逐个添加进map中作为key然后遍历比较list2中的元素是否都存在其中，不过这个要求list中的元素不重复

方法六：转换为Java8中的新特性steam流再进行排序来进行比较

public static void compareBySteam(List list,List list2){
        boolean flag = false;
        if (list.size() == list2.size()){
            String steam = list.stream().sorted().collect(Collectors.joining());
            String steam2 = (String) list2.stream().sorted().collect(Collectors.joining());
            if (steam.equals(steam2)){
                flag = true;
            }
        }
        System.out.println("方法六："+flag);
    }

工具类compareList完整代码：

package com.example.demo.utils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;


public class compareList {
    //比较两个集合是否相同
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("南京");
        list.add("苏州");
        list.add("常州");
        List list2 = new ArrayList<>();
        list2.add("常州");
        list2.add("苏州");
        list2.add("南京");
        compareByContainsAll(list,list2);

        compareByFor(list,list2);

        compareByString(list,list2);

        compareBySort();

        compareByRetainAll(list,list2);

        compareBySteam(list,list2);

    }

    //方法一：使用list中的containsAll方法，此方法是判断list2是否是list的子集，即list2包含于list
    public static void compareByContainsAll(List list,List list2){
        boolean flag = false;
        if (list.size()==list2.size()){
                if (list.containsAll(list2)){
                    flag = true;
                }
        }
        System.out.println("方法一："+flag);
    }

    //方法二：使用for循环遍历+contains方法
    public static void compareByFor(List list,List list2){
        boolean flag = false;
        if (list.size()==list2.size()){
            for (String str :list){
                if (!list2.contains(str)){
                    System.out.println(flag);
                    return;
                }
            }
            flag = true;
        }
        System.out.println("方法二："+flag);
    }

    //方法三：将list先排序再转为String进行比较（此方法由于涉及同集合内的排序，因此需要该集合内数据类型一致）
    public static void compareByString(List list,List list2){
        boolean flag = false;
        if (list.size()==list2.size()){
            //使用外部比较器Comparator进行排序，并利用Java8中新添加的特性方法引用来简化代码
            list.sort(Comparator.comparing(String::hashCode));
            //使用集合的sort方法对集合进行排序，本质是将集合转数组，再使用比较器进行排序
            Collections.sort(list2);
            if (list.toString().equals(list2.toString())){
                flag = true;
            }
        }
        System.out.println("方法三："+flag);
    }

    //如果涉及到引用数据的排序比如里面的一个个对象数据，则需要实现Comparable接口,并重写CompareTo方法,在此方法中指定排序原则
    public static void compareBySort(){
        ArrayList stus=new ArrayList();
        Student stu1=new Student(1,"张三",23,"男");
        Student stu2=new Student(2,"李四",21,"女");
        Student stu3=new Student(3,"王五",22,"女");
        Student stu4=new Student(4,"赵六",22,"女");

        stus.add(0,stu1);
        stus.add(1,stu2);
        stus.add(2,stu3);
        stus.add(3,stu4);

        System.out.println("原始顺序："+stus);
        Collections.sort(stus);
        System.out.println("排序后："+stus);

    }

    //方法四：使用list.retainAll()方法，此方法本质上是判断list是否有移除操作，如果list2是list的子集则不进行移除返回false，否则返回true
    //如果集合list2中的元素都在集合list中则list2中的元素不做移除操作，反之如果只要有一个不在list中则会进行移除操作。即：list进行移除操作返回值为：true反之返回值则为false。
    public static void compareByRetainAll(List list,List list2){
        boolean flag = false;
        if (list.size()==list2.size()){
            if (!list.retainAll(list2)){
                flag = true;
            }
            System.out.println("方法四："+flag);
        }
    }

    //方法五：使用MD5加密方式判断是否相同，这也算是list转String的一个变化，将元素根据加密规则转换为String加密字符串具有唯一性故可以进行判断
    //根据唯一性可以想到map中的key也是具有唯一性的，将list中的元素逐个添加进map中作为key然后遍历比较list2中的元素是否都存在其中，不过这个要求list中的元素不重复

    //方法六：转换为Java8中的新特性steam流再进行排序来进行比较
    public static void compareBySteam(List list,List list2){
        boolean flag = false;
        if (list.size() == list2.size()){
            String steam = list.stream().sorted().collect(Collectors.joining());
            String steam2 = (String) list2.stream().sorted().collect(Collectors.joining());
            if (steam.equals(steam2)){
                flag = true;
            }
        }
        System.out.println("方法六："+flag);
    }

}