精华内容
下载资源
问答
  • 判断string对象是否为空
    千次阅读
    2018-06-09 08:47:42

    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)这个方法都能搞定。

    更多相关内容
  • 如何判断java对象是否为空

    千次阅读 2021-02-28 13:16:10
    首先来看一下工具StringUtils的判断方法:一种是org.apache....这两种StringUtils工具类判断对象是否为空是有差距的:StringUtils.isEmpty(CharSequence cs); //org.apache.commons.lang3包下的StringUtils类,判...

    a4787605c336c83cc804ffe2de4d8b07.png

    首先来看一下工具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)这个方法都能搞定。

    接下来就是判断数组是否为空list.isEmpty(); //返回boolean类型。

    判断集合是否为空

    例1、判断集合是否为空:CollectionUtils.isEmpty(null): true

    CollectionUtils.isEmpty(new ArrayList()): true

    CollectionUtils.isEmpty({a,b}): false

    例2、判断集合是否不为空:CollectionUtils.isNotEmpty(null): false

    CollectionUtils.isNotEmpty(new ArrayList()): false

    CollectionUtils.isNotEmpty({a,b}): true

    2个集合间的操作:

    集合a: {1,2,3,3,4,5}

    集合b: {3,4,4,5,6,7}CollectionUtils.union(a, b)(并集): {1,2,3,3,4,4,5,6,7}

    CollectionUtils.intersection(a, b)(交集): {3,4,5}

    CollectionUtils.disjunction(a, b)(交集的补集): {1,2,3,4,6,7}

    CollectionUtils.disjunction(b, a)(交集的补集): {1,2,3,4,6,7}

    CollectionUtils.subtract(a, b)(A与B的差): {1,2,3}

    CollectionUtils.subtract(b, a)(B与A的差): {4,6,7}

    php中文网,大量的免费Java入门教程,欢迎在线学习!

    展开全文
  • java判断字符串String是否为空

    千次阅读 2021-12-08 18:23:52
    字符串判的小结

    1、判空的四个方法

    1、str == null;
    //length就是取得字符串的长度
    2、str.length == 0;
    3"".equals(str);
    //StringUtils.isEmpty判断某字符串是否为空,为空的标准是 str==null 或 str.length()==0
    4、StringUtils.isEmpty(str);
    

    //通过StringUtils判断是否为空(优先推荐使用org.apache.commons.lang包下的StringUtils来判断,原因是:用StringUtils可以避免空指针问题)

    2、区别

    ==和equals

    == 是java提供的等于比较运算符,用来比较两个变量指向的内存地址是否相同
    对于基本类型和引用类型 == 的作用效果是不同的,如下所示:

    基本类型:比较的是值是否相同;
    引用类型:比较的是引用是否相同;
    

    代码示例:

    String x = "string";
    String y = "string";
    String z = new String("string");
    System.out.println(x==y); // true
    System.out.println(x==z); // false
    System.out.println(x.equals(y)); // true
    System.out.println(x.equals(z)); // true
    

    equals() 是Object提供的一个方法.Object中equals()方法的默认实现就是返回两个对象==的比较结果.但是equals()可以被重写,所以我们在具体使用的时候需要关注equals()方法有没有被重写.
    equals 解读

    equals 本质上就是 ==,只不过 String 和 Integer 等重写了 equals 方法,把它变成了值比较。看下面的代码就明白了。

    首先来看默认情况下 equals 比较一个有相同值的对象,代码如下:

    class Cat {
        public Cat(String name) {
            this.name = name;
        }
    
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
    Cat c1 = new Cat("王磊");
    Cat c2 = new Cat("王磊");
    System.out.println(c1.equals(c2)); // false
    

    输出结果出乎我们的意料,竟然是 false?这是怎么回事,看了 equals 源码就知道了,源码如下:

    public boolean equals(Object obj) {
    		return (this == obj);
    }
    

    原来 equals 本质上就是 ==。

    那问题来了,两个相同值的 String 对象,为什么返回的是 true?代码如下:

    String s1 = new String("老王");
    String s2 = new String("老王");
    System.out.println(s1.equals(s2)); // true
    

    同样的,当我们进入 String 的 equals 方法,找到了答案,代码如下:

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
    

    原来是 String 重写了 Object 的 equals 方法,把引用比较改成了值比较。

    代码解读:因为 x 和 y 指向的是同一个引用,所以 == 也是 true,而 new String()方法则重写开辟了内存空间,所以 == 结果为 false,而 equals 比较的一直是值,所以结果都为 true。
    注意:== 对于基本类型来说是值比较,对于引用类型来说是比较的是引用;而 equals 默认情况下是引用比较,只是很多类重写了 equals 方法,比如 String、Integer 等把它变成了值比较,所以一般情况下 equals 比较的是值是否相等。

    null和“”

    1、null表示这个字符串不指向任何的东西,如果这时候你调用它的方法,那么就会出现空指针异常。
    2、"“表示它指向一个长度为0的字符串,这时候调用它的方法是安全的。
    3.、null不是对象,”“是对象,所以null没有分配空间,”"分配了空间,例如:

      String str1 = null; str引用为空
     String str2 = ""; str引用一个空串
    

    即可知:对象用equals比较,null用双等号比较。
    例子:判断字符串是否为空

    正确的写法是 if(str1==null || str1.equals("")),
    

    先判断是不是对象,如果是,再判断是不是空字符串
    同理 判断一个字符串是否为空,首先就要确保他不是null,然后再判断他的长度。

        String str = xxx;
      if(str == null && str.length() == 0{ }
    

    3、推荐使用

    方法一: 最多人使用的一个方法, 直观, 方便, 但效率很低: if(s == null || s.equals(""));

    方法二: 比较字符串长度, 效率高, 是我知道的最好一个方法: if(s == null || s.length() == 0);

    方法三: Java SE 6.0 才开始提供的方法, 效率和方法二几乎相等, 但出于兼容性考虑, 推荐使用方法二. if(s == null || s.isEmpty());

    方法四: 这是一种比较直观,简便的方法,而且效率也非常的高,与方法二、三的效率差不多: if (s == null || s == “”);

    使用StringUtils进行判断

    StringUtils.isBlank(null) = true
    
    StringUtils.isBlank("") = true
    
    StringUtils.isBlank(" ") = true
    
    StringUtils.isBlank("sdf") = false
    
    StringUtils.isBlank(" sdf ") = false
    

    参考链接:

    https://blog.csdn.net/weixin_41404773/article/details/79558355
    

    如有侵权,请告知删除!

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

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

    展开全文
  • 1、isEmpty(判断string是否为空) StringUtils.isEmpty(null) = true StringUtils.isEmpty("") = true StringUtils.isEmpty(" ") = false //注意在 StringUtils 中空格作非空处理 StringUtils.isEmpty("aa") = ...
  • 首先来看一下工具StringUtils的判断方法:一种是org.apache....这两种StringUtils工具类判断对象是否为空是有差距的:StringUtils.isEmpty(CharSequence cs); //org.apache.commons.lang3包下的StringUtils类,判...
  • 判断String是否为空的几种方法 判断某字符串是否为空为空的标准是 str==null 或 str.length()==0 基本的知识 (1)String str1 = null; 表示str1的引用为空,他没有地址, 他是一个没有被实例化的对象 (2)String ...
  • java判断对象是否为空

    千次阅读 2021-02-12 10:58:03
    对 Java 语言来说,一切皆是对象。把现实世界中的对象抽象地体现在编程世界中,一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计,这些对象可以是独立存在的,也可以是从别的对象继承过来的。对象...
  • java 判断对象是否为空.如String,Character,Object[]
  • c++ string判断字符串是否为空

    千次阅读 2022-05-09 11:06:05
    string类是C++STL类之一,有很丰富的接口,判断string为空是常用操作。 判断string为空就是元素个数0。 我一开始使用的是: str == NULL 这是不正确的!!!因为,NULL一般只和指针比较或者赋给指针,string...
  • Java判断对象是否为空

    千次阅读 2021-07-27 20:25:36
    Java方法isEmpty汇总问题描述参考资料 问题描述  。 参考资料 java判断一个字符串是否为空,isEmpty和isBlank的区别 Java判断对象是否为空的方法:isEmpty,null," " Java中判断数组是否为空
  • java判断对象是否为空的方法

    千次阅读 2021-03-14 00:19:01
    java判断对象是否为空的方法发布时间:2020-06-25 14:39:17来源:亿速云阅读:134作者:Leah这篇文章将大家详细讲解有关java判断对象是否为空的方法,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读...
  • Object.keys(xxx).length==0 js判断对象是否为空对象的几种方法 1.将json对象转化json字符串,再判断该字符串是否为"{}" var data = {}; var b = (JSON.stringify(data) == "{}"); alert(b);//true 2...
  • java对象如何判断是否为空

    千次阅读 2021-03-06 15:47:58
    下面我们来看一下java中判断对象是否为空的方法:(推荐:java视频教程)首先来看一下工具StringUtils的判断方法:一种是org.apache.commons.lang3包下的;另一种是org.springframework.util包下的。这两种StringUtils...
  • String字符串判定是否为空方法总结

    万次阅读 2015-10-13 16:28:39
    Java中判断String字符串不为空的方法一、判断一个字符串str不为空的方法有: 1. str!=null;(前提条件) 2. “”.equals(str); 3. str.length()!=0;( 注意:length是属性,一般集合类对象拥有的属性,取得集合...
  • 1、判断实体对象是否为空2、判断对象所有属性是否为空3、特别注意,实体类中如果有基本数据类型,会影响判断package com.liuxd.object;import org.apache.commons.lang3.StringUtils;import java.lang.reflect.Field...
  • ① 字符串对象有初始值且不null时使用:object.Length() == 0      Tips:此方法效率最高但在使用时可能产生异常。...③ 判断字符串对象是否存在以及是否为空string.IsN
  • Java判断对象是否为空(包括null ,"")的方法本文实例大家分享了Java判断对象是否为空的具体代码,供大家参考,.../*** 判断对象是否为空** @author Rex**/public class EmptyUtil{/*** 判断对象为空** @param obj* ...
  • java8判断对象是否为空新写法

    千次阅读 2022-04-19 10:37:39
    1、我们为了避免指针异常,通常会做一些非空的判断,通常写法如下 Object o = ... if(o != null){ do something ... } 2、java8 提供了一种更加优美的写法 @Test public void testOptional() { String strArr[]...
  • 判断String是否为空,或者Null

    万次阅读 2019-03-27 08:46:39
    判断str是否为空 if(str.length()==0) 或 if(str.equals("") 判断str是否为null if(str==null) 检验一个字符串既不是空串也不是null if(str!=null&&str.length()!=0) 注意:只有对象可以null,基本...
  • java中判断对象是否为空的方法

    千次阅读 2021-02-12 13:21:06
    判断Java对象是否为null的方法:首先,直接使用 object == null 去判断对象为null的时候返回true,不null的时候返回false。然后,在object != null true的情况下,进一步去判断对象.../*** 判断对象是否为空**...
  • int [] array数组为空的条件: if( array==null||array.length==0)String str字符串为空的条件: if(str == null || str.length() == 0);s==null是有必要存在的。1.如果想调用一个方法,首先要有一个对象,但是null并...
  • String判断是否为空的方式

    千次阅读 2017-08-01 14:32:21
    一、判断一个字符串str不为空的方法有:  1、str == null;  2、"".equals(str);  3、str.length  4、str.isEmpty();  注意:length是属性,一般集合类对象拥有的属性,取得集合的大小。 ...
  • 1.判断对象String是否为空利用工具类 StringUtils的判断方法StringUtils.isEmpty(CharSequence cs); //org.apache.commons.lang3包下的StringUtils类,判断是否为空的方法参数是字符序列类,也就是String类型 ...
  • 判断Object对象是否为空

    千次阅读 2021-06-16 14:44:03
    从Map<String,Object>中根据key值取出来的value默认是Object类型 public static boolean isEmpty(Object obj){ //Object类型判是和null进行对比 if (obj == null){  ... //判断list是都为空是从 list集
  • 1、判断实体对象是否为空2、判断对象所有属性是否为空3、特别注意,实体类中如果有基本数据类型,会影响判断package com.liuxd.object;import org.apache.commons.lang3.StringUtils;import java.lang.reflect.Field...
  • 怎么判断一个对象里的属性是否为空的怎么判断一个对象里的属性是否为空的,或者判断对象是否是一个实体!------解决方案--------------------引用:怎么判断一个对象里的属性是否为空的,或者判断对象是否...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 490,560
精华内容 196,224
热门标签
关键字:

判断string对象是否为空