list之间数据对比出相同和不同数据，高效方法

list匹配数据
第一种，最简单的方式遍历两个集合匹配，效率非常低
第二种，使用list的contains方法，内部封装的也是foreach方法，和第一种效率差不多
第三种，使用list的retainAll方法，效率也不算高
第四种，使用map匹配，效率极高，数据量越大越明显
贴上demo

public class ListCompareUtil {


    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        for (int i = 0; i < 3000000; i++) {
            list1.add("test"+i);
            list2.add("test"+i*3);
        }

        mapCompare(list1,list2);

    }

    /**
     * 对比两个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 = Lists.newArrayList();
        List<String> addData = Lists.newArrayList();
        List<String> repeatData = Lists.newArrayList();

        map.entrySet().forEach(stringIntegerEntry -> {
            if(stringIntegerEntry.getValue()==1)
            {
                oldData.add(stringIntegerEntry.getKey());
            }else if(stringIntegerEntry.getValue()==2){
                repeatData.add(stringIntegerEntry.getKey());
            }else{
                addData.add(stringIntegerEntry.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;

    }

    /**
     * 单独获取两个不用集合的数据，高效率
     * @param list1
     * @param list2
     * @return
     */
    public static List<String> getDiffrentList(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        List<String> diff = Lists.newArrayList();
        //优先使用数据量大的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("getDiffrentList total times "+(System.nanoTime()-st));
        return diff;

    }

    /**
     * 对比两个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;
    }

使用此方法后一百万的数据匹配速度在一秒左右，当然也和数据的复杂度有关系，总之比之前的方法快很多。
其中使用java8的lambda的foreach效率明显高于普通的foreach