在项目中，我们常常用到两个集合的数据比对，找到其中不同的数据，在Android里面基本上数据量也不会太大，往往大家都是直接用for循环嵌套搞定，大家有没有想过当数据量很大的时候，使用for循环嵌套找出不一样的对象，需要多久。本文将为大家介绍一下如果进行高效的数据比对，以及一些特殊场景的应用，收藏起来，你会用到的。

说明

测试耗时会因为设备性能不同而不同，以下为测试设备的硬件

准备阶段

创建对象模型，对象模型越复杂，越慢

    public static class User{
        private int id;
        private String name;

        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

通过循环插入大量假数据

    List<User> list1 = new ArrayList<User>();
    List<User> list2 = new ArrayList<User>();
    for (int i = 0; i < 100000; i++) {
        list1.add(new User(i,"test"+i));
    }
    for (int i = 0; i < 500000; i++) {
        list2.add(new User(i,"test"+i));
    }

方法一

两层遍历查找，遍历次数为list1.size()*list2.size()，很耗时

private static List<User> getDiffrent1(List<User> list1, List<User> list2) {
        // diff 存放不同的元素
        List<User> diff = new ArrayList<User>();
        // 开始查找的时间，用于计时
        long start = System.currentTimeMillis();
        for (User user : list1) {
            if (!list2.contains(user)) {
                diff.add(user);
            }
        }
        // 计时
        System.out.println("方法1 耗时：" + (System.currentTimeMillis() - start) + " 毫秒");
        return diff;
    }

方法二

原理和方法一一致，只是写法比较简单还是很耗时

private static List<User> getDiffrent2(List<User> list1, List<User> list2) {
        long start = System.currentTimeMillis();
        list1.retainAll(list2);// 返回值是boolean
        System.out.println("方法2 耗时：" + (System.currentTimeMillis() - start) + " 毫秒");
        return list1;
    }

方法三

用Map存放List1和List2的元素作为key，value为其在List1和List2中出现的次数

出现次数为1的即为不同元素，查找次数为list1.size() + list2.size()，较方法1和2，是极大简化

    
    private static List<User> getDiffrent3(List<User> list1, List<User> list2) {
        List<User> diff = new ArrayList<User>();
        long start = System.currentTimeMillis();
        Map<User, Integer> map = new HashMap<User, Integer>(list1.size() + list2.size());
        // 将List1元素放入Map，计数1
        for (User user : list1) {
            map.put(user, 1);
        }
        // 遍历List2，在Map中查找List2的元素，找到则计数+1；未找到则放入map，计数1
        for (User user : list2) {
            Integer count = map.get(user);
            if (count != null) {
                map.put(user, ++count);// 此处可优化，减少put次数，
                continue;
            }
            map.put(user, 1);
        }
        for (Map.Entry<User, Integer> entry : map.entrySet()) {
            if (entry.getValue() == 1) {
                diff.add(entry.getKey());
            }
        }
        System.out.println("方法3 耗时：" + (System.currentTimeMillis() - start) + " 毫秒");
        return diff;
    }

各方法耗时

如果在手机上处理这样的数据不是用的异步的话手机就会ANR了，当然实际上很少会在手机上有这么大的数据，但是当数据是几千，数据模型比较复杂的时候，for循环嵌套的速度比你们想像的慢

特殊需求

List1和list2 两个集合对比,找到完全相同的，list1存在list2不存在的，list2存在list1不存在的，id一致其他属性不同的！

或许很陌生，感觉从来没用遇到过这样的需求，收藏，或许哪天你就遇到了

例子：两个数据库对比，找到需要插入、更新、删除的值

创建比对模型

    public class ComparisonModel {
    private ContentValues values;
    //type  1相同  2更新  3插入  4删除
    private int type;

    public ComparisonModel(ContentValues values, int type) {
        this.values = values;
        this.type = type;
    }

    public ContentValues getValues() {
        return values;
    }

    public void setValues(ContentValues values) {
        this.values = values;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }
}

比对代码

Map<String, MapModel> map = new HashMap<String, MapModel>(wechatList.size() + list.size());

        for (ContentValues value : list) {
            map.put(value.get(key).toString(), new MapModel(value, 4));
        }
        for (ContentValues value : wechatList) {
            MapModel model = map.get(value.get(key).toString());
            if (model == null) {
                map.put(value.get(key).toString(), new MapModel(value, 3));
            } else {
                if (model.getValues().equals(value)) {
                    map.put(value.get(key).toString(), new MapModel(value, 1));
                } else {
                    map.put(value.get(key).toString(), new MapModel(value, 2));
                }
            }

        }

        for (Map.Entry<String, MapModel> entry : map.entrySet()) {

            switch (entry.getValue().getType()) {
                case 1://相同
                
                    break;
                case 2://更新
                    
                    break;
                case 3://插入
                    
                    break;
                case 4://删除
                    
                    break;
                default:
            }
        }