Java 快速進行對象集合數據比對，For循環嵌套不應該成爲你的選擇

在項目中，我們常常用到兩個集合的數據比對，找到其中不同的數據，在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 string : list1) {
            map.put(string, 1);
        }
        // 遍歷List2，在Map中查找List2的元素，找到則計數+1；未找到則放入map，計數1
        for (User user : list2) {
            Integer count = map.get(string);
            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:
            }
        }