精华内容
下载资源
问答
  • 主要介绍了Java判断对象是否为空(包括null ,"")的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了Java判断对象是否为空的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • JAVA判断对象是否为null

    千次阅读 2018-07-31 11:22:37
    1.String : StringUtils.isEmpty(xxx) 2.Class: Objective.isNull(xxx) 3.Collection: CollectionUtils.isEmpty(xxx) 不要写null==xxx

    1.String : StringUtils.isEmpty(xxx)

    2.Class: Objective.isNull(xxx)

    3.Collection: CollectionUtils.isEmpty(xxx)

    不要写null==xxx

    展开全文
  • Java判断对象是否为Null/空

    千次阅读 2019-05-17 11:42:00
    import java.lang.reflect.Field; import java.lang.reflect.Type;... * Description: 判断对象是否为空,进一步判断对象中的属性是否都为空 * * 对象为new,但对象中的属性都为null * </p&...
    package com.taiping.test;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Type;
    
    /**
     * <p>
     * Description: 判断对象是否为空,进一步判断对象中的属性是否都为空
     * 
     * 对象为new,但对象中的属性都为null
     * </p>
     * 
     */
    public class CheckObjectIsNullUtils {
    
        /**
         * 判断对象是否为空,且对象的所有属性都为空
         * ps: boolean类型会有默认值false 判断结果不会为null 会影响判断结果
         * 序列化的默认值也会影响判断结果
         * 
         * @param object
         * @return
         */
        @SuppressWarnings("rawtypes")
        public static boolean objCheckIsNull(Object object) {
            Class clazz = (Class) object.getClass(); // 得到类对象
            Field fields[] = clazz.getDeclaredFields(); // 得到所有属性
            boolean flag = true; // 定义返回结果,默认为true
            for (Field field : fields) {
                field.setAccessible(true);
                Object fieldValue = null;
                try {
                    fieldValue = field.get(object); // 得到属性值
                    Type fieldType = field.getGenericType();// 得到属性类型
                    String fieldName = field.getName(); // 得到属性名
                    System.out.println("属性类型:" + fieldType + ",属性名:" + fieldName
                            + ",属性值:" + fieldValue);
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                if (fieldValue != null) { // 只要有一个属性值不为null 就返回false 表示对象不为null
                    flag = false;
                    break;
                }
            }
            return flag;
        }
    
    }

     

    转载于:https://www.cnblogs.com/sinosoft/p/10880507.html

    展开全文
  • 因为此时对象已经被实例化,所以在项目中通常会用反射获取Field从而判断该属性值是否为null,也就是常说的判断对象中所有属性 不为null,本文讲讲我在项目中利用反射来判断遇到的问题和一些坑 编写工具类解决...

    前言

    • java中当对象需要判空的时候,大体都会直接 if(Object != null) ,而当我们的对象是 new Object()的时候,往往这种判断不会起作用
      因为此时对象已经被实例化,所以在项目中通常会用反射获取Field从而判断该属性值是否为null,也就是常说的判断对象中所有属性不为null,本文讲讲我在项目中利用反射来判断遇到的问题和一些坑

    编写工具类解决我们的问题

    • 废话不说,上代码
    	/**
         * description:定义一个System.out.println的开(纯属个人习惯)
         **/
    	private static int objectNullSystemOutFlag = 0;
    	
    	/**
         * description:判断当前对象是否为空(包括所有属性为空)
         *
         * @author ZhangXihui
         * @param object 入参类
         * @return boolean
         * @create 2019/6/3 17:34
         **/
        public static boolean objCheckIsNull(Object object) {
        	if (object == null) {
                return true;
            }
            // 得到类对象
            Class clazz = object.getClass();
            // 得到所有属性
            Field[] fields = clazz.getDeclaredFields();
            //定义返回结果,默认为true
            boolean flag = true;
            for (Field field : fields) {
            	//设置权限(很重要,否则获取不到private的属性,不了解的同学补习一下反射知识)
                field.setAccessible(true);
                Object fieldValue = null;
                String fieldName = null;
                try {
                    //得到属性值
                    fieldValue = field.get(object);
                    //得到属性类型
                    Type fieldType = field.getGenericType();
                    //得到属性名
                    fieldName = field.getName();
                    //打印输出(调试用可忽略)
                    if (objectNullSystemOutFlag == 1) {
                        System.out.println("属性类型:" + fieldType + ",属性名:" + fieldName + ",属性值:" + fieldValue);
                    }
                } catch (IllegalArgumentException | IllegalAccessException e) {
                    e.printStackTrace();
                }
                //只要有一个属性值不为null 就返回false 表示对象不为null
                if (fieldValue != null) {
                    flag = false;
                    break;
                }
            }
            return flag;
        }
    
    • 简单的写一个main,我们开始测试
    	public static void main(String[] args) {
            @ToString
            class User {
                private String username;
                private String password;
    
                public User() {
                }
    
                public User(String username, String password) {
                    this.username = username;
                    this.password = password;
                }
            }
            User user = new User();
            System.out.println(user);
            //正常判断
            System.out.println(user == null);
            //使用反射的工具类
            System.out.println( CommonFunction.objCheckIsNull(user));
        }
    
    • 输出结果

    User(username=null, password=null)
    false
    true

    • 可见我们的工具类是好用的,但是在使用中会遇到一些问题,接下来说说我项目中遇到的问题和解决方法

    问题与解决

    • 场景一:在web开发中,实体类我们经常会进行序列化, implements Serializable 并为其添加一个 serialVersionUID
    		@ToString
            class User implements Serializable {
                private static final long serialVersionUID = 1996598449318251880L;
                private String username;
                private String password;
    
                public User() {
                }
    
                public User(String username, String password) {
                    this.username = username;
                    this.password = password;
                }
            }
    
    • 产生问题:可以看到 serialVersionUID 是作为类中的一个属性,而最开始构建的工具类没有考虑到serialVersionUID 的存在
      这样会导致其返回结果一直为false,这也是一开始困扰我的原因,当我们专注于某一件事的时候,往往会忽略一些事情。

    • 解决:在判断条件中忽略序列化字段名

    			//只要有一个属性值不为null 就返回false 表示对象不为null 忽略序列化
                if (fieldValue != null && !"serialVersionUID".equals(fieldName)) {
                    flag = false;
                    break;
                }
    
    • 场景二:

    • 业务需求场景:有一入参实体类,该实体类有30个属性,其中有2个属性会在程序中赋予默认值为10,这样就导致该类有28个为null的属性和2个为10的属性,业务判断为除了默认值的两个属性之外如果所有属性为null,那么我们就认为这个入参实体类什么也没接到,也就认为它为"空"

    • 那么问题来了,难道我们要去挨个判断剩余的28个字段为空么?很显然不是的,根据上面我们从属性判断中剔除 serialVersionUID 的思路出发,我们会发现,业务中会经常出现,我们希望判断某一实体类中,除了某些属性或者某些值之外的属性为null的情况,也就是我们判空的时候希望剔除掉某些属性或者某些值,so,基于这些场景我改造了工具类,使其能够实现我们的思路

    	/**
         * description:判断当前对象是否为空(包括所有属性为空)
         * 可选则在判断规则中剔除某一字段,或者某一值
         *
         * @author ZhangXihui
         * @param object 入参对象
         * @param excludeNameList 要剔除的属性名称,没有就传空集合或者null
         * @param excludeValueList 要剔除的数值,没有就传空集合或者null
         * @return boolean
         * @create 2019/6/3 17:34
         **/
        public static boolean objCheckIsNull(Object object, List<String> excludeNameList, List<Object> excludeValueList) {
            if (object == null) {
                return true;
            }
            // 得到类对象
            Class clazz = object.getClass();
            // 得到所有属性
            Field[] fields = clazz.getDeclaredFields();
            //判断入参
            boolean excludeNameListFlag = false;
            if (excludeNameList != null && excludeNameList.size() > 0) {
                excludeNameListFlag = true;
            }
            boolean excludeValueListFlag = false;
            if (excludeValueList != null && excludeValueList.size() > 0) {
                excludeValueListFlag = true;
            }
            //定义返回结果,默认为true
            boolean flag = true;
            for (Field field : fields) {
                field.setAccessible(true);
                Object fieldValue = null;
                String fieldName = null;
                try {
                    //得到属性值
                    fieldValue = field.get(object);
                    //得到属性类型
                    Type fieldType = field.getGenericType();
                    //得到属性名
                    fieldName = field.getName();
                    //剔除指定属性名的属性值
                    if (excludeNameListFlag) {
                        for (String s : excludeNameList) {
                            if (fieldName.equals(s)) {
                                fieldValue = null;
                                break;
                            }
                        }
                    }
                    //剔除指定属性值
                    if (excludeValueListFlag) {
                        for (Object obj : excludeValueList) {
                            if (obj.equals(fieldValue)) {
                                fieldValue = null;
                                break;
                            }
                        }
                    }
                    //打印输出(调试用可忽略)
                    if (objectNullSystemOutFlag == 1) {
                        System.out.println("属性类型:" + fieldType + ",属性名:" + fieldName + ",属性值:" + fieldValue);
                    }
                } catch (IllegalArgumentException | IllegalAccessException e) {
                    e.printStackTrace();
                }
                //只要有一个属性值不为null 就返回false 表示对象不为null 忽略序列化
                if (fieldValue != null && !"serialVersionUID".equals(fieldName)) {
                    flag = false;
                    break;
                }
            }
            //打印输出(调试用可忽略)
            if (objectNullSystemOutFlag == 1) {
                System.out.println("忽略属性: " + excludeNameList + " 忽略值: " + excludeValueList);
            }
            return flag;
        }
    
    • 测试一下
    public static void main(String[] args) {
            @ToString
            class User implements Serializable {
                private static final long serialVersionUID = 1996598449318251880L;
                private String username;
                private String password;
                private String sex;
                private String childSex;
                public User() {
                }
                public User(String sex, String childSex) {
                    this.sex = sex;
                    this.childSex = childSex;
                }
            }
            User user = new User("男性","男性");
            System.out.println(user);
            //使用基础的反射工具类
            System.out.println( CommonFunction.objCheckIsNull(user));
            //在判断中剔除 value 为男性的属性
            System.out.println( CommonFunction.objCheckIsNull(user,null, Collections.singletonList("男性")));
            //在判断中剔除 属性名 为 sex,childSex 的属性
            System.out.println( CommonFunction.objCheckIsNull(user,Arrays.asList("sex","childSex"),null));
        }
    
    • 结果

    User(username=null, password=null, sex=男性, childSex=男性)
    false
    true
    true

    • OK 大功告成!
      在这里插入图片描述
    展开全文
  • Java判断对象是否为空的方法:isEmpty,null,"

    万次阅读 多人点赞 2019-01-08 17:39:05
    今天修改辞职同事遗留的代码才发现这个问题,不能用isEmpty来判断一个对象是否为null,之前没在意这个问题,在报了空指针之后才发现这个问题。 查了一下关于判断为空的几个方法的区别,这里做一个简单的总结: null...

    今天修改辞职同事遗留的代码才发现这个问题,不能用isEmpty来判断一个对象是否为null,之前没在意这个问题,在报了空指针之后才发现这个问题。

    查了一下关于判断为空的几个方法的区别,这里做一个简单的总结:

    1. null

    一个对象如果有可能是null的话,首先要做的就是判断是否为null:object == null,否则就有可能会出现空指针异常,这个通常是我们在进行数据库的查询操作时,查询结果首先用object != null,进行非空判断,然后再进行其他的业务逻辑,这样可以避免出现空指针异常。

    1. isEmpty() 此方法可以使用于字符串,数组,集合都可以用。

    首先看一下源码:

        public boolean isEmpty() {
            return value.length == 0;
        }
    

    这里是一个对象的长度,使用这个方法,首先要排除对象不为null,否则当对象为null时,调用isEmpty方法就会报空指针了。

    要想返回true,也就是一个对象的长度为0,也就是说首先这个对象肯定不为null了,内容为空时,才能返回true。

    这里我想到了之前看过视频里面说到的栈和堆的问题,当创建一个新的对象时,栈里面有一个对象,堆里面有一个对象,栈里的对象指向堆里面的对象。对象包含引用对象和实际对象,也就是栈和值的关系,比如String a = new String();,这句代码就在堆内存中产生了一个String对象"",和栈内存中一个引用对象a,也就是a指向了一个为空的字符串。当没有再次给引用对象a进行赋值时,操作a也即是操作这个空字符串。

    栈内存:栈内存首先是一片内存区域,存储的都是局部变量,凡是定义在方法中的都是局部变量(方法外的是全局变量),for循环内部定义的也是局部变量,是先加载函数才能进行局部变量的定义,所以方法先进栈,然后再定义变量,变量有自己的作用域,一旦离开作用域,变量就会被释放。栈内存的更新速度很快,因为局部变量的生命周期都很短。

    堆内存:存储的是数组和对象(其实数组就是对象),凡是new建立的都是在堆中,堆中存放的都是实体(对象),实体用于封装数据,而且是封装多个(实体的多个属性),如果一个数据消失,这个实体也没有消失,还可以用,所以堆是不会随时释放的,但是栈不一样,栈里存放的都是单个变量,变量被释放了,那就没有了。堆里的实体虽然不会被释放,但是会被当成垃圾,Java有垃圾回收机制不定时的收取。

    下面我们通过一个图例详细讲一下堆和栈:

    比如主函数里的语句 int [] arr=new int [3];在内存中是怎么被定义的:

    主函数先进栈,在栈中定义一个变量arr,接下来为arr赋值,但是右边不是一个具体值,是一个实体。实体创建在堆里,在堆里首先通过new关键字开辟一个空间,内存在存储数据的时候都是通过地址来体现的,地址是一块连续的二进制,然后给这个实体分配一个内存地址。数组都是有一个索引,数组这个实体在堆内存中产生之后每一个空间都会进行默认的初始化(这是堆内存的特点,未初始化的数据是不能用的,但在堆里是可以用的,因为初始化过了,但是在栈里没有),不同的类型初始化的值不一样。所以堆和栈里就创建了变量和实体:
    在这里插入图片描述

    下面看一个demo:

    	public static void main(String[] args) {
    		String a = new String();
    		String b = "";
    		String c = null;
    		if (a.isEmpty()) {
    			System.out.println("String a is empty");
    		}
    		if (b.isEmpty()) {
    			System.out.println("String b is empty");
    		}
    		if (c == null) {
    			System.out.println("String c = null");
    		}
    		if (null == a) {
    			// 编译器直接就提示了Dead code,a指向了一个新对象,肯定不是null了
    			System.out.println("String a =null");
    		}
    		if (a == "") {
    			System.out.println("a = ''");
    		}
    		if (a.equals("")) {
    			//由于a是字符串,字符串的比较需要用equals,不能直接用 ==
    			System.out.println("a = ''");
    		}
    		/*if (c.isEmpty()) {
    			// 这里会报空指针,即null不能使用此方法
    			System.out.println("c == null   and   c.isEmpty");
    		}*/
    		
    		List<String> list = new ArrayList<>();
    		//list.add("");
    		if (list.isEmpty()) {
    			System.out.println("list is empty");
    		}
    		System.out.println(list.size());
    	}
    /*Output:
    String a is empty
    String b is empty
    String c = null
    equals:a = ''
    list is empty
    0
    */
    

    参考文章:
    堆和栈的概念和区别 : https://blog.csdn.net/pt666/article/details/70876410/
    JAVA中isEmpty和null以及""的区别 : https://blog.csdn.net/lhflower123/article/details/8223607

    展开全文
  • java 判断对象是否为空.如String,Character,Object[]
  • Java 判断json字符串中的对象null

    千次阅读 2020-08-03 09:50:17
    Java 判断json字符串中的对象null 判断不能用 if(jsonObject.get(“xxx”) ==null){} 或者是 if(“null”.equals(jsonObject.get(“xxx”))){} 原因是jsonObject.get(“xxx”) 返回JSONObject.NULL,所以用以下...
  • //判断对象是否: 返回ture表示所有属性为null  返回false表示不是所有属性都是null public static boolean isAllFieldNull(Object obj) throws IllegalAccessException { Class<?> aClass ...
  • 判断Java对象的属性是否为null

    千次阅读 2018-07-02 15:41:41
    if(requestVo.getName == null || requestVo.getName.equals(""))
  • // 判断对象中的属性值是否都为null // f.get(object) 获取属性值 public static boolean checkObjAllFieldsIsNull(Object object) { if (null == object) { return true; } try { for (Field f : object....
  • Java判断对象是否为空(包括null ,"")

    万次阅读 2016-07-19 13:35:31
    package com.gj5u.publics.util; import java.util.List; /** * 判断对象是否为空 * * @author Rex * */ public class EmptyUtil { /** * 判断对象为空 * * @param obj * 对象名 *
  • java 判断一个对象是否为空对象

    万次阅读 2020-03-30 22:29:29
    最近项目中遇到一个问题,在用户没填数据的时候,我们需要接收从前端传过来的对象为null,但是前端说他们一个一个判断特别麻烦,只能传个空对象过来,我第一个想法就是可以通过反射来判断对象是否为空。 第一版: ...
  • JAVA判断对象以及属性值是否为空

    千次阅读 2020-12-18 11:45:27
    JAVA判断对象以及属性值是否为空 import java.lang.reflect.Field; import lombok.extern.slf4j.Slf4j; import org.springframework.util.StringUtils; /** * @author Tate * @date 2020-12-18 11:10 * @title ...
  • Java 判断对象及对象中属性是否为空

    万次阅读 2019-09-18 09:08:37
    import java.lang.reflect.Field; /** * Created by hj. */ public class VoUtilsTool { /**** * @param object 对象 * @return 如果对象不为空,且没有空值。返回false,对象为空或者有空值,返回true * */ ...
  • 相信,网上很多java性能优化的帖子里都会有这么一条:尽量把不使用的对象显式得置为null.这样有助于内存回收 &nbsp; &nbsp; &nbsp;可以明确的说,这个观点是基本错误的.sun jdk远比我们想象中的机智.完全...
  • 字符串作为特殊的对象类 我们有的时候要判断是否为null或者空 直接用 if (str != null && str.equals("")) {} 即可。 其他对象(容器)的话 就直接: if (obj != null){} 就完事了 ...
  • JAVA 判断对象内容是否含有空值

    千次阅读 2018-03-09 14:24:28
    简单判断对象是否含有NULL值,以及信息描述。package com.sicdt.sicsign.bill.api.util; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.ArrayList; ...
  • java8判断对象是否为空新写法

    万次阅读 2019-10-28 16:48:22
    1、我们为了避免空指针异常,通常会做一些非空的判断,通常写法如下 Object o = ... if(o != null){ do something ... } 2、java8 提供了一种更加优美的写法 @Test public void testOptional() { String ...
  • java 判断对象的所有属性不为空

    千次阅读 2019-07-23 15:11:50
    import java.lang.reflect.Field; public class aaaaaa { public static void main(String[] args) throws Exception { person p = new person(); p.setAge(10); p.setNa...
  • java判断字符串为空或NULL的方法

    千次阅读 2020-06-27 21:25:45
    NULL串指的目前没有任何对象与该变量关联,判断方法: if(str==null) 检查一个字符串既不是空串也不是NULL串的方法: 一是: if(str!=null&&str.length()!=0) 注意:要先检查str不为null,否则在一个...
  • java判断空字符串和对象是否为null

    千次阅读 2017-07-06 14:35:45
    判断空字符串: StringUtils.isEmpty(str); 判断对象null: Objects.isNull(object); 判断对象不为null: Objects.nonNull(object);
  • Java 判断实体对象及所有属性是否为空

    万次阅读 多人点赞 2018-11-02 22:12:30
    2、判断对象所有属性是否为空 3、特别注意,实体类中如果有基本数据类型,会影响判断 package com.liuxd.object; import org.apache.commons.lang3.StringUtils; import java.lang.reflect.Field; /** * ...
  • 判断对象或者对象数组是否为空的工具类。
  • java判断字符串不为空和null的方法

    千次阅读 2019-04-19 12:44:41
    首先,区分空串和null串 1、 空串""是长度为0的字符串,它有自己的串长度(0)和内容(空),判断一个字符串为空的方法: if (str.length() == 0);...2、 null串表示目前没有任何对象与该变量关联...
  • java里面对象T不能用T.equals(null)方法判断是否T泛型是否为null 因为如果T为null,他是不存在任何方法的,包括equals,所以当T为null时,使用T.equals()就会报空指针错误。在equals源码里面也明确表示"non-null ...
  • java判断object对象为不为空

    千次阅读 2020-09-16 11:36:39
    判断对象不为null:Objects.nonNull(obj); 判断对象null: Objects.isNull(obj); 判断空字符串: StringUtils.isEmpty(str);
  • //查询出对象所有的属性 Field[] fields = dept.getClass().getDeclaredFields(); //用于判断所有属性是否为空,如果参数为空则不查询 boolean flag = false; for (Field field : fields) { //不检查 直接取值 ...
  • 如何判断? 1、user.getName()==null,其结果是false 2、user.getName().isEmpty()。抛出异常java.lang.NullPointerException 3、user.getName().length()。抛出异常java.lang.NullPointerEx

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 532,242
精华内容 212,896
关键字:

java判断对象等于null

java 订阅