简单的对象属性值对比方法

最新推荐文章于 2023-10-03 15:58:53 发布
最新推荐文章于 2023-10-03 15:58:53 发布
阅读量2.9k 收藏
点赞数
分类专栏： 设计模式&&工具思想 文章标签： .net 对象 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kameleon2013/article/details/50710115
版权

这段时间，小编忙于修改自己所负责的系统中的一个调用接口，这个接口用来调用另外一个系统的API，对方API中的参数进行了升级，在原有对象的属性基础之上，增加了一些新的属性，但是由于对新接口的调用处于测试阶段，需要保证旧的接口仍可用，并且新的接口中传递的对象和旧的接口中传递的对象之间共同的参数值需要一致，但是小编看了看，新旧对象的属性个数都在50+，一个一个对比不是不行，尽管这样做确实提高了准确率，但是这样又回到了原始搬砖的漫漫长路上，因此小编认为这种情况下应该写一个通用的方法，用来对比两个对象之间的属性值。

其实这里和对象的深度复制和浅度复制差不多（这里可以参考小编另外一篇博客，不过使用JAVA实现的：点击打开链接），不过这里小编实现的是对比两个对象之间基础属性的值是否一致，或者是String类型的值是否一致，如果对象中包含复杂对象，则这个方法并不适用，不过有机会可以将此方法改为递归的方式调用，这个小编以后可以想办法实现，这里就先放一个用.NET C#写的这个工具方法吧！

首先声明两个基础类：

 

    public class ClassA
    {
        public int a { set; get; }
        public int? b { set; get; }
        public string c { set; get; }
        public float d { set; get; }
    }
    public class ClassB
    {
        public int a { set; get; }
        public int b { set; get; }
        public string c { set; get; }
        public double d { set; get; }
        public decimal e { set; get; }
    }


这两个类中，有4个属性的名字是一样的，在这4个属性之中，有两个属性的类型是不一样的，在小编的业务中是这样定义的：

 

新旧两个对象：

1.同样的属性名对应的属性值应该是一样的，但是不排除这两个属性的类型不同，但是这两个属性的值仍应该一样

   如：一个属性是int型，另外一个是String型，但是这两个属性名若是一样的，若其中都是有值得，则里面的内容应该是一样的

   如：一个属性是int型，另外一个是String型，但是这两个属性名若是一样的，若其中均没值，如int = 0，String = null，这两个也算值相同

2.由于目前需要保证旧的接口可用，新的接口传递的参数尽管比旧的接口多，但是仍需要包含旧对象中所有的值，一个也不能少

 

这里小编主要用到了.NET 的反射机制，通过这种方式获取了两个对象的public属性：

通过这种方式获取属性的名字和属性值：

从而进行对象之间基础属性或者String类型的属性值是否一样！

 

基于以上的需求，小编写了如下的工具方法：

 

public static bool ContrastTwoObjects(Object a, Object b, bool basic, out string logInfo)
        {
            logInfo = "";
            StringBuilder sb = new StringBuilder();
            int count = 0;

            if (a == null || b == null)
            {
                sb.Append(String.Format("第一个对象是否为NULL：{0} ", a == null ? "是" : "否"));
                sb.Append(String.Format("第二个对象是否为NULL：{0} ", b == null ? "是" : "否"));
                logInfo = sb.ToString();
                return false;
            }
            else
            {
                PropertyInfo[] propertiesA = a.GetType().GetProperties(
                    BindingFlags.Instance | BindingFlags.Public);
                PropertyInfo[] propertiesB = b.GetType().GetProperties(
                    BindingFlags.Instance | BindingFlags.Public);

                if (propertiesA.Length == 0 || propertiesB.Length == 0)
                {
                    sb.Append(String.Format("第一个对象的属性数量是否为0：{0} ", propertiesA.Length == 0 ? "是" : "否"));
                    sb.Append(String.Format("第二个对象的属性数量是否为0：{0} ", propertiesB.Length == 0 ? "是" : "否"));
                    logInfo = sb.ToString();
                    return false;
                }
                else
                {
                    //若basic为true，则以第一个传进来的参数为准
                    //比对第一个参数中的属性是否都出现在第二个参数的属性中，并且这些属性值都是一样的
                    if (basic)
                    {
                        sb.AppendLine("以对象A为基准，比对两个对象共同的属性值是否一致 ");
                        foreach (PropertyInfo itemA in propertiesA)
                        {
                            string nameA = itemA.Name;
                            object valueA = itemA.GetValue(a, null);

                            #region 判断A中的属性是否出现在B中，并且属性的值相等

                            bool findFlag = false;//判断是否有属性名称相同的属性
                            bool valueFlag = false;//判断属性名称相同的属性的属性值是否一样

                            foreach (PropertyInfo itemB in propertiesB)
                            {
                                string nameB = itemB.Name;
                                object valueB = itemB.GetValue(b, null);

                                if (nameA.Equals(nameB))
                                {
                                    findFlag = true;

                                    //这里只能判断字符串类型的值是否一样
                                    if ((itemA.PropertyType.IsValueType && itemB.PropertyType.FullName == "System.String")
                                             || (itemB.PropertyType.IsValueType && itemA.PropertyType.FullName == "System.String")
                                             || (itemA.PropertyType.FullName == "System.String" && itemB.PropertyType.FullName == "System.String"))
                                    {
                                        if ((valueA == null || valueA.ToString() == String.Empty)
                                             && (valueB == null || valueB.ToString() == String.Empty))
                                        {
                                            valueFlag = true;
                                            break;
                                        }
                                        else
                                        {
                                            if (valueA != null && valueB != null)
                                            {
                                                string s1 = valueA.ToString();
                                                string s2 = valueB.ToString();

                                                if (s1.Equals(s2))
                                                {
                                                    valueFlag = true;
                                                    break;
                                                }
                                                else
                                                {
                                                    sb.Append(
                                                       String.Format("第一个对象和第二个对象同样名称的属性值不同，属性名称：{0}，属性值1：{1}，属性值2：{2} ",
                                                            nameA, s1, s2));
                                                    valueFlag = false;
                                                    break;
                                                }
                                            }
                                            else
                                            {
                                                sb.Append(
                                                       String.Format("第一个对象和第二个对象同样名称的属性值不同，属性名称：{0}，属性值1：{1}，属性值2：{2} ",
                                                        nameA, valueA ?? "null", valueB ?? "null"));
                                                valueFlag = false;
                                                break;
                                            }
                                        }
                                    }

                                    //这里只能判断值类型的值是否一样
                                    if (itemA.PropertyType.IsValueType && itemB.PropertyType.IsValueType)
                                    {
                                        //鉴于两个对象同样属性名称不用属性类型的情况，这里将两个基础属性值全部转成字符串类型，从而对比其内容是否一致
                                        string s1 = valueA.ToString();
                                        string s2 = valueB.ToString();
                                        if (s1.Equals(s2))
                                        {
                                            valueFlag = true;
                                            break;
                                        }
                                        else
                                        {
                                            sb.Append(
                                               String.Format("第一个对象和第二个对象同样名称的属性值不同，属性名称：{0}，属性值1：{1}，属性值2：{2} ",
                                                    nameA, s1, s2));
                                            valueFlag = false;
                                            break;
                                        }
                                    }
                                }
                            }

                            #endregion

                            if (!findFlag)
                            {
                                sb.Append(String.Format("未能找到在第二个对象中找到属性值：{0} ", nameA));
                                logInfo = sb.ToString();
                                return false;
                            }
                            else
                            {
                                findFlag = false;
                            }

                            if (!valueFlag)
                            {
                                logInfo = sb.ToString();
                                return false;
                            }
                            else
                            {
                                count++;
                                valueFlag = false;
                            }
                        }

                        sb.AppendLine(String.Format("属性值一致，供对比属性值数：{0}", count.ToString()));
                        logInfo = sb.ToString();
                        return true;
                    }

                    //若Basic为false，则只比对两个对象中共同的属性，不以第一个对象为准
                    else
                    {
                        sb.AppendLine("不以A对象为准，比对两个对象共同的属性值是否一致 ");
                        foreach (PropertyInfo itemA in propertiesA)
                        {
                            string nameA = itemA.Name;
                            object valueA = itemA.GetValue(a, null);

                            #region 判断A中的属性是否出现在B中，并且属性的值相等

                            bool valueFlag = false;//判断属性名称相同的属性的属性值是否一样
                            foreach (PropertyInfo itemB in propertiesB)
                            {
                                string nameB = itemB.Name;
                                object valueB = itemB.GetValue(b, null);
                                if (nameA.Equals(nameB))
                                {
                                    //这里只能判断字符串类型的值是否一样
                                    if ((itemA.PropertyType.IsValueType && itemB.PropertyType.FullName == "System.String")
                                             || (itemB.PropertyType.IsValueType && itemA.PropertyType.FullName == "System.String"))
                                    {
                                        if ((valueA == null || valueA.ToString() == String.Empty)
                                             && (valueB == null || valueB.ToString() == String.Empty))
                                        {
                                            valueFlag = true;
                                            break;
                                        }
                                        else
                                        {
                                            if (valueA != null && valueB != null)
                                            {
                                                string s1 = valueA.ToString();
                                                string s2 = valueB.ToString();
                                                if (s1.Equals(s2))
                                                {
                                                    valueFlag = true;
                                                    break;
                                                }
                                                else
                                                {
                                                    sb.Append(
                                                       String.Format("第一个对象和第二个对象同样名称的属性值不同，属性名称：{0}，属性值1：{1}，属性值2：{2} ",
                                                            nameA, s1, s2));
                                                    valueFlag = false;
                                                    break;
                                                }
                                            }
                                            else
                                            {
                                                sb.Append(
                                                       String.Format("第一个对象和第二个对象同样名称的属性值不同，属性名称：{0}，属性值1：{1}，属性值2：{2} ",
                                                        nameA, valueA ?? "null", valueB ?? "null"));
                                                valueFlag = false;
                                                break;
                                            }
                                        }
                                    }

                                    //这里只能判断值类型的值是否一样
                                    if (itemA.PropertyType.IsValueType && itemB.PropertyType.IsValueType)
                                    {
                                        //鉴于两个对象同样属性名称不用属性类型的情况，这里将两个基础属性值全部转成字符串类型，从而对比其内容是否一致
                                        string s1 = valueA.ToString();
                                        string s2 = valueB.ToString();
                                        if (s1.Equals(s2))
                                        {
                                            valueFlag = true;
                                            break;
                                        }
                                        else
                                        {
                                            sb.Append(
                                                String.Format("第一个对象和第二个对象同样名称的属性值不同，属性名称：{0}，属性值1：{1}，属性值2：{2} ",
                                                    nameA, s1, s2));
                                            valueFlag = false;
                                            break;
                                        }
                                    }
                                }
                            }

                            #endregion

                            if (!valueFlag)
                            {
                                logInfo = sb.ToString();
                                return false;
                            }
                            else
                            {
                                count++;
                                valueFlag = false;
                            }
                        }

                        sb.AppendLine(String.Format("属性值一致，供对比属性值数：{0}", count.ToString()));
                        logInfo = sb.ToString();
                        return true;
                    }
                }
            }

            logInfo = sb.ToString();
            return false;
        }

 

 

这里大家可以看到，返回值用来表明这两个对象是否是一样的，并且其中的一个参数是out类型的，用来像外界输出具体的对比情况，并且小编还提供了另外一个参数，这里有两种情况：

1.以第一个对象为基准，要求第二个对象中需要包含第一个对象中所有的属性名，并且这些属性值需要一致

2.只比对两个对象中共同属性名的属性值

 

以下是调用的方式和输出的结果：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ReflactionTest
{
    public class Program
    {
        static void Main(string[] args)
        {
            ClassA a = new ClassA();
            ClassB b = new ClassB();

            a.a = 1;
            a.b = 2;
            a.c = "c";
            a.d = 0.1f;

            b.a = 1;
            b.b = 2;
            b.d = 0.1d;
            b.e = 0.01m; 

            string info = "";
            bool flag = Tool.ContrastTwoObjects(a,b,true,out info);

            Console.WriteLine(String.Format("对比结果：{0}，结果信息：{1}", flag, info));
        }
    }
}


这是结果：

 

 

这里小编未必能测试到所有的CASE，如果有有缘人和小编遇到了一样的需求，也请多多尝试小编提供的方法，大家共同进步

 

小编的邮箱是：kameleon@126.com

大家有问题多多交流哈~~~

 

大大大猫头鹰
关注
专栏目录
对象属性值对比(支持复杂对象)
学海无涯,我用JAVA
08-02 372
对比两个bean中的内容,返回其中属性的值不一致的完整信息,包括: 属性 新值 旧值找了很多工具类都没有找到,然后自己动手封装了一个,希望能给后来人带来参考;虽说是自己封装的,但实际也是站在巨人的肩膀,基于 hutool jdk 等工具类。
对比两个对象属性值的不同
weixin_44772980的博客
04-26 953
差异值对象 import lombok.Data; @Data public class DifferentFieldDTO { private String fieldName;//字段名 private String fieldText;//字段中文名 private String oldValue;//新值 private String newValue;//旧值 private String status;//add,update,delete
java对象属性对比_java两个对象属性比较
weixin_39797912的博客
02-13 1868
两个对象进行比较相等，有两种做法：1,情况一：当仅仅只是判断两个对象是否相等时，只需重写equals()方法即可。这里就不用说明2.情况二：当除了情况一之外，还需知道是那个属性不同，那么就需要采用类反射，具体代码如下：public static void main(String[] args) {A a = new A();a.setUserName("a");a.setPassword("p")...
比较两个对象属性及属性值
weixin_30920091的博客
09-12 470
import java.lang.reflect.Method; private static Object getFieldValue(Object thisClass, String fieldName) { Object value = new Object(); Method method = nu...
比较对象值
weixin_34268310的博客
06-02 108
比较对象值 1可以将对象类型作为一个普通的数据类型使用。 2使用比较操作符时，需要提供类型的映射函数，类型函数必须返回和源列相同的数据类型，并且不同执行提交和回滚操作。 3比较操作符 =，<,>,<=,>=,in,like,between 测试数据 --创建对象类型头 create or replace type class4...
关于比较两个对象属性
tiantiantbtb的博客
08-11 254
泛型主要为了将对象转成相应的类型,可以使用Object t1,t2为需要比较的两对象 返回t是一个新的对象 然后 t1还是原对象 新生成的t为有差异的对象。
java的对象的属性值_java对象属性值对比
weixin_29848477的博客
02-18 1423
这个工具类有一下四个方法：1：对比一个对象的属性和map中的属性的值是否相等，相等返回true,不相等返回false;2：对比两个对象的属性是否相等，相等返回true,不相等返回false;3:对比两个对象的不同，返回值为map,key为对象中属性不相等的字段，value为原始对象的值4：对比两个对象的不同，返回值为map,changekey取得修改的字段，sourceValue取得字段修改前的值...
Java对象属性数据比较，返回变化数据
05-16
在Java编程中，比较对象属性的数据变化是一项常见的需求，特别是在数据跟踪、日志记录或版本控制等场景。本文将深入探讨如何实现这个功能，并基于给定的文件`PriceCheckDetail.java`和`ObjectCompareUtil.java`来...
原生javascript获取元素样式属性值的方法
10-28
本文将详细介绍如何使用原生JavaScript来获取元素的样式属性值，并对比IE特有方法和W3C标准方法的区别。 首先，当我们需要获取HTML元素的样式属性值时，最直接的方法是通过`elem.style.attr`，这里的`attr`是CSS...
java两个对象比较属性值
m0_67265464的博客
05-28 375
比较相同 返回true import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import java.sql.Timestamp; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.util.HashMap; import java.
关于对象值的比较顺序
question_mark的博客
11-03 168
认识 Comparable public interface Comparable<E> { // 返回值: // < 0: 表示 this 指向的对象小于 o 指向的对象 // == 0: 表示 this 指向的对象等于 o 指向的对象 // > 0: 表示 this 指向的对象等于 o 指向的对象 int compareTo(E ...
Java中对象属性的比较详解
DevNinja的博客
10-03 2592
如果重写了equals()方法，还应该同时重写hashCode()方法，并保持两者的一致性。在比较对象属性时，我们可以重写equals()方法，根据属性的值逐个进行比较。在上面的示例中，我们重写了equals()方法，首先判断两个对象的引用是否相等，然后判断对象的类型是否相同，最后比较对象的属性值。在上面的示例中，我们重写了equals()方法，首先判断两个对象的引用是否相等，然后判断对象的类型是否相同，最后比较对象的属性值。比较方法应该保持一致性，即对于相同的对象，每次比较都应该得到相同的结果。
关于在集合中对象比较属性值的问题
ABestRookie的博客
02-13 509
数据库查询的集合对象与前端传递的集合对象进行比较
实现两个对象的所有属性值比较（集合，数组除外）
qq_44845473的博客
11-15 527
对象属性比较(集合，数组不参与比较)
java对象比较参数不同
细节打败一切
07-25 901
现象: java对象比较参数不同 快速比较两个对象有哪些参数内容不一样 方法： 1：建立bean对象 2：maven程序使用jar包 <dependency> <groupId>com.github.dadiyang</groupId> <artifactId>equator</artifactId> <v...
同属性对象属性值对比
LSQ_2584951836的博客
02-27 178
同属性对象属性值对比。
java对象实体类属性字段对比变化过程
最新发布
11-13
Java对象实体类属性字段对比变化过程是指在一个Java对象实体类的生命周期中，其属性字段的变化情况。这种变化过程通常涉及到对象的创建、使用和销毁等阶段。 在对象的创建阶段，Java对象实体类会根据预设的属性字段...
JAVA对象比较
Unique_LZ的博客
04-03 442
如果有两个数字要判断是否相等，可以使用"=="完成，如果字符串要判断是否相同可以使用equals()方法，但是如果有一个自定义类，要判断它的两个对象是否相等，那么必须要实现类对象中所有属性内容的比较 String类中的equals()方法也属于对象比较操作，它具备null的验证 对象比较实现： package oop; ​ /** * 对象比较实现 */ //定义一个图书类 class Book1{ private String title;//书名 private double..
对象比较的三种方式
qq_44363212的博客
11-17 3242
1.关于对象值相等的比较 1.1 == / equals p == q表示的是p和q两个引用指向同一个对象 p.equals(q)表示p指向的对象和q指向的对象是否是值语意相等的 public class Card{ public int rank; public String suit; public Card(int rank,String s...
JavaScript中对象的比较
weixin_30415801的博客
12-17 78
Javascript中有'=='和'==='两种相等比较，后者是全等，会判断数据类型，前者是相等，在比较时，会发生隐式转换。 如果将两个对象做'=='比较，结果会如何呢？ 比如有如下两个对象： var obj1 = { name: "Nicole", sex : "female" } var obj2 = { name: "Nicole", ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值