集合使用retainAll找到重复项

集合A的泛型是集合B，集合B泛型是自定义对象，判定新增的集合C在集合A中是否有重复的集合。

判断是否包含使用retainAll，如果A.retainAll(C)，A中有数据，表示有重复数据

1. 如果集合泛型是自定义对象，使用retainAll()，最终调用的方法是自定义对象的equals方法。比较的是属性值是否相同

   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       Stu stu = (Stu) o;
       return Objects.equals(name, stu.name) &&
           Objects.equals(age, stu.age) &&
           Objects.equals(createTime, stu.createTime);
   }
   

2. 如果集合泛型是集合，使用retainAll()，方法调用的ArrayList是AbstractList中的equals方法。

   这里要注意两个集合添加的元素要一一对应。如果拿到的数据不是一一对应，那比较的结果就是false。在判断新增的C中里面的数据是乱序的。如果有一种方法，我们对请求添加的元素进行排好序，对已经存在的所有列表中的元素都进行排序就可以解决。这时候就用到了重写hashcode，可以使用Comparator对元素的hashcode进行排序，因为重写后的hashcode值是通过属性值计算得到的，如果两个对象即使是不同的对象（new出来的），但是属性值是相同的，那么它们的hashcode值也是一样的，这样就满足了我们的业务要求
   

   该equals方法比较的是集合长度是否相同，并且两个集合一一对应的元素是否相同。

   public boolean equals(Object o) {
       if (o == this)
           return true;
       if (!(o instanceof List))
           return false;
   
       ListIterator<E> e1 = listIterator();
       ListIterator<?> e2 = ((List<?>) o).listIterator();
       while (e1.hasNext() && e2.hasNext()) {
           E o1 = e1.next();
           Object o2 = e2.next();
           if (!(o1==null ? o2==null : o1.equals(o2)))
               return false;
       }
       return !(e1.hasNext() || e2.hasNext());
   }
   

   案例一

   import java.util.LinkedList;
   import java.util.List;
   
   /**
    * @Description:
    * @Author party-abu
    * @Date 2021/12/26 20:51
    */
   public class TestSimpleList {
   
       public static void main(String[] args) {
   
           List<Stu> numListInnerOne = new LinkedList<>();
           Stu stu01 = new Stu();
           stu01.setAge(19);
           stu01.setName("张三");
   
           Stu stu03 = new Stu();
           stu03.setAge(33);
           stu03.setName("张三1");
           numListInnerOne.add(stu01);
           numListInnerOne.add(stu03);
   
           System.out.println("=========================");
   
           List<Stu> numListInnerTwo = new LinkedList<>();
           Stu stu02 = new Stu();
           stu02.setAge(19);
           stu02.setName("张三");
   
           Stu stu04 = new Stu();
           stu04.setAge(33);
           stu04.setName("张三1");
           numListInnerTwo.add(stu02);
           numListInnerTwo.add(stu04);
   
           // 取交集
           numListInnerOne.retainAll(numListInnerTwo);
           System.out.println(numListInnerOne.size() > 0 ? "包含" : "不包含");
   
       }
   }
   

   案例二

   import java.util.*;
   
   /**
    * @Description:
    * @Author party-abu
    * @Date 2021/12/26 20:51
    */
   public class TestComplex {
   
       public static void main(String[] args) {
   
           List<List<Stu>> numListOut = new LinkedList<>();
   
           List<Stu> numListInnerOne = new LinkedList<>();
           Stu stu01 = new Stu();
           stu01.setAge(19);
           stu01.setName("张三");
           numListInnerOne.add(stu01);
   
           Stu stu02 = new Stu();
           stu02.setAge(22);
           stu02.setName("小明");
           numListInnerOne.add(stu02);
   
           numListInnerOne.sort(Comparator.comparingInt(Stu::hashCode));
   
           List<Stu> numListInnerTwo = new LinkedList<>();
           Stu stu03 = new Stu();
           stu03.setAge(20);
           stu03.setName("李四");
           numListInnerTwo.add(stu03);
   
           numListOut.add(numListInnerOne);
           numListOut.add(numListInnerTwo);
   
           System.out.println("================================================");
   
           List<Stu> numListInnerRequest = new LinkedList<>();
           Stu stu04 = new Stu();
           stu04.setAge(19);
           stu04.setName("张三");
   
           Stu stu05 = new Stu();
           stu05.setAge(22);
           stu05.setName("小明");
   
           numListInnerRequest.add(stu04);
           numListInnerRequest.add(stu05);
           // 不进行排序，调换上边两个stu04、stu05顺序结果会不一样
           numListInnerRequest.sort(Comparator.comparingInt(Stu::hashCode));
   
           List<List<Stu>> listList = new LinkedList<>();
           listList.add(numListInnerRequest);
   
           // 取交集
           numListOut.retainAll(listList);
           System.out.println(numListOut.size() > 0 ? "包含" : "不包含");
   
       }
   }