精华内容
下载资源
问答
  • Java比较两个对象中所有属性值是否相等
    千次阅读
    2021-03-08 16:30:03

    例以下述Java类:java

    import java.io.Serializable;

    import java.util.List;

    public class Bean_Topology implements Serializable {

    private static final long serialVersionUID = 1L;

    public static long getSerialversionuid() {

    return serialVersionUID;

    }

    private Long topology_pk;

    private String topology_id;

    public String getTopology_id() {

    return topology_id;

    }

    public void setTopology_id(String topology_id) {

    this.topology_id = topology_id;

    }

    public Long getTopology_pk() {

    return topology_pk;

    }

    public void setTopology_pk(Long topology_pk) {

    this.topology_pk = topology_pk;

    }

    @Override

    public String toString() {

    return "当前拓扑的PK为:" + topology_pk + ",ID为:" +

    更多相关内容
  • 下面小编就为大家带来一篇基于java两个对象属性比较。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 比较两个对象属性值是否相同

    比较两个对象的属性值是否相同

    import java.lang.reflect.Field;
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author xqg
     * @date 2022-03-28 16:03
     */
    public class CompareObjectValue {
    
        /**
         * 比较两个实体属性值,返回一个boolean,true则表时两个对象中的属性值无差异
         *
         * @param obj1 进行属性比较的对象1
         * @param obj2 进行属性比较的对象2
         * @return 属性差异比较结果boolean
         */
        public static boolean compareObject(Object obj1, Object obj2) throws Exception {
            Map<String, String> result = new HashMap<>();
            if (obj1.getClass() == obj2.getClass()) {
                Field[] fs = obj1.getClass().getDeclaredFields();// 获取所有属性
                for (Field field : fs) {
                    // 设置访问性,反射类的方法,设置为true就可以访问private修饰的东西,否则无法访问
                    field.setAccessible(true);
                    Object v1 = field.get(obj1);
                    Object v2 = field.get(obj2);
                    result.put(field.getName(), String.valueOf(equals(v1, v2)));
                }
            }
            Collection<String> collection = result.values();
            for (String str : collection) {
                if ("false".equals(str)) {
                    return false;
                }
            }
            return obj1.getClass() == obj2.getClass();
        }
    
        private static boolean equals(Object obj1, Object obj2) {
            if (obj1 == obj2) {
                return true;
            }
            return obj1.equals(obj2);
        }
    
    }
    
    
    展开全文
  • 主要介绍了Java比较两个List的值是否相等的方法,涉及java针对队列比较的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 点击关注公众号,实用技术文章及时了解来源:xiaoer.blog.csdn.net/article/details/85005295例如下述Java类:importjava.io.Ser...

    点击关注公众号,实用技术文章及时了解

    来源:xiaoer.blog.csdn.net/article/details/85005295

    例如下述Java类:

    import java.io.Serializable;
    import java.util.List;
    
    public class Bean_Topology implements Serializable {
     private static final long serialVersionUID = 1L;
     public static long getSerialversionuid() {
      return serialVersionUID;
     }
    
     private Long topology_pk;
    
     private String topology_id;
    
     public String getTopology_id() {
      return topology_id;
     }
    
     public void setTopology_id(String topology_id) {
      this.topology_id = topology_id;
     }
    
     public Long getTopology_pk() {
      return topology_pk;
     }
    
     public void setTopology_pk(Long topology_pk) {
      this.topology_pk = topology_pk;
     }
    
     @Override
     public String toString() {
      return "当前拓扑的PK为:" + topology_pk + ",ID为:" + topology_id;
     }
    }
    

    如下想判断下面两个对象中全部属性值是否一致时,有哪些办法呢?

    Bean_Topology topology1 = new Bean_Topology();
     topology1.setTopology_id("1");
    
    Bean_Topology topology2 = new Bean_Topology();
     topology2.setTopology_pk(1L);
     topology2.setTopology_id("1");
    

    方法一:重写Bean_Topology的equals方法和hashcode方法,代码如下:

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
      
        if (obj == null || getClass() != obj.getClass()) {
            return false;
         }
    
        Bean_Topology topology = (Bean_Topology) obj;
        if (topology_pk == null) {
            if (topology.topology_pk != null) {
                return false;
            } 
        }else if (!topology_pk.equals(topology.topology_pk)) {
            return false; 
        }
            
        if (topology_id == null) {
            if (topology.topology_id != null) {
                return false;
            } 
        }else if (!topology_id.equals(topology.topology_id)) {
            return false; 
        }
            
            return true;
        }
     
        @Override
        public int hashCode() {
            return  topology_pk.hashCode()+topology_id.hashCode();
        }
    

    测试代码如下:

    if(topology1.equals(topology2)) {
     System.out.println("对象1与对象2的属性值无差异。");
    }else {
     System.out.println("对象1与对象2的属性值有差异。"); 
    }
    

    输出结果为:

    对象1与对象2的属性值有差异。

    方法二:调用文章末尾的工具类,代码如下:

    Map<String, Map<String,Object>> resultMap=compareFields(topology1,topology2);
    int size=resultMap.size();
    if(size>0) {
        System.out.println("对象1与对象2的属性值有差异,差异结果如下:");
      
        Iterator<String> it = resultMap.keySet().iterator();
        while(it.hasNext()) {
            String key=it.next();
            System.out.println("  "+key+"(oldValue:"+resultMap.get(key).get("oldValue")+",newValue:"+resultMap.get(key).get("newValue")+")");
            } 
    }else {
     System.out.println("对象1与对象2的属性值无差异!");
    }
    

    输出结果为:

    对象1与对象2的属性值有差异,差异结果如下:topology_pk(oldValue:null,newValue:1)

    工具类如下:

    package com.sitech.modual.util.compare;
    
    import java.beans.Introspector;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Method;
    import java.sql.Timestamp;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    
    import com.sitech.modual.bean.Bean_Link;
    import com.sitech.modual.bean.Bean_Topology;
    
    public class ClassCompareUtil {
     /**
      * 比较两个实体属性值,返回一个boolean,true则表时两个对象中的属性值无差异
      * @param oldObject 进行属性比较的对象1
      * @param newObject 进行属性比较的对象2
      * @return 属性差异比较结果boolean
      */
     public static boolean compareObject(Object oldObject, Object newObject) {
      Map<String, Map<String,Object>> resultMap=compareFields(oldObject,newObject);
      
      if(resultMap.size()>0) {
       return false;
      }else {
       return true;
      }
     }
     
     /**
      * 比较两个实体属性值,返回一个map以有差异的属性名为key,value为一个Map分别存oldObject,newObject此属性名的值
      * @param oldObject 进行属性比较的对象1
      * @param newObject 进行属性比较的对象2
      * @return 属性差异比较结果map
      */
     @SuppressWarnings("rawtypes")
     public static Map<String, Map<String,Object>> compareFields(Object oldObject, Object newObject) {
      Map<String, Map<String, Object>> map = null;
      
      try{ 
       /**
        * 只有两个对象都是同一类型的才有可比性
        */
       if (oldObject.getClass() == newObject.getClass()) {
        map = new HashMap<String, Map<String,Object>>();
        
        Class clazz = oldObject.getClass();
        //获取object的所有属性
        PropertyDescriptor[] pds = Introspector.getBeanInfo(clazz,Object.class).getPropertyDescriptors();
        
        for (PropertyDescriptor pd : pds) {
         //遍历获取属性名
         String name = pd.getName();
         
         //获取属性的get方法
         Method readMethod = pd.getReadMethod();
         
         // 在oldObject上调用get方法等同于获得oldObject的属性值
         Object oldValue = readMethod.invoke(oldObject);
         // 在newObject上调用get方法等同于获得newObject的属性值
         Object newValue = readMethod.invoke(newObject);
         
         if(oldValue instanceof List){
          continue;
         }
         
         if(newValue instanceof List){
          continue;
         }
         
         if(oldValue instanceof Timestamp){
          oldValue = new Date(((Timestamp) oldValue).getTime());
         }
         
         if(newValue instanceof Timestamp){
          newValue = new Date(((Timestamp) newValue).getTime());
         }
         
         if(oldValue == null && newValue == null){
          continue;
         }else if(oldValue == null && newValue != null){
          Map<String,Object> valueMap = new HashMap<String,Object>();
           valueMap.put("oldValue",oldValue);
           valueMap.put("newValue",newValue);
          
          map.put(name, valueMap);
          
          continue;
         }
         
         if (!oldValue.equals(newValue)) {// 比较这两个值是否相等,不等就可以放入map了
          Map<String,Object> valueMap = new HashMap<String,Object>();
           valueMap.put("oldValue",oldValue);
           valueMap.put("newValue",newValue);
          
          map.put(name, valueMap);
         }
        }
       }
      }catch(Exception e){
       e.printStackTrace();
      }
      
      return map;
     }
    
    }
    

    注意: 本工具类不适用于比较包含List,Map等类的Class。

    【练手项目】基于SpringBoot的ERP系统,自带进销存+财务+生产功能

    分享一套基于SpringBoot和Vue的企业级中后台开源项目,代码很规范!

    能挣钱的,开源 SpringBoot 商城系统,功能超全,超漂亮!

    PS:因为公众号平台更改了推送规则,如果不想错过内容,记得读完点一下“在看”,加个“星标”,这样每次新文章推送才会第一时间出现在你的订阅列表里。点“在看”支持我们吧!

    展开全文
  • Java比较两个对象属性值是否相等 import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import java.sql.Timestamp; import java.util.*; /** * 比较两个...

    Java比较两个对象的属性值是否相等

    import java.beans.Introspector;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Method;
    import java.sql.Timestamp;
    import java.util.*;
    
    /**
     * 比较两个对象的属性值
     */
    public class CompareUtil {
    
        /**
         * 比较两个实体属性值,返回一个boolean,true则表时两个对象中的属性值无差异
         * @param oldObject 进行属性比较的对象1
         * @param newObject 进行属性比较的对象2
         * @return 属性差异比较结果boolean
         */
        public static boolean compareObject(Object oldObject, Object newObject) {
            Map<String, List<Object>> resultMap=compareFields(oldObject,newObject,null);
    
            if(resultMap.size()>0) {
                return false;
            }else {
                return true;
            }
        }
    
        /**
         * 比较两个实体属性值,返回一个map以有差异的属性名为key,value为一个Map分别存oldObject,newObject此属性名的值
         * @param obj1 进行属性比较的对象1
         * @param obj2 进行属性比较的对象2
         * @param ignoreArr 忽略比较的字段
         * @return 属性差异比较结果map
         */
        @SuppressWarnings("rawtypes")
        public static Map<String, List<Object>> compareFields(Object obj1, Object obj2, String[] ignoreArr) {
            try{
                Map<String, List<Object>> map = new HashMap<String, List<Object>>();
                List<String> ignoreList = null;
                if(ignoreArr != null && ignoreArr.length > 0){
                    // array转化为list
                    ignoreList = Arrays.asList(ignoreArr);
                }
                if (obj1.getClass() == obj2.getClass()) {// 只有两个对象都是同一类型的才有可比性
                    Class clazz = obj1.getClass();
                    // 获取object的属性描述
                    PropertyDescriptor[] pds = Introspector.getBeanInfo(clazz,
                            Object.class).getPropertyDescriptors();
                    for (PropertyDescriptor pd : pds) {// 这里就是所有的属性了
                        String name = pd.getName();// 属性名
                        if(ignoreList != null && ignoreList.contains(name)){// 如果当前属性选择忽略比较,跳到下一次循环
                            continue;
                        }
                        Method readMethod = pd.getReadMethod();// get方法
                        // 在obj1上调用get方法等同于获得obj1的属性值
                        Object o1 = readMethod.invoke(obj1);
                        // 在obj2上调用get方法等同于获得obj2的属性值
                        Object o2 = readMethod.invoke(obj2);
                        if(o1 instanceof Timestamp){
                            o1 = new Date(((Timestamp) o1).getTime());
                        }
                        if(o2 instanceof Timestamp){
                            o2 = new Date(((Timestamp) o2).getTime());
                        }
                        if(o1 == null && o2 == null){
                            continue;
                        }else if(o1 == null && o2 != null){
                            List<Object> list = new ArrayList<Object>();
                            list.add(o1);
                            list.add(o2);
                            map.put(name, list);
                            continue;
                        }
                        if (!o1.equals(o2)) {// 比较这两个值是否相等,不等就可以放入map了
                            List<Object> list = new ArrayList<Object>();
                            list.add(o1);
                            list.add(o2);
                            map.put(name, list);
                        }
                    }
                }
                return map;
            }catch(Exception e){
                e.printStackTrace();
                return null;
            }
        }
    }
    
    

    如有用,请留下你的足迹~

    展开全文
  • (Java)判断两个对象属性是否相等
  • import java.lang.reflect.Field;import java.lang.reflect.Method;import java.util.HashMap;import java.util.Map;import org.apache.log4j.Logger;public classDomainEquals {/*** 日志操作类*/private static ...
  • 比较笨的办法就是,对两个对象需要判断的属性一一进行对比,如果只有几个属性值需要对比,可以满足,但是字段值过多就不使用了,也没有通用性 下面介绍利用反射机制,判断两个对象属性值是否相同 public static...
  • 主要思想还是通过反射获取类的属性的getter方法,调用getter方法获取比较是否相同相同就忽略不同就返回属性信息,方法都不复杂,主要是利用反射思想。 代码如下: 定义一类保存比较后的返回值信息 @Data ...
  • JAVA利用反射比较两个对象属性值是否相等 java代码 public static void main(String[] args) { Announcement announcement = new Announcement(); announcement.setContent("123"); announcement.setPhoto(...
  • 比较两个对象属性值是否相同方法 /** * 比较两个对象属性值是否相同 * * @param obj1 比较对象1 * @param obj2 比较对象2 * @param cls 对象class * @param ignoreFields 忽略字段 * @return true 相等 */ ...
  • 需求:比较两个相同对象,得到不同的属性值的属性和属性值,后面才是重点:对像里面包含其他的对象,也要拿出来,例如:两个user对象,user里面包含部门,如果两个user下面的部门不一致,要得到分别的部门名称,...
  • 主类import java.beans.PropertyDescriptor;import java.lang.reflect.Field;import java.lang.reflect.Method;public class CompareObejct {private CompareStatus status;/*** 之前原始的*/private T original;/...
  • [java]代码库import java.lang.reflect.Field;import java.lang.reflect.Method;import java.util.HashMap;import java.util.Map;import org.apache.log4j.Logger;public class DomainEquals {/*** 日志操作类*/...
  • equals(): 它的作用也是判断两个对象是否相等。但它一般有两种使用情况: 情况1:类没有覆盖equals()方法。则通过equals()比较该类的两个对象时,等价于通过“==”比较两个对象。 情况2:类覆盖了equals()方法。...
  • Java 两个对象之间的进行比较是否相同 package com.inspur.softwaregroup.communication.nrms.ex.flow.wirelessnetwork.domain; import lombok.extern.slf4j.Slf4j; import java.beans.Introspector; import java...
  • 一.Java反射的概念:在Java运行时环境中,对于任意一类,可以知道这类有哪些属性和方法。 对于任意一个对象,可以调用它的任意一方法。 这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的...
  • 1、工具类 package ... /** * @author tqf * @Description * @Version 1.0 * @since 2022-03-21 16:50 ...import java.lang.reflect.Field;...import java.util.ArrayList;...import java.u
  • 创建工具类通过反射获取类型字段并且通过getSuperclass获取父类的字段,然后再通过两个对象进行字段值比较。public class ClassInstanceCompareUtil {/*** 比较对象所有字段并把差异字段存入新的对象** @return*/...
  • java判断两个对象是否相等的方法

    千次阅读 2021-02-12 14:10:36
    java判断两个对象是否相等的方法发布时间:2020-06-25 13:48:38来源:亿速云阅读:197作者:...java中可以使用equals()方法判断两个对象是否相等,equals() 方法用于将字符串与指定的对象比较。如果给定对象与字符...
  • * 对象比较器 * 比较结果eg:1、字段名称loginName,旧:liu,新:gu;2、字段名称address,旧:hunan,新:neimenggu * @param oldBean * @param newBean * @return */ public String compareObject(Object ...
  • * 比较两个实体属性值,返回一个map以有差异的属性名为key,value为一个Map分别存oldObject,newObject此属性名的值 * @param oldObject 进行属性比较对象1 * @param newObject 进行属性比较对象2 * @...
  • * Description: 判断两个对象的各个属性是否相同 * Param: isUpdate为true,表示对原有属性值进行覆盖更改,为false,则只增加原来没有的属性值,原来有的属性值不进行更改 * @throws IllegalAccessException  ...
  • 一起跟随小编过来看看吧两个对象进行比较相等,有两种做法:1、情况一:当仅仅只是判断两个对象是否相等时,只需重写equals()方法即可。这里就不用说明2、情况二:当除了情况一之外,还需知道是那个属性不同,那么就...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 454,247
精华内容 181,698
关键字:

java比较两个对象属性值是否相等

java 订阅