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

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

    最近项目中遇到一个问题,在用户没填数据的时候,我们需要接收从前端传过来的对象为null,但是前端说他们一个一个判断特别麻烦,只能传个空对象过来,我第一个想法就是可以通过反射来判断对象是否为空。

    第一版:

    User.java

    public class User {
        private String username;
    
        private Boolean active;
    
        private Long id;
        // 省略get和set方法
    }
    

    ReflectUtil.java

    public class ReflectUtil {
        public static boolean isObjectNull(Object obj){
            if (obj != null) {
                Class<?> objClass = obj.getClass();
                Method[] declaredMethods = objClass.getDeclaredMethods();
                if (declaredMethods.length > 0) {
                    int methodCount = 0; // get 方法数量
                    int nullValueCount = 0; // 结果为空
    
                    for (Method declaredMethod : declaredMethods) {
                        String name = declaredMethod.getName();
                        if (name.startsWith("get") || name.startsWith("is")){
                            methodCount += 1;
                            try {
                                Object invoke = declaredMethod.invoke(obj);
                                if (invoke == null) {
                                    nullValueCount += 1;
                                }
                            } catch (IllegalAccessException | InvocationTargetException e){
                                e.printStackTrace();
                            }
                        }
                    }
                    return methodCount == nullValueCount;
                }
            }
            return false;
        }
    }
    
    

    TestReflect.java

    public class TestReflect {
        public static void main(String[] args) {
            User user = new User();
            System.out.println(ReflectUtil.isObjectNull(user));
        }
    }
    

    结果:

    true
    

    第一版 获取一个类的声明的方法,判断方法如果以get或者is开头就是get方法,然后通过反射调用改方法获取结果,再判断结果是否为空,如果结果为null的话就把nullValueCount+1,最后返回结果为空的值的数量和get方法数量比较的结果,如果两者数量相同则说明该对象为空,反之不为空。
    第一版也可以判断一个对象是否为空,但前提是对象必须使用包装类,没有默认值的就不行了,当然你也可以根据类型和返回值结果来判断对象是否为空,但是如果想忽略某个属性不做判断,改起来就有点麻烦了。 后来想知道spring 的BeanUtils 是怎么实现属性复制的就看了一下,发现了新的方法,于是就有了第二版。

    第二版:

    /**
         *  判断对象是否为空,
         * @param obj
         * @param ignoreProperties 忽略的属性
         * @return 如果get 方法的数量等于 属性为空的数量 返回true,否则false
         */
        public static boolean isNullObject(Object obj , String... ignoreProperties) throws IntrospectionException {
            if (obj != null) {
                Class<?> objClass = obj.getClass();
                BeanInfo beanInfo = Introspector.getBeanInfo(objClass);
                PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
    
                List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);
    
                int count = 1; // 结果为空的属性数量 初始化为1 去除Object的getClass方法
                int propertyCount = propertyDescriptors.length; // 属性数量
                if (ignoreList != null){
                    propertyCount -= ignoreList.size();
                }
    
                for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
                    Method readMethod = propertyDescriptor.getReadMethod();
                    String name = propertyDescriptor.getName();
                    if (readMethod != null && (ignoreList == null || !ignoreList.contains(name))) {
                        Class<?> returnType = readMethod.getReturnType();
                        String typeName = returnType.getSimpleName();
                        Object invoke = null;
                        try {
                            invoke = readMethod.invoke(obj);
                            if (invoke == null) {
                                count+=1;
                            }else {
                                switch (typeName) {
                                    case "String":
                                        if ("".equals(invoke.toString().trim())) {
                                            count += 1;
                                        }
                                        break;
                                    case "Integer":
                                        if ((Integer) invoke <= 0) {
                                            count += 1;
                                        }
                                        break;
                                    case "int":
                                        if ((int) invoke <= 0) {
                                            count += 1;
                                        }
                                        break;
                                    case "double":
                                        if ((double) invoke <= 0.0d) {
                                            count += 1;
                                        }
                                        break;
                                    case "Double":
                                        if ((Double) invoke <= 0.0D) {
                                            count += 1;
                                        }
                                        break;
                                    case "float":
                                        if ((float) invoke <= 0.0f) {
                                            count += 1;
                                        }
                                        break;
                                    case "Float":
                                        if ((Float) invoke <= 0.0F) {
                                            count += 1;
                                        }
                                        break;
                                    case "Long":
                                        if ((Long) invoke <= 0L) {
                                            count += 1;
                                        }
                                        break;
                                    case "long":
                                        if ((long) invoke <= 0L) {
                                            count += 1;
                                        }
                                        break;
                                }
                            }
                        } catch (IllegalAccessException | InvocationTargetException e) {
                            e.printStackTrace();
                        }
                    }
                }
                return propertyCount == count;
            }
            return true;
        }
    

    第一版和第二版思想基本都是一样的,都是通过读方法去判断返回值是否为空,只不过第二版在第一版上加强了可以忽略属性这个功能。
    通过spring 的beanutils发现PropertyDescriptor这个类,从名字看来是个属性描述器,描述属性相关的东西,通过属性描述器可以获取bean的属性名称,读写方法,使用起来还挺方便。
    通过Introspector内省类的静态方法getBeanInfo(Class<?> beanClass)获取BeanInfo,然后通过BeanInfo对象的getPropertyDescriptors()就可以返回属性描述器。
    由于没有太多研究就不多介绍了。
    如果你还有其他方法判断一个对象是否为空请留言,谢谢

    能力有限,水平一般,如有错误,请多指出。

    展开全文
  • java 判断对象是否为空.如String,Character,Object[]
  • 字符串作为特殊的对象类 我们有的时候要判断是否为null或者 直接用 if (str != null && str.equals("")) {} 即可。 其他对象(容器)的话 就直接: if (obj != null){} 就完事了 ...

    注意 这里我们说的是对象 因为原始类型数据会自动默认值 所以永远无需担心。

    字符串作为特殊的对象类 我们有的时候要判断是否为null或者空
    直接用

    if (str != null && str.equals("")) {}
    

    即可。

    其他对象(容器)的话 就直接:

    if (obj != null){}
    

    就完事了

    展开全文
  • Java 判断一个对象中某一个属性是否为空 每次写博客都不知道咋开头…算了^_^ 直接说问题吧。就是验证一个对象中的一个属性的值是否为空。 自己在网上也找到了很多大神给的答案,有看到利用反射机制 public ...

    每次写博客都不知道咋开头…算了_ 直接说问题吧。就是验证一个对象中的一个属性的值是否为空。
    自己在网上也找到了很多大神给的答案,有看到利用反射机制

    public  boolean checkObjFieldIsNull(Object obj) throws IllegalAccessException {
    
        boolean flag = false;
        for(Field f : obj.getClass().getDeclaredFields()){
            f.setAccessible(true);
            log.info(f.getName());
            if(f.get(obj) == null){
                flag = true;
                return flag;
            }
        }
        return flag;
    }
    

    上面这一段代码,可以检验这个对象中是否有空值,但我想要的结果是判断其中的一个属性是否为空。显然这段神奇的代码解决不了问题。

    问题显然已经说清楚了,下面说一下答案!

    首先我需要检验的对象是一个Student类,并且Student类继承了Person类。代码如下所示

    public class Person {
        //姓名
        private String name;
        //性别
        private String sex;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", sex='" + sex + '\'' +
                    '}';
        }
    }
    
    public class student extends Person {
        //学号
        private String snum;
        // 学院
        private String scoll;
        // 班级
        private String sclass;
    
        public String getSnum() {
            return snum;
        }
    
        public void setSnum(String snum) {
            this.snum = snum;
        }
    
        public String getScoll() {
            return scoll;
        }
    
        public void setScoll(String scoll) {
            this.scoll = scoll;
        }
    
        public String getSclass() {
            return sclass;
        }
    
        public void setSclass(String sclass) {
            this.sclass = sclass;
        }
    
        @Override
        public String toString() {
            return "student{" +
                    "snum='" + snum + '\'' +
                    ", scoll='" + scoll + '\'' +
                    ", sclass='" + sclass + '\'' +
                    '}';
        }
    }
    

    前方高能~~~

    public class Test {
    
        public static void main(String[] args) {
            student student = new student();
            student.setName("这是姓名");//父类中的属性
            student.setSnum("这是学号");
            Map<String, Object> map = objToMap(student);
            System.out.println(null == map.get("name"));//不是空
            System.out.println(null == map.get("age"));//是空的
            System.out.println(null == map.get("snum"));//不是空的
            System.out.println(null == map.get("scoll"));//是空的
    
        }
    
    
        //将对象转成map
        private static Map<String, Object> objToMap(Object obj) {
            Map<String, Object> map = new HashMap<String, Object>();
            // 获取f对象对应类中的所有属性域
            Field[] fields = getAllFields(obj);
            for (int i = 0, len = fields.length; i < len; i++) {
                String varName = fields[i].getName();
                varName = varName.toLowerCase();//将key置为小写,默认为对象的属性
                try {
                    // 获取原来的访问控制权限
                    boolean accessFlag = fields[i].isAccessible();
                    // 修改访问控制权限
                    fields[i].setAccessible(true);
                    // 获取在对象f中属性fields[i]对应的对象中的变量
                    Object o = fields[i].get(obj);
                    if (o != null)
                        map.put(varName, o.toString());
                    // System.out.println("传入的对象中包含一个如下的变量:" + varName + " = " + o);
                    // 恢复访问控制权限
                    fields[i].setAccessible(accessFlag);
                } catch (IllegalArgumentException ex) {
                    ex.printStackTrace();
                } catch (IllegalAccessException ex) {
                    ex.printStackTrace();
                }
            }
            return map;
        }
    
        /**
         * 返回对象的Field(包括私有的和父类的)
         */
        public static Field[] getAllFields(Object object) {
            Class clazz = object.getClass();
            List<Field> fieldList = new ArrayList<>();
            while (clazz != null) {
                fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
                clazz = clazz.getSuperclass();
            }
            Field[] fields = new Field[fieldList.size()];
            fieldList.toArray(fields);
            return fields;
        }
    }
    

    解释一下:我先将一个对象转换成了一个map,然后通过key返回值判断是否为空,在这里使用objToMap()将对象转换成map,因为我的这个对象是集成的Person类,(通过getClass()方法来获取类的定义信息,通过定义信息再调用getFields()方法来获取类的所有公共属性,或者调用getDeclaredFields()方法来获取类的所有属性,包括公共,保护,私有,默认的方法,但是这里有一点要注意的是这个方法只能获取当前类里面显示定义的属性),所以我有使用了getAllFields()获取一个对象的所有属性。

    运行程序得到结果为

    false
    true
    false
    true
    

    下面在贴一下大神的回复,更便捷的方式

    if(StringUtils.isNotBlank(ObjectUtils.toString(student.getName),""))){} 
    
    展开全文
  • Java 判断对象及对象中属性是否为空

    万次阅读 2019-09-18 09:08:37
    import java.lang.reflect.Field; /** * Created by hj. */ public class VoUtilsTool { ... * @return 如果对象为空,且没有空值。返回false,对象为空或者有空值,返回true * */ public...
    package com.ax.util;
    
    import java.lang.reflect.Field;
    /**
     * Created by hj.
     */
    
    public class VoUtilsTool {
    /****
     * @param object 对象
     * @return 如果对象不为空,且没有空值。返回false,对象为空或者有空值,返回true
     * */
       public static boolean checkObjFieldIsNull(Object object) throws IllegalAccessException{
          boolean flag = false;
          if(null!=object){
             for(Field field : object.getClass().getDeclaredFields()){
                field.setAccessible(true);//在用反射时访问私有变量(private修饰变量)
                if(field.get(object) == null || field.get(object).equals("")){
                   flag = true;
                   return flag;
                }
                if(field.get(object) != null&&field.get(object).toString().trim().equals("")){
                   flag = true;
                   return flag;
                }
             }
          }else{
             flag=true;
          }
          return flag;
       }
    }
    
    展开全文
  • package com.nnhx.common.util; import ... ... import io.jsonwebtoken.lang.Strings; import java.util.ArrayList;...import java.util.Arrays;...import java.util.Collection;...import java.
  • 判断一个对象的所有属性是否为空 直接上代码 public static boolean allFieldIsNotNull(Object o) { try { for (Field field : o.getClass().getDeclaredFields()) { //把私有属性公有化 field.setAccessible...
  • Java判断对象是否为空的方法:isEmpty,null,"

    万次阅读 多人点赞 2019-01-08 17:39:05
    今天修改辞职同事遗留的代码才发现这个问题,不能用isEmpty来判断一个对象是否为null,之前没在意这个问题,在报了指针之后才发现这个问题。 查了一下关于判断为空的几个方法的区别,这里做一个简单的总结: null...
  • = null true的情况 下,进一步去判断对象的所有属性是否为null。 被判断的类对象,随便写的一个 针对第一种情况,直接使用null进行比较即可 但是,只要学过java的人都知道,这个判断永远都是true,因为上面...
  • 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判断一个对象是否全部为空

    千次阅读 2018-02-02 12:02:02
    public static boolean isField(Object object)throws Exception{ boolean flag = true; Class materual = (Class) object.getClass(); Field [] fs = materual.getDeclaredFields(); for (Field f
  • Java判断一个对象属性是否为空

    万次阅读 2017-05-18 14:54:46
    就是在服务端在返回数据结构时,有些字段有时返回有时不返回(根据字段值来决定);但客户端会用到这些字段当没有返回时就会报指针异常。... if (f.get(obj) == null) { //判断字段是否为空,并且对象
  • 废话不多说,直接上代码: public boolean checkObjFieldIsNull(Object obj) throws IllegalAccessException { boolean flag = false; for(Field f : obj.getClass()...可以封装到一个工具类中,作为公共方法。
  • java判断对象是否为空 在学习过程中遇到的一个小问题记录下来分享一下 在一个保存用户接口中,后端接收用户传递的对象调用对应的方法进行保存,前端使用vue进行开发。前端传递的对象有可能未初始化对象,所以后端...
  • //判断对象是否: 返回ture表示所有属性null  返回false表示不是所有属性都是null public static boolean isAllFieldNull(Object obj) throws IllegalAccessException { Class<?> aClass ...
  • 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判断对象是否为空的方法

    千次阅读 2018-07-03 16:30:30
    1、判断list是否为空(Map、Set同list) if(list != null &amp;&amp; list.size() == 0){ } if(list != null &amp;&amp; !list.isEmpty()){ } list!=null:判断是否存在list,null表示这list...
  • 参考链接: https://developer.aliyun.com/ask/62145?spm=a2c6h.13159736 ... 问题分析: //判断1 : 这里会返回 true User user = null; if(user == null){ return...
  • 有时候数据库中的某些字段值要求不为空,所以代码中要判断这些字段对应的属性值是否为空,当对象属性过多时,一个一个属性去判断,会显得代码冗余,所以,可以借助工具类 package ...
  • 在项目中,很多情况下需要通过接口获得数据,数据类型包括Map<String, Object> 或者 JSONObject ,然后get某个属性; 例如:Object object = get("name")...所以,需要对object 进行非空判断 需要用到:lan...
  • java 判断对象是否为空

    千次阅读 2019-01-02 13:15:54
    Java判断对象是否为空的方法 版权声明:本文博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/hxxanyifree/article/details/72312509 首先来看一下工具StringUtils的判断方法:  种是org....
  • Optional.ofNullable(user).ifPresent(u-> { // TODO: do something } );
  • java8判断对象是否为空新写法

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

    万次阅读 2018-05-30 10:23:33
    1、 位于org.apache.commons.lang包下 StringUtils  public   class  StringUtilsTest {      public ... System.out.println(StringUtils.isEmpty( ...org.apache.commons.lang3包...ObjectUtils 判断对象是否为空 
  • java判断object对象为为空

    千次阅读 2020-09-16 11:36:39
    这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、...
  • 首先需要理解null和“ ”的区别: null表示这个字符串在栈中没有任何指向因此在堆中没有分配内存空间,如果要调用这个字符串会出现指针... 判断一个对象是否“” 用eques() 判断一个字符串是否是null 用 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 342,594
精华内容 137,037
关键字:

java判断一个对象是否为空

java 订阅