Java中判断集合是否相等的几种方法详解

更新时间：2023年08月25日 10:32:20 作者：流苏打

这篇文章主要介绍了Java中判断集合是否相等的几种方法详解,在平时的开发中,可能会遇到需要判断两个集合是否相等的需求,那么本文就来详细讲解一下几种实现方法,需要的朋友可以参考下

方法一：使用list中的containsAll方法
方法二：使用for循环遍历+contains方法
方法三：将list先排序再转为String进行比较
方法四：使用list.retainAll()方法
方法五：使用MD5加密方式
方法六：转换为Java8中的新特性steam流再进行排序来进行比较

工具类compareList完整代码：

Java中判断集合是否相等

工作中经常会遇到这样一个需要：写一个定时任务每隔5s监听一个接口所发送的数据并存储转发。

只需要一个全局变量和一个局部变量即可实现，两者不相同则将数据赋值给全局变量，相同则不变。

因此在这里整理了几种判断集合是否相同的方法。

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

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

    //方法一：使用list中的containsAll方法，此方法是判断list2是否是list的子集，即list2包含于list
    public static void compareByContainsAll(List<String> 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<String> 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<String> 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;
/**
 * @author zhangqianwei
 * @date 2021/9/7 17:25
 */
@Data
public class Student  implements Comparable<Student>{
    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<Student> stus=new ArrayList<Student>();
        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<String> 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<String> 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;
/**
 * @author zhangqianwei
 * @date 2021/10/8 11:46
 */
public class compareList {
    //比较两个集合是否相同
    public static void main(String[] args) {
        List<String> 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<String> 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<String> 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<String> 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<Student> stus=new ArrayList<Student>();
        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<String> 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<String> 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);
    }
}

到此这篇关于Java中判断集合是否相等的几种方法详解的文章就介绍到这了,更多相关Java中判断集合是否相等内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

SpringBoot项目设置断点debug调试无效忽略web.xml问题的解决
这篇文章主要介绍了SpringBoot项目设置断点debug调试无效忽略web.xml问题的解决，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-08-08
简单了解JavaCAS的相关知识原理
这篇文章主要介绍了简单了解JavaCAS的相关知识,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2019-11-11
Kotlin常用函数let,with,run,apply用法与区别案例详解
这篇文章主要介绍了Kotlin常用函数let,with,run,apply用法与区别案例详解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
2021-09-09
spring启动加载程序的几种方法介绍
本篇文章主要介绍了spring启动加载程序的几种方法介绍，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-04-04
SpringBoot系列教程之防重放与操作幂等
同一条数据被用户点击了多次,导致数据冗余,需要防止弱网络等环境下的重复点击,下面这篇文章主要给大家介绍了关于SpringBoot系列教程之防重放与操作幂等的相关资料,需要的朋友可以参考下
2022-04-04
SpringBoot3-yaml文件配置方式
这篇文章主要介绍了SpringBoot3-yaml文件配置方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-03-03
关于Idea卡在Resolving Maven dependencies的解决方案
本文详细介绍了关于Idea卡在Resolving Maven dependencies的解决方案,文中通过图文结合的形式给大家介绍的非常详细,对大家解决问题有一定的帮助,需要的朋友可以参考下
2024-02-02
解决Spring AOP拦截抽象类(父类)中方法失效问题
这篇文章主要介绍了解决Spring AOP拦截抽象类(父类)中方法失效问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-11-11
spring boot配置druid连接池的完整步骤
这篇文章主要给大家介绍了关于spring boot配置druid连接池的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-01-01
java项目怎么集成stable diffusion图文生成算法
在开发Java项目过程中,我们经常需要使用消息传递来实现不同组件之间的通信,Stable Diffusion是一种基于消息传递的实时通信解决方案,使用Java调用外部服务（如Python脚本或API服务）,这些服务运行Stable Diffusion模型,本文将介绍如何将Stable Diffusion集成到Java项目
2024-07-07