java实现对象对比工具类

最新推荐文章于 2024-04-29 12:05:59 发布
最新推荐文章于 2024-04-29 12:05:59 发布
阅读量1.6k 收藏 5
点赞数 4
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34497272/article/details/114024059
版权

目录

说明

此工具类对比两个Java对象相同属性以及不同属性

对比示例/结果

对比示例,可以对比实体，实体中嵌套实体，实体中嵌套集合等

{
	"id":"",
	"username":"",
	"age":0,
	"address":[
		{
			"province":"",
			"city":"",
			"disrtict":""
		}
	],
	"details":{
		"sex":"",
		"mobile":""
	}
}

一下对比结果(更多测试可使用下方源码进行测试):

全部对比：
相同列==>[id, age, address_city, address_id, details_sex]
不同列==>[username, address_province, address_disrtict, details_mobile]

默认过滤策略(id存在于默认策略，所以被过滤掉了)：
相同列==>[age, address_city, details_sex]
不同列==>[username, address_province, address_disrtict, details_mobile]

指定列对比(只对比username、province)：
相同列==>[]
不同列==>[username, address_province]

指定列不对比(不对比username、province)：
相同列==>[id, age, address_city, address_id, details_sex]
不同列==>[address_disrtict, details_mobile]

指定列不对比+默认过滤策略(不对比username、province+默认过滤策略)：
相同列==>[age, address_city, details_sex]
不同列==>[address_disrtict, details_mobile]

指定列不对比+默认过滤策略(不对比username、address+默认过滤策略)：
相同列==>[age, details_sex]
不同列==>[details_mobile]

源码

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @description: 对象对比工具类
 * @author: guo-coffee
 */
public class ComparedUtils {

    /**
     * 示例说明(更多事例可查看main方法)：
     * 对比json:{"id":"tom","username":"tom","age":18,"address":[{"province":"上海市"},{"city":"上海市"},{"disrtict":"静安区"},{"id":"静安区"}]}
     *
     * 示例一：调用compareJson(JSONObject json1, JSONObject json2, List<String> compareList)
     *      假设指定username、address_province两列对比，compareList中需要放入username、address、address_province。
     *      解释：若compareList集合中不放address，则表示整个address均不会进入比较，所以json嵌套多层时，将父key也需要放入compareList中
     *
     * 事例二：调用compareJson(JSONObject json1, JSONObject json2, List<String> filterList,boolean flag)
     *      1、假设指定username、address_province两列不进行对比，filterList中需要放入username、address_province即可
     *      2、假设整个address均不进行比对，filterList中需要放入username、address即可
     */

    /**
     * 默认过滤列名(由于项目会继承一些基类[例如ID、操作人、操作时间、修改人、修改时间等]，基类中属性对比无任何意义，可以过滤掉)
     */
    private static final List<String> DEFAULT_FILTER_COLUMNS = Arrays.asList("id","createDate","updateDate","createPersonId","createPersonName","updatePersonId","updatePersonName","concurrencyVersion","delflag","tendId");

    /**
     * json嵌套多层时，父子key拼接字符
     */
    private static final String SEPARATOR = "_";

    /**
     * 两个对象对比(全部列对比)
     * @param json1 对比对象,必传
     * @param json2 对比对象,必传
     * @return
     */
    public static Map<String,List<String>> compareJson(JSONObject json1, JSONObject json2){
        return compareJson(json1,json2,false);
    }

    /**
     * 两个对象对比
     * @param json1 对比对象,必传
     * @param json2 对比对象,必传
     * @param flag 是否采用默认过滤策略-->true:采用 false：不采用
     * @return
     */
    public static Map<String,List<String>> compareJson(JSONObject json1, JSONObject json2, boolean flag){
        return compareJson(json1,json2,null,null,flag,null,null,new ArrayList<>(),new ArrayList<>());
    }

    /**
     * 两个对象对比
     * @param json1 对比对象,必传
     * @param json2 对比对象,必传
     * @param compareList 要比较的列
     * @return
     */
    public static Map<String,List<String>> compareJson(JSONObject json1, JSONObject json2, List<String> compareList){
        return compareJson(json1,json2,compareList,null,false,null,null,new ArrayList<>(),new ArrayList<>());
    }

    /**
     * 两个对象对比
     * @param json1 对比对象,必传
     * @param json2 对比对象,必传
     * @param filterList 不需要比较的列
     * @param flag 是否需要过滤默认列-->true:需要 false：不需要
     * @return
     */
    public static Map<String,List<String>> compareJson(JSONObject json1, JSONObject json2, List<String> filterList,boolean flag){
        return compareJson(json1,json2,null,filterList,flag,null,null,new ArrayList<>(),new ArrayList<>());
    }

    /**
     * 父类递归
     * @param json1 对比对象
     * @param json2 对比对象
     * @param compareList 要比较的列
     * @param filterList 不需要比较的列
     * @param flag 是否需要过滤默认列-->true:需要 false：不需要
     * @param key 当前比较的key,默认传null,主要用于递归时使用
     * @param parentKey 拼接父类key,避免json嵌套多层时，返回key一致问题,默认传null，主要用于递归时使用
     * @param equalsList 相同列,默认传new ArrayList<String>(),主要用于递归使用
     * @param diffList 不同列,默认传传new ArrayList<String>(),主要用于递归使用
     * @return
     */
    private static Map<String,List<String>> compareJson(JSONObject json1, JSONObject json2,List<String> compareList,List<String> filterList,boolean flag, String key,String parentKey,List<String> equalsList,List<String> diffList) {
        Map<String,List<String>> map = new HashMap<>(2);
        Iterator i = json1.keySet().iterator();
        while (i.hasNext()) {
            // 当前比较的列
            key = (String) i.next();
            // 嵌套JSONArray时，当前key拼接父类key
            String str = StringUtils.isBlank(parentKey) ? key : parentKey + SEPARATOR + key;
            if (
                // 比较全部
                    ((compareList == null || compareList.isEmpty()) && (filterList == null || filterList.isEmpty()) && !flag)
                            // 在【要比较的列】中
                            || (compareList != null && !compareList.isEmpty() && compareList.contains(str))
                            // 不默认过滤 并且 不在【不需要比较的列】中
                            || (filterList != null && !filterList.isEmpty() && !filterList.contains(str) && !flag)
                            // 过滤默认 并且 不在默认列 并且 不在【不需要比较的列】中
                            || (filterList != null && !filterList.isEmpty() && !filterList.contains(str) && flag && !DEFAULT_FILTER_COLUMNS.contains(key))
                            // 只过滤默认
                            || ((filterList == null || filterList.isEmpty()) && flag && !DEFAULT_FILTER_COLUMNS.contains(key))
            ) {
                /**
                 * 调用-->Object
                 */
                if (json1.get(key) != null && json2.get(key) != null){
                    compareJson(json1.get(key), json2.get(key), compareList, filterList, flag, key, parentKey, equalsList, diffList);
                } else if (json1.get(key) == null && json2.get(key) == null) {
                    equalsList.add(key);
                } else {
                    diffList.add(key);
                }
            }
        }
        // 嵌套JSONArray时，只要有一列不一致，均为不一致
        equalsList.removeAll(diffList);
        // 嵌套JSONArray时，存在列明重复情况，集合去重处理
        map.put("equalsList",equalsList.stream().distinct().collect(Collectors.toList()));
        map.put("diffList",diffList.stream().distinct().collect(Collectors.toList()));
        return map;
    }

    /**
     * Object
     */
    private static void compareJson(Object json1, Object json2,List<String> compareList,List<String> filterList,boolean flag, String key,String parentKey,List<String> equalsList,List<String> diffList) {
        if (json1 instanceof JSONObject) {
            // 拼接父类key,避免json嵌套多层时，返回key一致问题
            parentKey = StringUtils.isBlank(parentKey)?key:parentKey+SEPARATOR+key;
            /**
             * 调用-->父类递归
             */
            compareJson((JSONObject) json1, (JSONObject) json2, compareList,filterList, flag, key ,parentKey,equalsList,diffList);
        } else if (json1 instanceof JSONArray) {
            /**
             * 调用-->jsonArray
             */
            compareJson((JSONArray) json1, (JSONArray) json2, compareList, filterList, flag, key ,parentKey,equalsList,diffList);
        } else if (json1 instanceof String) {
            try {
                String json1ToStr = json1.toString();
                String json2ToStr = json2.toString();
                /**
                 * 调用-->json字符串
                 */
                compareJson(json1ToStr, json2ToStr, key , parentKey,equalsList,diffList);
            } catch (Exception e) {
                System.out.println("转换发生异常 key:" + key);
                e.printStackTrace();
            }
        } else {
            /**
             * 调用-->json字符串
             */
            compareJson(json1.toString(), json2.toString(), key , parentKey,equalsList,diffList);
        }
    }

    /**
     * json字符串
     */
    private static void compareJson(String str1, String str2, String key,String parentKey,List<String> equalsList,List<String> diffList) {
        // 拼接父类key,避免json嵌套多层时，返回key一致问题
        parentKey = StringUtils.isBlank(parentKey)?key:parentKey+SEPARATOR+key;
        if (!str1.equals(str2)) {
            // 不一致的key
            diffList.add(parentKey);
        } else {
            // 一致
            equalsList.add(parentKey);
        }
    }

    /**
     * jsonArray
     */
    private static void compareJson(JSONArray json1, JSONArray json2,List<String> compareList,List<String> filterList,boolean flag, String key, String parentKey,List<String> equalsList,List<String> diffList) {
        // 拼接父类key,避免json嵌套多层时，返回key一致问题
        if (json1 != null && json2 != null && json1.size() == json2.size()) {
            Iterator i1 = json1.iterator();
            Iterator i2 = json2.iterator();
            while (i1.hasNext()) {
                /**
                 * 调用-->Object
                 */
                compareJson(i1.next(), i2.next(),compareList,filterList, flag, key , parentKey , equalsList,diffList);
            }
        } else {
            // JSONArray只要有一个为null则会不一致
            diffList.add(parentKey);
        }
    }

    /**
     * 测试方法
     * @param args
     */
    public static void main(String[] args) {
        String st1 = "{\"id\":\"tom\",\"username\":\"tom\",\"age\":18,\"address\":[{\"province\":\"上海市\"},{\"city\":\"上海市\"},{\"disrtict\":\"静安区\"},{\"id\":\"静安区\"}],\"details\":{\"sex\":\"男\",\"mobile\":\"13811112222\"}}";
        String st2 = "{\"id\":\"tom\",\"username\":\"tom1\",\"age\":18,\"address\":[{\"province\":\"上海市1\"},{\"city\":\"上海市\"},{\"disrtict\":\"静安区1\"},{\"id\":\"静安区\"}],\"details\":{\"sex\":\"男\",\"mobile\":\"13811113333\"}}";

        JSONObject jsonObject1 = JSONObject.fromObject(st1);
        JSONObject jsonObject2 = JSONObject.fromObject(st2);

        System.out.println("全部对比：");
        Map<String,List<String>> map = compareJson(jsonObject1, jsonObject2);
        System.out.println("相同列==>"+map.get("equalsList"));
        System.out.println("不同列==>"+map.get("diffList"));

        System.out.println("默认过滤策略(id存在于默认策略，所以被过滤掉了)：");
        Map<String,List<String>> map1 = compareJson(jsonObject1, jsonObject2,true);
        System.out.println("相同列==>"+map1.get("equalsList"));
        System.out.println("不同列==>"+map1.get("diffList"));

        System.out.println("指定列对比(只对比username、province)：");
        // 注：要比较province，必须将address也放入集合中
        Map<String,List<String>> map2 = compareJson(jsonObject1, jsonObject2,Arrays.asList("username","address","address_province"));
        System.out.println("相同列==>"+map2.get("equalsList"));
        System.out.println("不同列==>"+map2.get("diffList"));

        System.out.println("指定列不对比(不对比username、province)：");
        Map<String,List<String>> map3 = compareJson(jsonObject1, jsonObject2,Arrays.asList("username","address_province"),false);
        System.out.println("相同列==>"+map3.get("equalsList"));
        System.out.println("不同列==>"+map3.get("diffList"));

        System.out.println("指定列不对比+默认过滤策略(不对比username、province+默认过滤策略)：");
        Map<String,List<String>> map4 = compareJson(jsonObject1, jsonObject2,Arrays.asList("username","address_province"),true);
        System.out.println("相同列==>"+map4.get("equalsList"));
        System.out.println("不同列==>"+map4.get("diffList"));

        System.out.println("指定列不对比+默认过滤策略(不对比username、address+默认过滤策略)：");
        Map<String,List<String>> map5 = compareJson(jsonObject1, jsonObject2,Arrays.asList("username","address"),true);
        System.out.println("相同列==>"+map5.get("equalsList"));
        System.out.println("不同列==>"+map5.get("diffList"));
    }
}
郭咖啡
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java比较两段json不同工具类（两个同一类型的java对象比较也推荐转成JSON再进行比较）
pipi_7的博客
04-12 5753
import java.util.Iterator;import net.sf.json.JSONArray; import net.sf.json.JSONObject;public class JsonDiff { // private static StringBuilder sb = new StringBuilder(); @SuppressWarnings("unchecked"
Java反射之Bean修改更新属性值等工具类
土鳖&only29
01-28 4667
package com.bocean.util; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.Date; import java.util.Map; import com.bocean.entity.healthManage.HealthIndex; import com.b
java对象对比工具 自定义注解对象属性对比 支持递归调用 无三方包纯原生工具 简单实用 反射来对比对象的差异 增强字典说明
CC学java
08-11 648
java对象对比工具 纯原生工具 注解反射
java 实体类字段对比工具类
weixin_39093006的博客
05-10 370
实体类字段检测工具类。
Java工具类：CompareUtils（比较对象字段值变化）
最新发布
2401_84103045的博客
04-29 156
并且逻辑性也高度重合，这时的代码就会显得十分的臃肿，那么，这个时候，我们就不妨考虑写一个通用的方法了。那么，我们既然要记录每次保存前后的字段值变化，则肯定需要进行字段值的比较。（2）可以给字段进行一个备注，因为我们看到的最终内容，应该是一个中文名称；设想下，如果随着业务的拓展，当我们的 2 个字段增加到多个字段的时候。（3）一个对象中，可以忽略某些字段进行比较，只要我需要的字段进行比较。（1）可以接收任何对象的比较，但比较的对象应该是同个对象；
java object diff_Fast-object-diff 对象对比工具
weixin_33268464的博客
02-19 1580
Fast-object-diff我们经常要打一些日志记录,然而手动记录是比价困难的,也是不方便的,非常需要一个对比java相同对象内不同值的方法Fast-object-diff就这样诞生.支持基本对象 和 Collection集合日期可按照自定义格式输出注解方法输出日志,配置简单忽略不需要的值提供基础方法 generateDiff 和扩展方法集合中可根据某个key进行对应diff记录,方便乱序中使...
实用小工具：Java实体类对比、Json对比、字符串动态拼接等功能
09-15
对比两个JSON对象，可以使用Jackson库的ObjectMapper或者Gson库的fromJson方法将JSON字符串转换为Java对象，然后进行对象间的比较。也可以使用专门的JSON对比工具，如json-unit，它提供了一套API来比较两个JSON对象...
java对象实体类属性字段对比变化过程
11-13
Java对象实体类属性字段对比变化过程是指在一个Java对象实体类的生命周期中，其属性字段的变化情况。这种变化过程通常涉及到对象的创建、使用和销毁等阶段。 在对象的创建阶段，Java对象实体类会根据预设的属性字段...
Java常用工具类包包含各种常用开发工具
01-04
"Java常用工具类包"是一个集合，它包含了多种针对不同场景的工具类，如文件操作、文本处理、对象转换等。下面将详细介绍这些工具类的主要功能及其应用场景。 1. **文件对比**： - Java中的`java.io.File`类可以...
Java Adapter 适配器模式（类适配器，对象适配器）优缺点对比
08-31
适配器模式主要有两类实现方式：类适配器模式和对象适配器模式。 类适配器模式是通过适配器类继承被适配者类并实现目标接口的方式进行适配。在Java中，由于单继承的限制，类适配器只能服务于一个被适配者类。例如，...
Java对象属性数据比较，返回变化数据
05-16
总结起来，`Java对象属性数据比较，返回变化数据`这个主题涉及到Java的面向对象特性，包括对象、属性、以及反射API的使用。`ObjectCompareUtil`工具类提供了一种通用的方式来比较两个对象的属性，而`...
JAVA对象以及数据的工具类
03-22
工具类 基础的类型 对象 数据的工具，进行判断或者进行操作
Java Objects工具类的学习
m0_62335629的博客
11-14 527
当我们遇到一些类对象是null空指针时，我们代码又要调用类方法，就会出现错误，此时我们一般的解决方法就是用if-else结构判断是不是空指针，然而我们用Objects工具类解决这个问题更为简单。5.如果重写了 比较属性值 所以这边a 和 c的属性值一样 但地址值不一样 比较的结果依旧是false。1.equals方法的底层会判断里面的第一个类是否有null 如果有一个null 直接返回false。3.此时第一个类a是persons类型，所以最终还是会调用persons中的equals方法。
[Java] - Java对象的比较,equals,Comparable,Comparator
weixin_65941860的博客
06-01 186
Java比较方法，equals，Comparator，Comparable
Java反射-实体属性遍历比较数据前后是否发生变动
博渊的博客
09-16 1626
对于数据有修改前和修改后 那么如何判断修改数据是否已发生改变而且取到修改的数据呢？-----利用反射 大大降低代码冗余度 1、关于反射 下面就直接上工具类代码： public class JudgeAttributesIsEqualedUtil { /** * @param beginModel 旧数据model * @param afterModel 新数据mod...
Java对象属性拷贝工具对比分析
靖节先生的博客
03-26 4872
Java对象属性拷贝工具详解1. 对象属性拷贝概述2. 对象属性拷贝工具2.1 拷贝工具对比2.2 拷贝工具验证3. 实现案例3.1 集合对象拷贝验证3.2 对象拷贝验证 1. 对象属性拷贝概述 在开发中经常遇到对象属性拷贝功能，而对象属性拷贝方式很多，比如手动set赋值，虽然麻烦，但是性能是最好的，其次MapStruct也是通过预编译完成，效率等同手动set，但是这两种相较于一些工具类稍微麻烦一些，一些常用的工具类方便简单，而且效率也相对不错，比如SpringBeanUtils，CgLib，hutoolB
java 比较两个实体对象的值差异
cwx_csdn的博客
07-05 2242
import com.alibaba.fastjson.JSONObject; import org.apache.commons.beanutils.PropertyUtils; import java.beans.BeanInfo; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.InvocationTargetException; import java.l.
java8判断两个集合中是否有相同的元素
ywj776199845的专栏
08-18 4472
比如这样一个需求，现有一个Teacher对象集合和一个Student对象集合，需要查出两个集合中姓名相同的记录该怎么办呢，通常我们想到的肯定是用双层for循环来做，如果用java8新特性lambda表达式怎么做呢？废话不多说，直接看示例: 新建老师类: package demo; import lombok.AllArgsConstructor; import lombok.Data; /** * 老师类 */ @Data @AllArgsConstructor public class Te
java 对比对象字段 工具类
04-27
Java中比较对象字段的常用工具类是 `Objects` 类。它提供了一些静态方法，例如： - `equals(Object a, Object b)`：比较两个对象是否相等，避免了 `null` 值的判断； - `hash(Object... values)`：生成一组对象的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值