精华内容
下载资源
问答
  • 以object类为对象,判断是否为空时,直接== 或者equals()会报错 本文章主要解决: 返回List<Map<String,Object>> list 的一个list 获得对象是list.get(i).get(“xxx”),该对象object对象 判断...

    以object类为对象,判断其是否为空时,直接== 或者equals()会报错
    本文章主要解决:
    返回为List<Map<String,Object>> list 的一个list
    获得对象是list.get(i).get(“xxx”),该对象为object对象
    判断是否为空时,可以使用ObjectUtils…toString(object,null)
    不为空时返回String类型值
    为空时返回null
    可以直接if判断即可。

    展开全文
  • java判断是否为空工具类判断为空

    千次阅读 2019-07-10 10:47:48
    package brilliance.znjt.serviceratingservice.utils; import java.util.Date; import java.util.List; import java.util.Map; import java.util.Set; ... * 对象是否为空 * @param obj St...
    package brilliance.znjt.serviceratingservice.utils;
    
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    public class xx {
    	
    	
    	/**
    	 * 对象是否为空
    	 * @param obj String,List,Map,Object[],int[],long[]
    	 * @return
    	 */
    	@SuppressWarnings("rawtypes")
    	public static boolean isEmpty(Object o) {
    		if (o == null) {
    			return true;
    		}
    		if (o instanceof String) {
    			if (o.toString().trim().equals("")||o.toString().trim().equals("null")) {
    				return true;
    			}
    		} else if (o instanceof List) {
    			if (((List) o).size() == 0) {
    				return true;
    			}
    		} else if (o instanceof Map) {
    			if (((Map) o).size() == 0) {
    				return true;
    			}
    		} else if (o instanceof Set) {
    			if (((Set) o).size() == 0) {
    				return true;
    			}
    		} else if (o instanceof Object[]) {
    			if (((Object[]) o).length == 0) {
    				return true;
    			}
    		} else if (o instanceof int[]) {
    			if (((int[]) o).length == 0) {
    				return true;
    			}
    		} else if (o instanceof long[]) {
    			if (((long[]) o).length == 0) {
    				return true;
    			}
    		} else if(o instanceof Integer) {
    			if (o.toString().trim().equals("0")) {
    				return true;
    			}
    		}
    		return false;
    	}
    
    	/**
    	 * 对象组中是否存在 Empty Object
    	 * @param os 对象组
    	 * @return
    	 */
    	public static boolean isOneEmpty(Object... os) {
    		for (Object o : os) {
    			if(isEmpty(o)){
    				return true;
    			}
    		}
    		return false;
    	}
    
    	/**
    	 * 对象组中是否全是 Empty Object
    	 * @param os
    	 * @return
    	 */
    	public static boolean isAllEmpty(Object... os) {
    		for (Object o : os) {
    			if (!isEmpty(o)) {
    				return false;
    			}
    		}
    		return true;
    	}
    	
    	/**
    	 * 是否为数字
    	 * @param obj
    	 * @return
    	 */
    	public static boolean isNum(Object obj) {
    		try {
    			Integer.parseInt(obj.toString());
    		} catch (Exception e) {
    			return false;
    		}
    		return true;
    	}
    	
    	/**
    	 * 字符串是否为 true
    	 * @param str
    	 * @return
    	 */
    	public static boolean isTrue(Object str) {
    		if (isEmpty(str)) {
    			return false;
    		}
    		str = str.toString().trim().toLowerCase();
    		if (str.equals("true") || str.equals("on")) {
    			return true;
    		}
    		return false;
    	}
    
    	/**
    	 * 格式化字符串->'str'
    	 * @param str
    	 * @return
    	 */
    	public static String format(Object str) {
    		return "'" + str.toString() + "'";
    	}
    
    	/**
    	 * 强转->Integer
    	 * @param obj
    	 * @return
    	 */
    	public static Integer toInt(Object obj) {
    		return Integer.parseInt(obj.toString());
    	}
    
    	/**
    	 * 强转->Integer
    	 * @param obj
    	 * @param defaultValue
    	 * @return
    	 */
    	public static Integer toInt(Object obj, int defaultValue) {
    		if (isEmpty(obj)) {
    			return defaultValue;
    		}
    		return toInt(obj);
    	}
    
    	/**
    	 * 强转->Long
    	 * @param obj
    	 * @return
    	 */
    	public static long toLong(Object obj) {
    		return Long.parseLong(obj.toString());
    	}
    
    	/**
    	 * 强转->Long
    	 * @param obj
    	 * @param defaultValue
    	 * @return
    	 */
    	public static long toLong(Object obj, long defaultValue) {
    		if (isEmpty(obj)) {
    			return defaultValue;
    		}
    		return toLong(obj);
    	}
    
    	/**
    	 * 强转->Double
    	 * @param obj
    	 * @return
    	 */
    	public static double toDouble(Object obj) {
    		return Double.parseDouble(obj.toString());
    	}
    	
    	/**
    	 * 强转->Boolean
    	 * @param obj
    	 * @return
    	 */
    	public static Boolean toBoolean(Object obj) {
    		return Boolean.parseBoolean(obj.toString());
    	}
    	
    	/**
    	 * 强转->Boolean
    	 * @param obj
    	 * @param defaultValue
    	 * @return
    	 */
    	public static Boolean toBoolean(Object obj, Boolean defaultValue) {
    		if (isEmpty(obj)) {
    			return defaultValue;
    		}
    		return toBoolean(obj);
    	}
    	
    	/**
    	 * 强转->java.util.Date
    	 * @param str 日期字符串
    	 * @return
    	 */
    	public static Date toDate(String str) {
    		try {
    			if (str == null || "".equals(str.trim()))
    				return null;
    			return new java.text.SimpleDateFormat("yyyy-MM-dd").parse(str.trim());
    		} catch (Exception e) {
    			throw new RuntimeException("Can not parse the parameter \"" + str + "\" to Date value.");
    		}
    	}
    	
    	/**
    	 * Array转字符串(用指定符号分割)
    	 * @param array
    	 * @param sign
    	 * @return
    	 */
    	public static String join(Object[] array, char sign) {
    		if (array == null) {
    			return null;
    		}
    		int arraySize = array.length;
    		int bufSize = (arraySize == 0 ? 0 : ((array[0] == null ? 16 : array[0].toString().length()) + 1) * arraySize);
    		StringBuilder sb = new StringBuilder(bufSize);
    
    		for (int i = 0; i < arraySize; i++) {
    			if (i > 0) {
    				sb.append(sign);
    			}
    			if (array[i] != null) {
    				sb.append(array[i]);
    			}
    		}
    		return sb.toString();
    	}
    	
    	/**
    	 * 删除末尾字符串
    	 * @param str 待处理字符串
    	 * @param sign 需要删除的符号
    	 * @return
    	 */
    	public static String delEnd(String str, String sign){
    		if (str.endsWith(sign)) {
    			return str.substring(0, str.lastIndexOf(sign));
    		}
    		return str;
    	}
    
    	
    	
    	
    	/**
    	 * 消耗毫秒数
    	 * @param time
    	 */
    	public static void costTime(long time) {
    		System.err.println("Load Cost Time:" + (System.currentTimeMillis() - time) + "ms\n");
    	}
    	
    	/**
    	 * 格式化输出JSON
    	 * @param json
    	 * @return
    	 */
    	public static String formatJson(String json) {
    		int level = 0;
    		StringBuffer sb = new StringBuffer();
    		for (int i = 0; i < json.length(); i++) {
    			char c = json.charAt(i);
    			if (level > 0 && '\n' == sb.charAt(sb.length() - 1)) {
    				sb.append(getLevelStr(level));
    			}
    			switch (c) {
    			case '{':
    			case '[':
    				sb.append(c + "\n");
    				level++;
    				break;
    			case ',':
    				sb.append(c + "\n");
    				break;
    			case '}':
    			case ']':
    				sb.append("\n");
    				level--;
    				sb.append(getLevelStr(level));
    				sb.append(c);
    				break;
    			default:
    				sb.append(c);
    				break;
    			}
    		}
    		return sb.toString();
    	}
        
        private static String getLevelStr(int level){
            StringBuffer levelStr = new StringBuffer();
            for(int levelI = 0;levelI<level ; levelI++){
                levelStr.append("  ");
            }
            return levelStr.toString();
        }
        
        public static int getCount(String str,String scan){
            int count = 0;
            int index = 0;
            while(((index = str.indexOf(scan)) != -1)){
                //想个办法截取字符串中查找字符,并将查找当前匹配字符之后的字符串重新
                //赋值给字符串
                str = str.substring(index+1);
                count++;
            }
            return count;
        }
    
    
        
        
      
    }

     

    展开全文
  • 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()就可以返回属性描述器。
    由于没有太多研究就不多介绍了。
    如果你还有其他方法判断一个对象是否为空请留言,谢谢

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

    展开全文
  • 判断是否为空的常用工具

    千次阅读 2018-11-12 11:10:31
    判断实体列表是否为空,可以用 org.apache.commons.collections中的CollectionUtils.isNotEmpty(name)

    User user = new User();
    List list = new ArrayList<>();
    判断实体类列表是否为空,可以用
    org.apache.commons.collections中的CollectionUtils.isNotEmpty(list)
    判断实体类是否为空,可用
    org.apache.commons.lang3中的StringUtils.isNoneEmpty(user)

    判断Integer是否为空
    Objects.isNull(sealApply.getId());

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

    千次阅读 2016-06-03 15:02:17
    遍历文件夹,除“.”和“..”以外,还有文件,说明不为空。二、实现1. Platform SDK的两函数:FindFirstFile()和FindNextFile() BOOL IsFolderEmpty(WCHAR* szPath) { WCHAR szFind[MAX_PATH] = {0}; WIN32_...
  • 字符串作为特殊的对象 我们有的时候要判断是否为null或者 直接用 if (str != null && str.equals("")) {} 即可。 其他对象(容器)的话 就直接: if (obj != null){} 就完事了 ...
  • Java中判断实体类是否为空

    千次阅读 2020-04-14 10:27:48
    public static boolean checkObjFieldIsNotNull(Object obj) { // true 不为空 false 为空 boolean flag = false; try { for (Field f : obj.getClass().getDeclaredFields()) { f.setAc...
  • //判断该对象是否: 返回ture表示所有属性null  返回false表示不是所有属性都是null public static boolean isAllFieldNull(Object obj) throws IllegalAccessException { Class<?> aClass ...
  • Java 判断实体属性是否为空工具

    万次阅读 2019-05-21 17:13:00
    * 判断对象是否为空 * @param obj * @return */ public static Boolean isNotEmptyBean(Object obj) { Boolean flag = false; try { if (null != obj){ //得到对象 Class<?> c = (Class) obj.getClass...
  • 判断集合是否为空: 方法: CollectionUtils.isEmpty(集合); 判断集合是否为空 方法: CollectionUtils.isNotEmpty(集合);
  • Java判断一个对象属性是否为空

    万次阅读 2017-05-18 14:54:46
    就是在服务端在返回数据结构时,有些字段有时返回有时不返回(根据字段值来决定);但客户端会用到这些字段当没有返回时就会报指针异常。... if (f.get(obj) == null) { //判断字段是否为空,并且对象属
  • 有一些业务场景下,我们需要判断某个对象的属性是否全部为空。该怎么做呢? 马上能想到的一个方案是,一个一个判断对象中的属性。这个倒也可以,但是如果要判断的对象比较多,就得给每个对象写一个判断方法(因为每...
  • StringUtils.isBlank(str)//判断某个字符串是否为空的标准是str==null或者str.length==0或者是str==""; StringUtils.isEmpty(str);//判断某个字符串是否为空的标准是str==null或者str.length==0 把一个字符串按...
  • 1、isEmpty(判断string是否为空) StringUtils.isEmpty(null) = true StringUtils.isEmpty("") = true StringUtils.isEmpty(" ") = false //注意在 StringUtils 中空格作非空处理 StringUtils.isEmpty("aa") = ...
  • 判断对象是否为空工具

    千次阅读 2018-06-04 23:10:31
    用Spring的Assert(断言机制)public ... * 判断一个对象是否为空 * @param obj * @param msg * @return */ public static boolean isNotNull(Object obj, String msg) { Boolean checkState = Bool...
  • 有时候数据库中的某些字段值要求不为空,所以代码中要判断这些字段对应的属性值是否为空,当对象属性过多时,一个一个属性去判断,会显得代码冗余,所以,可以借助工具 package ...
  • 判断一个对象的各个属性是否为空的方法://查询出对象所有的属性 Field[] fields = obj.getClass().getDeclaredFields(); //用于判断所有属性是否为空,如果参数为空则不查询 boolean flag = false; for (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 工具】集合判断是否为空

    千次阅读 2020-09-14 13:46:03
    比如:判断list是否为空,通过我们是这样判断的: if(null != list && list.size() > 0){ // ... } 写多了,就感觉太繁琐了。然后list里面自带的有这样一个方法: list.isEmpty() 它可以判断list是否...
  • 判断对象或者对象数组是否为空的工具
  • 1. isEmpty() 用于判断List内容是否为空,即list里一个元素也没有,但是必须在 List&lt;MallNews&gt; getNewsList 本身不是的引用的情况下才行。即对象本身不能是对象。2.null一般判断该List的引用也...
  • 因为JS 中判断一个字段是否为空非常复杂,涉及到undefined等多种情况,特此写了一个工具方法,使用简单,判断全面,避免重复造轮子~ /** * 用于判断空,Undefined String Array Object Number boolean */ ...
  • java 判断对象是否为空

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

    千次阅读 2019-07-04 10:54:39
    今天无意之间发现使用Object.requireNonNull(Object o)方法可以判断个类是否为空如果O为空则会抛出指针异常
  • 一.代码: package com.example.demo.jdk8... import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map;...public class CheckNOtNullUtils { ... * 判断一个对象中的某些字段是否为空 * * @p...
  • 判断集合是否为空 、 工具

    千次阅读 2016-09-21 11:09:00
    /** * 判断集合是否为空 * * @param list * 集合 */ public static boolean isEmpty(List list) { if (list != null && list.size() > 0) { ...
  • 废话不多说,直接上代码: public boolean checkObjFieldIsNull(Object obj) throws IllegalAccessException { boolean flag = false; for(Field f : obj.getClass()...可以封装到一个工具中,作为公共方法。
  • 判断Object类型的数据是否为空

    千次阅读 2019-03-27 10:06:02
    今天就给他家推荐一个封装好的判断object类型的数据是否为空的Utils /** * 判断对象是否为空或null */ public class ObjectUtils { public static boolean isNull(Object obj) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 720,432
精华内容 288,172
关键字:

判断一个类是否为空