Java集合---06---List集合--数据对比

List集合的交集（retainAll）、并集（removeAll，addAll）、差集（removeAll）

交集 retainAll();

    @Test
    public void test01(){
        ArrayList<String> listA = new ArrayList<>();
        ArrayList<String> listB= new ArrayList<>();

        listA.add("a");listA.add("b");listA.add("c");
        listB.add("b");listB.add("c");listB.add("e");listB.add("f");

        listA.retainAll(listB);

        listA.forEach(e-> System.out.println(e));
    }

差集 removeAll()

    @Test
    public void test02(){
        ArrayList<String> listA = new ArrayList<>();
        ArrayList<String> listB= new ArrayList<>();

        listA.add("a");listA.add("b");listA.add("c");
        listB.add("b");listB.add("c");listB.add("e");listB.add("f");

        listA.removeAll(listB);

        listA.forEach(e-> System.out.println(e));
    }

并集 且去重

1. listA.removeAll(listB);
2. listA.addAll(listB);

   @Test
    public void test03(){
        ArrayList<String> listA = new ArrayList<>();
        ArrayList<String> listB= new ArrayList<>();

        listA.add("a");listA.add("b");listA.add("c");
        listB.add("b");listB.add("c");listB.add("e");listB.add("f");

        listA.removeAll(listB);
        listA.addAll(listB);

        listA.forEach(e-> System.out.println(e));
    }

for循环比较list集合

单层循环找出相同数据.

   @Test
    public void test02() {

        List<String> listA = new ArrayList<>();
        List<String> listB = new ArrayList<>();

        for (int i = 0; i < 6;i++) {
            listA.add(i + "");              //0,1,2,3,4,5
            listB.add(i + 1 + "");          //1,2,3,4,5,6
        }
        
        List<String> listC = getSameListByLoop(listA,listB);
        listC.forEach(e-> System.out.print(e+" "));
    }

   //循环比较相同的数据
 private List<String> getSameListByLoop(List<String> listA, List<String> listB) {
        long begin = System.nanoTime();//纳秒
        List<String> listC = new ArrayList<String>();
        //遍历判断
        for(String str :listA){
            if(listB.contains(str)){
                listC.add(str);
            }
        }
        
        long end = System.nanoTime();
        System.out.println("take  " + (end-begin) + " time ");
        return listC;
    }

双重for循环 找出2个list集合不同的数据:

   @Test
    public void test02() {

        List<String> listA = new ArrayList<>();
        List<String> listB = new ArrayList<>();

        for (int i = 0; i < 6;i++) {
            listA.add(i + "");              //0,1,2,3,4,5
            listB.add(i + 1 + "");          //1,2,3,4,5,6
        }

        List<String> listC = getDifferListByLoop(listA,listB);

        listC.forEach(e-> System.out.print(e+" "));

    }

    private List<String> getDifferListByLoop(List<String> listA, List<String> listB) {
        long begin = System.nanoTime();//纳秒

        List<String> listC = new ArrayList<String>();
        for(String str :listA){
            if(!listB.contains(str)){
                listC.add(str);
            }
        }

        for(String str :listB) {
            if (!listA.contains(str)) {
                listC.add(str);
            }
        }

       long end = System.nanoTime();
        System.out.println("take  " + (end-begin) + " time ");
        return listC;
    }

使用map匹配，效率极高，数据量越大越明显

获取两个集合之间的不同数据

    @Test
    public void test01() {

        List<String> listA = new ArrayList<>();
        List<String> listB = new ArrayList<>();

        for (int i = 0; i < 10000;i++) {
            listA.add(i + "");              //0,1,2,3,4,5.....9999
            listB.add(i + 1 + "");          //1,2,3,4,5,6....10000
        }

        List<String> listC = getDiffrentList(listA, listB);

        listC.forEach(e-> System.out.print(e+" "));
    }

  /**
     * 单独获取两个不用集合的数据，高效率
     * @param list1
     * @param list2
     * @return
     */
    public static List<String> getDiffrentList(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        List<String> diff = new ArrayList<>();
        //优先使用数据量大的list，提高效率
        List<String> maxList = list1;
        List<String> minList = list2;
        if(list2.size()>list1.size())
        {
            maxList = list2;
            minList = list1;
        }
        Map<String,Integer> map = new HashMap<>(maxList.size());
        for (String string : maxList) {
            map.put(string, 1);
        }

        for (String string : minList) {
            if(map.get(string)!=null)
            {
                map.put(string, 2);
                continue;
            }
            diff.add(string);
        }
        for(Map.Entry<String, Integer> entry:map.entrySet())
        {
            if(entry.getValue()==1)
            {
                diff.add(entry.getKey());
            }
        }
        System.out.println("take "+(System.nanoTime()-st));
        return diff;

    }

10000条数据,map对比

10000条数据,for循环对比

map方法对比 1,旧数据;2,重复的数据;3,新增的数据

  @Test
    public void test03() {

        List<String> listA = new ArrayList<>();
        List<String> listB = new ArrayList<>();

        for (int i = 0; i < 10000;i++) {
            listA.add(i + "");              //0,1,2,3,4,5
            listB.add(i + 1 + "");          //1,2,3,4,5,6
        }

        //flag 1,旧数据;2,重复的数据;3,新增的数据
        List<String> listC = getCompareList(listA, listB,3);

        listC.forEach(e-> System.out.print(e+" "));
    }

flag 1,旧数据;2,重复的数据;3,新增的数据

    /**
     * 对比两个list取出差并和的集合
     * @param oldList 旧集合
     * @param newList 新集合
     * @param flag 1,旧数据;2,重复的数据;3,新增的数据
     * @return
     */
    public static List<String> getCompareList(List<String> oldList, List<String> newList,Integer flag){
        long st = System.nanoTime();

        Map<String,Integer> map = mapCompare(oldList,newList);
        List<String> result ;

        List<String> oldData = new ArrayList<>();
        List<String> addData = new ArrayList<>();
        List<String> repeatData = new ArrayList<>();

        map.entrySet().forEach(Entry -> {
            if(Entry.getValue()==1)
            {
                oldData.add(Entry.getKey());
            }else if(Entry.getValue()==2){
                repeatData.add(Entry.getKey());
            }else{
                addData.add(Entry.getKey());
            }
        });

        if(flag.equals(1)){
            result = oldData;
        }else if(flag.equals(2)){
            result = repeatData;
        }else{
            result = addData;
        }
        System.out.println("getCompareList "+(System.nanoTime()-st));
        return result;

    }

 /**
     * 对比两个list，返回list并集
     * @param oldList
     * @param newList
     * @return value为1,旧数据;2,重复的数据;3,新增的数据
     */
    public static Map<String,Integer> mapCompare(List<String> oldList, List<String> newList) {
        long st = System.nanoTime();

        //若知道两个list大小区别较大，以大的list优先处理
        Map<String,Integer> map = new HashMap<>(oldList.size());

        //lambda for循环数据量越大，效率越高，小数据建议用普通for循环
        oldList.forEach(s -> map.put(s, 1) );

        newList.forEach(s -> {
            if(map.get(s)!=null)
            {
                //相同的数据
                map.put(s, 2);
            }else {
                //若只是比较不同数据，不需要此步骤，浪费资源
                map.put(s,3);
            }
        });

        System.out.println("mapCompare total times "+(System.nanoTime()-st));
        return map;
    }