//方法一：使用list中的containsAll方法，此方法是判斷l(xiāng)ist2是否是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循環(huán)遍歷+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先排序再轉(zhuǎn)為String進(jìn)行比較（此方法由于涉及同集合內(nèi)的排序，因此需要該集合內(nèi)數(shù)據(jù)類型一致）
    public static void compareByString(List<String> list,List list2){
        boolean flag = false;
        if (list.size()==list2.size()){
            //使用外部比較器Comparator進(jìn)行排序，并利用Java8中新添加的特性方法引用來簡化代碼
            list.sort(Comparator.comparing(String::hashCode));
            //使用集合的sort方法對集合進(jìn)行排序，本質(zhì)是將集合轉(zhuǎn)數(shù)組，再使用比較器進(jìn)行排序
            Collections.sort(list2);
            if (list.toString().equals(list2.toString())){
                flag = true;
            }
        }
        System.out.println("方法三："+flag);
    }

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;
    }
}

    //如果涉及到引用數(shù)據(jù)的排序比如里面的一個(gè)個(gè)對象數(shù)據(jù)，則需要實(shí)現(xiàn)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()方法，此方法本質(zhì)上是判斷l(xiāng)ist是否有移除操作，如果list2是list的子集則不進(jìn)行移除返回false，否則返回true
    //如果集合list2中的元素都在集合list中則list2中的元素不做移除操作，反之如果只要有一個(gè)不在list中則會進(jìn)行移除操作。即：list進(jìn)行移除操作返回值為：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);
        }
    }

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);
    }

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 {
    //比較兩個(gè)集合是否相同
    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方法，此方法是判斷l(xiāng)ist2是否是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循環(huán)遍歷+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先排序再轉(zhuǎn)為String進(jìn)行比較（此方法由于涉及同集合內(nèi)的排序，因此需要該集合內(nèi)數(shù)據(jù)類型一致）
    public static void compareByString(List<String> list,List list2){
        boolean flag = false;
        if (list.size()==list2.size()){
            //使用外部比較器Comparator進(jìn)行排序，并利用Java8中新添加的特性方法引用來簡化代碼
            list.sort(Comparator.comparing(String::hashCode));
            //使用集合的sort方法對集合進(jìn)行排序，本質(zhì)是將集合轉(zhuǎn)數(shù)組，再使用比較器進(jìn)行排序
            Collections.sort(list2);
            if (list.toString().equals(list2.toString())){
                flag = true;
            }
        }
        System.out.println("方法三："+flag);
    }
    //如果涉及到引用數(shù)據(jù)的排序比如里面的一個(gè)個(gè)對象數(shù)據(jù)，則需要實(shí)現(xiàn)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()方法，此方法本質(zhì)上是判斷l(xiāng)ist是否有移除操作，如果list2是list的子集則不進(jìn)行移除返回false，否則返回true
    //如果集合list2中的元素都在集合list中則list2中的元素不做移除操作，反之如果只要有一個(gè)不在list中則會進(jìn)行移除操作。即：list進(jìn)行移除操作返回值為：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轉(zhuǎn)String的一個(gè)變化，將元素根據(jù)加密規(guī)則轉(zhuǎn)換為String加密字符串具有唯一性故可以進(jìn)行判斷
    //根據(jù)唯一性可以想到map中的key也是具有唯一性的，將list中的元素逐個(gè)添加進(jìn)map中作為key然后遍歷比較list2中的元素是否都存在其中，不過這個(gè)要求list中的元素不重復(fù)
    //方法六：轉(zhuǎn)換為Java8中的新特性steam流再進(jìn)行排序來進(jìn)行比較
    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);
    }
}