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

    千次阅读 2018-06-09 08:47:42
    String对象中有一个isEmpty的方法判断是否为,其实isEmpty完全等同于string.length()==0,注意如果String本身是null,那么使用string.isEmpty()会报指针异常(NullPointerException)判断一个String为的最安全...

    Java原生的方法:

    String对象中有一个isEmpty的方法判断是否为空,其实isEmpty完全等同于string.length()==0,注意如果String本身是null,那么使用string.isEmpty()会报空指针异常(NullPointerException)判断一个String为空的最安全的方法,还是string ==null || string.isEmpty()

    工具StringUtils的判断方法: 

    一种是org.apache.commons.lang3包下的; 

    另一种是org.springframework.util包下的。这两种StringUtils工具类判断对象是否为空是有差距的:

    StringUtils.isEmpty(CharSequence cs); //org.apache.commons.lang3包下的StringUtils类,判断是否为空的方法参数是字符序列类,也就是String类型
    StringUtils.isEmpty(Object str); //而org.springframework.util包下的参数是Object类,也就是不仅仅能判断String类型,还能判断其他类型,比如Long等类型。

    从上面的例子可以看出第二种的StringUtils类更实用。

    下面来看一下org.apache.commons.lang3的StringUtils.isEmpty(CharSequence cs)源码:

    public static boolean isEmpty(final CharSequence cs) {
            return cs == null || cs.length() == 0;
    }

    接下来是org.springframework.util的StringUtils.isEmpty(Object str)源码:

    public static boolean isEmpty(Object str) {
            return (str == null || "".equals(str));
    }

    基本上判断对象是否为空,StringUtils.isEmpty(Object str)这个方法都能搞定。

    展开全文
  • 判断对象或者对象数组是否为的工具类。

    判断对象或者对象数组是否为空。

    package com.kinth.common.util;
    
    import java.util.List;
    import java.util.Map;
    
    public class ParamValidator {
    
        public static boolean isNullOrEmptyObject(Object obj) {
            return obj == null || obj.toString().trim().isEmpty();
        }
    
        public static boolean isNullOrEmptyArray(Object[] array) {
            if(array == null) {
                return true;
            }
    
            if(array.length ==0) {
                return true;
            }
    
            boolean eachItemIsNull = true;
            for(Object item:array) {
                if(item != null) {
                    eachItemIsNull = false;
                }
            }
            return eachItemIsNull;
        }
    
        public static boolean isNullOrEmptyList(List<?> list) {
            if(list == null) {
                return true;
            }
    
            if(list.isEmpty()) {
                return true;
            }
    
            boolean eachItemIsNull = true;
            for(Object item:list) {
                if(item != null) {
                    eachItemIsNull = false;
                }
            }
            return eachItemIsNull;
        }
    
        public static boolean isNullOrEmptyMap(Map<?,?> map) {
            if(map == null) {
                return true;
            }
    
            if(map.isEmpty()) {
                return true;
            }
    
            return false;
        }
    }
    
    展开全文
  • java 判断对象是否为

    万次阅读 2014-04-26 11:25:02
    java 中如何判断对象是否为呢,特别是一个weizhi
  • java判断空字符串和对象是否为null

    千次阅读 2017-07-06 14:35:45
    判断空字符串: StringUtils.isEmpty(str); 判断对象为null: Objects.isNull(object); 判断对象不为null: Objects.nonNull(object);
  • Java 判断一个对象中某一个属性是否为 每次写博客都不知道咋开头…算了^_^ 直接说问题吧。就是验证一个对象中的一个属性的值是否为。 自己在网上也找到了很多大神给的答案,有看到利用反射机制 public ...
  • Java 判断实体对象及所有属性是否为

    万次阅读 多人点赞 2018-11-02 22:12:30
    1、判断实体对象是否为 2、判断对象所有属性是否为 3、特别注意,实体类中如果有基本数据类型,会影响判断 package com.liuxd.object; import org.apache.commons.lang3.StringUtils; import java.lang....
  • java判断对象是否为 在学习过程中遇到的一个小问题记录下来分享一下 在一个保存用户接口中,后端接收用户传递的对象调用对应的方法进行保存,前端使用vue进行开发。前端传递的对象有可能为未初始化对象,所以后端...
  • Java判断一个对象属性是否为

    万次阅读 2017-05-18 14:54:46
    就是在服务端在返回数据结构时,有些字段有时返回有时不返回(根据字段值来决定);但客户端会用到这些字段当没有返回时就会报指针异常。... if (f.get(obj) == null) { //判断字段是否为,并且对象
  • public static boolean isEmpty(final CharSequence cs) { return cs == null || cs.length() == 0; }
  • 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
  • 废话不多说,直接上代码: public boolean checkObjFieldIsNull(Object obj) throws IllegalAccessException { boolean flag = false; for(Field f : obj.getClass()...可以封装到一个工具类中,作为公共方法
  • java 判断Object对象是否为或者字符串 /** * 判断Object对象字符串 * @param obj * @return */ public static Boolean isObjectNotEmpty(Object obj) { String str = ObjectUtils.toString(obj,...
  • 判断对象不为null:Objects.nonNull(obj); 判断对象为null: Objects.isNull(obj); 判断空字符串: StringUtils.isEmpty(str);
  • 判断一个对象的所有属性是否为 直接上代码 public static boolean allFieldIsNotNull(Object o) { try { for (Field field : o.getClass().getDeclaredFields()) { //把私有属性公有化 field.setAccessible...
  • 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 ...
  • // 这里会报指针,即null不能使用此方法 System.out.println("c == null and c.isEmpty"); }*/ List<String> list = new ArrayList<>(); //list.add(""); if (list.isEmpty()) { ...
  • java空对象

    千次阅读 2018-10-18 14:33:47
     当使用null表示缺少对象时,在每次引用前都要测试其是否为null,因此需要在代码中加入判断语句,当判断语句变多时,代码就变得杂乱,使用空对象可以减少判断的语句。 例子:  假如有一个Person类,Person类有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 335,012
精华内容 134,004
关键字:

java判断空方法对象

java 订阅