通用对象比较工具类-GeneralComparator

蛋蛋专属

墨衍会员 · AI 创作全网分发码龄16年

关注

原创最新推荐文章于 2024-10-02 06:13:56 发布 1.7k 阅读 AI 写同款· GEO 优化 ›

由于公司有同步数据的逻辑，涉及到对大批量数据的对比，选择性覆盖，需要对许多不同的数据Beans进行对比。

以前都是针对不同对象重写equals方法，面对大量不同值对象，需要重写很多，比较麻烦，而且重写equals方法大多也只是变量值进行比较。；

有看过别人写的一些，很多都很不理想。。So 一言不合就写个工具类

简单的逻辑

1、判断类型，基本类型、集合、对象分别处理；

2、基本类型直接判断，集合取出后再判断，对象则利用反射获取成员变量，递归取值；

3、没了

也许看起来两个对象判空的时候写的冗长，没有什么与或或者其他会让代码看起来简洁漂亮的写法；

但我觉得这样的朴素的写法可以让比较次数降到最低；

入口：传入两个值对象，并对属性进行分类

/**
     * 同为空/都不为空：true
     */
    public static boolean compareObject(Object head, Object tail) {
        if (head == null) {
            if (tail != null) {
                return false;
            } else {
                return true;
            }
        } else {
            if (tail == null) {
                return false;
            }
        }
        if (head.getClass() != tail.getClass()) {
            return false;
        }
        if (head.equals(tail)) {
            return true;
        }
        if (head.getClass() == String.class) {
            return head.equals(tail);
        } else if (head.getClass() == Integer.class) {
            return (int) head == (int) tail;
        } else if (head.getClass() == Boolean.class) {
            return (boolean) head == (boolean) tail;
        } else if (head.getClass() == Long.class) {
            return (long) head == (long) tail;
        } else if (head.getClass() == Double.class) {
            return (double) head == (double) tail;
        } else if (List.class.isAssignableFrom(head.getClass())) {
            return compareList((List) head, (List) tail);
        } else if (Map.class.isAssignableFrom(head.getClass())) {
            return compareMap(head, tail);
        }
        Field[] fields = head.getClass().getDeclaredFields();
        for (Field field : fields) {
//            Class cls = field.getType();
            Object o1 = getFieldValue(head, field);
            Object o2 = getFieldValue(tail, field);
            boolean result = compareObject(o1, o2);
            if (!result) {
                return false;
            }
            continue;
        }
        return true;
    }

获取field值

    private static Object getFieldValue(Object bean, Field field) {
        try {
            field.setAccessible(true);
            Object value = field.get(bean);
            return value;
        } catch (IllegalAccessException ace) {
            ace.printStackTrace();
            return null;
        }
    }

比较List ：List中仍可存储类型的数据，所以使用compareObject方法来比较

private static boolean compareList(List head, List tail) {
        if (head == null) {
            if (tail == null || tail.isEmpty()) {
                return true;
            } else {
                return false;
            }
        } else {
            if (tail == null) {
                return head.isEmpty();
            }
        }
        if (head.isEmpty() && tail.isEmpty()) {
            return true;
        }
        if (head.size() != tail.size()) {
            return false;
        }
        for (int i = 0; i < head.size(); i++) {
            boolean result = compareObject(head.get(i), tail.get(i));
            if (!result) {
                return false;
            }
        }
        return true;
    }

比较Map：Map中没有存储其他类型，均为基本类型，所以就偷懒直接equals比较了

 private static boolean compareMap(Object head, Object tail) {
        if (head == null) {
            if (tail == null) {
                return true;
            } else {
                boolean isEmpty = ((HashMap) tail).isEmpty();
                if (isEmpty) {
                    return true;
                } else {
                    return false;
                }
            }
        } else {
            if (tail == null) {
                boolean isEmpty = ((HashMap) head).isEmpty();
                if (isEmpty) {
                    return true;
                } else {
                    return false;
                }
            }
        }
        HashMap srcMap = (HashMap) head;
        HashMap tarMap = (HashMap) tail;
        if (srcMap.keySet().isEmpty() && tarMap.keySet().isEmpty()) {
            return true;
        }
        if (srcMap.keySet().size() != tarMap.keySet().size()) {
            return false;
        }
        for (String key : srcMap.keySet()) {
            if (!tarMap.containsKey(key)) {
                return false;
            }
            Object vSrc = srcMap.get(key);
            Object vTar = tarMap.get(key);
            if (!vSrc.equals(vTar)) {
                return false;
            }
        }
        return true;
    }

到这以及可以满足绝大部分的数据类型了，而且不论你数据多复杂，嵌套有多深。

没有short、char等，因为项目中没有，集合使用List、Map，其他也没有使用，所有就没有加入；

需要注意：

Object : true : Null && Null

Set : true : Null && Null , Empty && Empty , Empty && Null

下面是测试用，基本覆盖每个分支

public class TestEquals {
    public static void main(String args[]) {
        School school1 = getTestBean(0);
        School school2 = getTestBean(1);
        long start = System.currentTimeMillis();
        boolean result = GeneralComparator.compareObject(school1, school2);
        long end = System.currentTimeMillis();
        System.out.print(result + " --- " + (end - start));
    }

    private static School getTestBean(int index) {
        School school1 = new School();
        school1.id = 3;
        if (index == 1) {
//            school1.id = 4;
        }
        ArrayList teacher1 = new ArrayList<>();
        Teacher t1 = new Teacher();
        t1.setTeakcherTitle("ma");
        if (index == 1) {
//            t1.setTeakcherTitle("mas");
        }
        if (index == 1) {
//            teacher1.add(t1);
        }
        teacher1.add(t1);
        school1.teacherList = teacher1;

        ArrayList list = new ArrayList();
        list.add("list_1");
        list.add("list_2");
        list.add("list_4");
//        if (index == 1) {
//            list.add("list_4");
//        }
        school1.setSchsoolId(list);
//
        HashMap map1 = new HashMap();
        map1.put("ma2", "2");
        map1.put("ma3", "22");
        if (index == 1) {
//            map1.put("ma3", "2d2");
        }
        school1.map = map1;

        ArrayList> arrayMap = new ArrayList<>();
        arrayMap.add(map1);
        if (index == 1) {
//            map1.put("ma2d","s2");
//            arrayMap.add(map1);
        }
        school1.arrayMap = arrayMap;
        return school1;
    }
}

class School {
    public int id;

    private ArrayList schsoolId;

    public HashMap map;
    public ArrayList teacherList;

    public ArrayList> arrayMap;

    public ArrayList getSchsoolId() {
        return schsoolId;
    }

    public void setSchsoolId(ArrayList schsoolId) {
        this.schsoolId = schsoolId;
    }
}

class Teacher {

    public String teakcherTitle;


    public String getTeakcherTitle() {
        return teakcherTitle;
    }

    public void setTeakcherTitle(String teakcherTitle) {
        this.teakcherTitle = teakcherTitle;
    }
}

收录于