精华内容
下载资源
问答
  • 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比较两个对象中全部属性值是否相等

    万次阅读 多人点赞 2018-12-14 16:01:49
    Java比较两个对象中全部属性值是否相等 例如下述Java类: import java.io.Serializable; import java.util.List; public class Bean_Topology implements Serializable { private static final long ...

    例如下述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。

    展开全文
  • [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 {/*** 日志操作类*/...

    [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 {

    /**

    * 日志操作类

    */

    private static Logger logger = Logger.getLogger(DomainEquals.class);

    public DomainEquals() {

    }

    /**

    * 比较两个BEAN或MAP对象的值是否相等

    * 如果是BEAN与MAP对象比较时MAP中的key值应与BEAN的属性值名称相同且字段数目要一致

    * @param source

    * @param target

    * @return

    */

    public static boolean domainEquals(Object source, Object target) {

    if (source == null || target == null) {

    return false;

    }

    boolean rv = true;

    if (source instanceof Map) {

    rv = mapOfSrc(source, target, rv);

    } else {

    rv = classOfSrc(source, target, rv);

    }

    logger.info("THE EQUALS RESULT IS " + rv);

    return rv;

    }

    /**

    * 源目标为MAP类型时

    * @param source

    * @param target

    * @param rv

    * @return

    */

    private static boolean mapOfSrc(Object source, Object target, boolean rv) {

    HashMap map = new HashMap();

    map = (HashMap) source;

    for (String key : map.keySet()) {

    if (target instanceof Map) {

    HashMap tarMap = new HashMap();

    tarMap = (HashMap) target;

    if(tarMap.get(key)==null){

    rv = false;

    break;

    }

    if (!map.get(key).equals(tarMap.get(key))) {

    rv = false;

    break;

    }

    } else {

    String tarValue = getClassValue(target, key) == null ? "" : getClassValue(target, key).toString();

    if (!tarValue.equals(map.get(key))) {

    rv = false;

    break;

    }

    }

    }

    return rv;

    }

    /**

    * 源目标为非MAP类型时

    * @param source

    * @param target

    * @param rv

    * @return

    */

    private static boolean classOfSrc(Object source, Object target, boolean rv) {

    Class> srcClass = source.getClass();

    Field[] fields = srcClass.getDeclaredFields();

    for (Field field : fields) {

    String nameKey = field.getName();

    if (target instanceof Map) {

    HashMap tarMap = new HashMap();

    tarMap = (HashMap) target;

    String srcValue = getClassValue(source, nameKey) == null ? "" : getClassValue(source, nameKey)

    .toString();

    if(tarMap.get(nameKey)==null){

    rv = false;

    break;

    }

    if (!tarMap.get(nameKey).equals(srcValue)) {

    rv = false;

    break;

    }

    } else {

    String srcValue = getClassValue(source, nameKey) == null ? "" : getClassValue(source, nameKey)

    .toString();

    String tarValue = getClassValue(target, nameKey) == null ? "" : getClassValue(target, nameKey)

    .toString();

    if (!srcValue.equals(tarValue)) {

    rv = false;

    break;

    }

    }

    }

    return rv;

    }

    /**

    * 根据字段名称取值

    * @param obj

    * @param fieldName

    * @return

    */

    public static Object getClassValue(Object obj, String fieldName) {

    if (obj == null) {

    return null;

    }

    try {

    Class beanClass = obj.getClass();

    Method[] ms = beanClass.getMethods();

    for (int i = 0; i < ms.length; i++) {

    // 非get方法不取

    if (!ms[i].getName().startsWith("get")) {

    continue;

    }

    Object objValue = null;

    try {

    objValue = ms[i].invoke(obj, new Object[] {});

    } catch (Exception e) {

    logger.info("反射取值出错:" + e.toString());

    continue;

    }

    if (objValue == null) {

    continue;

    }

    if (ms[i].getName().toUpperCase().equals(fieldName.toUpperCase())

    || ms[i].getName().substring(3).toUpperCase().equals(fieldName.toUpperCase())) {

    return objValue;

    } else if (fieldName.toUpperCase().equals("SID")

    && (ms[i].getName().toUpperCase().equals("ID") || ms[i].getName().substring(3).toUpperCase()

    .equals("ID"))) {

    return objValue;

    }

    }

    } catch (Exception e) {

    // logger.info("取方法出错!" + e.toString());

    }

    return null;

    }

    public static void main(String args[]) {

    }

    }

    //源代码片段来自云代码http://yuncode.net

    694748ed64b9390909c0d88230893790.png

    展开全文
  • 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 ...

    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 Logger logger = Logger.getLogger(DomainEquals.class);publicDomainEquals() {

    }/**

    * 比较两个BEAN或MAP对象的值是否相等

    * 如果是BEAN与MAP对象比较时MAP中的key值应与BEAN的属性值名称相同且字段数目要一致

    * @param source

    * @param target

    * @return*/

    public staticboolean domainEquals(Object source, Object target) {if (source == null || target == null) {return false;

    }

    boolean rv= true;if(source instanceof Map) {

    rv=mapOfSrc(source, target, rv);

    }else{

    rv=classOfSrc(source, target, rv);

    }

    logger.info("THE EQUALS RESULT IS" +rv);returnrv;

    }/**

    * 源目标为MAP类型时

    * @param source

    * @param target

    * @param rv

    * @return*/

    private staticboolean mapOfSrc(Object source, Object target, boolean rv) {

    HashMap map = new HashMap();

    map=(HashMap) source;for(String key : map.keySet()) {if(target instanceof Map) {

    HashMap tarMap = new HashMap();

    tarMap=(HashMap) target;if(tarMap.get(key)==null){

    rv= false;break;

    }if (!map.get(key).equals(tarMap.get(key))) {

    rv= false;break;

    }

    }else{

    String tarValue= getClassValue(target, key) == null ? "": getClassValue(target, key).toString();if (!tarValue.equals(map.get(key))) {

    rv= false;break;

    }

    }

    }returnrv;

    }/**

    * 源目标为非MAP类型时

    * @param source

    * @param target

    * @param rv

    * @return*/

    private staticboolean classOfSrc(Object source, Object target, boolean rv) {

    Class> srcClass =source.getClass();

    Field[] fields=srcClass.getDeclaredFields();for(Field field : fields) {

    String nameKey=field.getName();if(target instanceof Map) {

    HashMap tarMap = new HashMap();

    tarMap=(HashMap) target;

    String srcValue= getClassValue(source, nameKey) == null ? "": getClassValue(source, nameKey)

    .toString();if(tarMap.get(nameKey)==null){

    rv= false;break;

    }if (!tarMap.get(nameKey).equals(srcValue)) {

    rv= false;break;

    }

    }else{

    String srcValue= getClassValue(source, nameKey) == null ? "": getClassValue(source, nameKey)

    .toString();

    String tarValue= getClassValue(target, nameKey) == null ? "": getClassValue(target, nameKey)

    .toString();if (!srcValue.equals(tarValue)) {

    rv= false;break;

    }

    }

    }returnrv;

    }/**

    * 根据字段名称取值

    * @param obj

    * @param fieldName

    * @return*/

    public staticObject getClassValue(Object obj, String fieldName) {if (obj == null) {return null;

    }try{

    Class beanClass=obj.getClass();

    Method[] ms=beanClass.getMethods();for (int i = 0; i < ms.length; i++) {//非get方法不取

    if (!ms[i].getName().startsWith("get")) {continue;

    }

    Object objValue= null;try{

    objValue= ms[i].invoke(obj, newObject[] {});

    }catch(Exception e) {

    logger.info("反射取值出错:" +e.toString());continue;

    }if (objValue == null) {continue;

    }if(ms[i].getName().toUpperCase().equals(fieldName.toUpperCase())|| ms[i].getName().substring(3).toUpperCase().equals(fieldName.toUpperCase())) {returnobjValue;

    }else if (fieldName.toUpperCase().equals("SID")&& (ms[i].getName().toUpperCase().equals("ID") || ms[i].getName().substring(3).toUpperCase()

    .equals("ID"))) {returnobjValue;

    }

    }

    }catch(Exception e) {//logger.info("取方法出错!" + e.toString());

    }return null;

    }public static voidmain(String args[]) {

    }

    }

    展开全文
  • importjava.lang.reflect.Field;importjava.lang.reflect.Method;importjava.util.HashMap;importjava.util.Map;importorg.apache.log4j.Logger;publicclassDomainEquals{/***日志操作类*/privatestaticLogger...
  • 例以下述Java类:javaimport java.io.Serializable;import java.util.List;public class Bean_Topology implements Serializable {private static final long serialVersionUID = 1L;public static long ...
  • 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 { /...
  • /// /// 判断两个相同引用类型的对象属性值是否相等/// /// /// 对象1/// 对象2/// 按type类型中的属性进行比较/// public static bool CompareProperties(T obj1, T obj2, Type type){//为空判断if (obj1 == null...
  • 什么叫对象?对象即object,它是类的实例化后的产物。它有两个特征:1.静态特征,2.动态特征。静态特征是指对象的属性;...3.使用if控制语句判断两个对象的内存地址值是否相等。4.下面是完整代码,...
  • Java中通常要比较两个对象在修改前与修改后的值是否相同,一般我们采用的是反射技术获取对象的get方法[或其他的方法]获取值并做比较。如果系统将修改的属性名称也显示出来,这样就能更直观的显示类中的哪一个属性...
  • 初探java对象比较

    2017-08-07 22:07:00
    判断两个对象属性值是否相等的方法, class Book{ private String title; private double price; public Book(String title,double price){ this.title = title; this.price = price; } ...
  • 相等与同一:如果两个对象具有相同的类型以及相同的属性值,则称这两个对象相等。如果两个引用对象指的是同一个对象,则称这两个变量同一。==是一个比较运算符,基本数据类型比较的是值,引用数据类型比较的是地址值...
  • 09 Java相等判断方法

    2019-03-10 20:12:00
      ( == )比较的是对象值,如果是地址,比较两个地址是否相等。 2. equals()方法   equals()也默认与( == )一样比较地址,但是每个类都继承了object,每个类都可以重写equals(), 你可以自己实现比较...
  • ——两个对象具有相同的类型,及相同的属性值,则称二者相等(equal) ——如果两个引用变量指向的是同一个对象,则称这两个变量(对象)同一(identical) ——两个对象同一,则肯定相等 ——两个对象相等,不一定同一 ...
  • 如果两个对象具有相同的类型以及相同的属性值,则称这两个对象相等。 如果两个引用对象指的是同一个对象,则称这两个变量同一。 ==是一个比较运算符,基本数据类型比较的是值,引用数据类型比较的是地址值。 (比较...
  • 如果一个自定义的对象类中没有覆写equals方法,这是使用equals进行比较两个对象与使用"=="是一样的,都是比较的是两个对象的地址(即两个对象是否为同一个对象); 如果覆写了equals()方法,则是比较其中的属性值是否...
  • scala的相等

    2018-10-26 10:54:41
    java比较两个对象/属性是否相等: /**在java中,== 只会对java对象引用进行比较,对象引用的地址相同(内存中同一个位置)则返回true ; * 而equals是比较两个字段的值是否相等,若值相等则返回true * * 不过...
  • java八股文第一章:Java 基础知识

    千次阅读 2021-01-18 13:39:20
    Java 基础知识 1、Object 类相关方法 getClass 获取当前运行时对象的 Class 对象。 hashCode 返回对象的 hash 码。...通过内存地址比较两个对象是否相等,String 类重写了这个方法使用来比较是否相等。 toStri
  • Java中HashSet vs TreeSet 一.HashSet 其底层数据结构是哈希表,不保证顺序,是不同步的。 在插入对象类型的时候... 如果有相等则继续通过equals()比较两个对象的每个属性是否完全相等,如相等则为重复对象,不能插入
  • Java 八股文

    万次阅读 多人点赞 2020-09-04 16:05:58
    一、Java 基础知识 1、Object 类相关方法 getClass 获取当前运行时对象的 Class 对象。 hashCode 返回对象的 hash 码。...通过内存地址比较两个对象是否相等,String 类重写了这个方法使用来比较是否相等。 toS.
  • Java 基础 - equals和==

    2020-10-09 15:16:10
    概念 如果没有重写equals(), equals 比较的是两个对象的地址是否相等。 Java 类中重写equals() 的基本类 ...4. 比较两个对象属性值是否相等 为什么重写equals(), 要重写 hashCode() ? 如果不重写
  • 我们平常判断两个对象是否相等时直接使用.equals()方法,但你有思考过equals比较的是两个对象还是引用地址嘛? 这个问题基本上是面试的常客 提问: 请判断,两个对象值相同(x.equals(y) == true),但却可有不同...
  • Java常用类二

    2020-05-29 20:37:36
    equals默认比较对象地址是否相等,重写后可以比较对象内的属性值是否相等。 Objects类,比较两个对象,防止空指针方法 Date类: Calendar类: 日期相关的类,用法比较简单,月数需要+1。可以取年,月,.
  • equals()是比较对象的属性值是否相等,前提是这两个对象必须重写object对象的equals方法,object对象是所有对象的基类,也就是所有对象都继承了object对象,如果不重写equals方法,object对象原有的equals方法作用和=是...
  • 03.08 对象的行为

    2019-03-08 17:29:09
    4(==)与equals()的区别? ==比较的是对象的,如果是...equals和hashcode方法两个都是java设计用来判断两个对象是否相等的方法,但是equals在进行比较的时候,逻辑是比较对象的所有属性是否相等,如果属性全都...
  • Java常用知识复习

    2020-10-18 12:58:22
    在开发中要比较两个对象是否相同,经常会根据对象中的属性值进行比较,也就是在开发经常需要子类重写equals方法根据对象的属性值进行比较 class Person extends Object{ int age ; //复写父类的equals方法,实现...
  • 1.功能:比较两个对象是否相等。如果没有重写的话,比较的是两个对象的地址值。重写后,可以比较两个对象属性值。 2.==: (1)可以比较基本数据类型,比较基本数据类型的时候,比较的是基本数据类型的值是否相同。...

空空如也

空空如也

1 2 3 4 5
收藏数 99
精华内容 39
关键字:

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

java 订阅