Java 检查字符串是否不为null且不为空

如何检查字符串是否为空

public void doStuff(String str)
{
    if (str != null && str != "**here I want to check the 'str' is empty or not**")
    {
        /* handle empty string */
    }
    /* ... */
}

或者

str != null && !str.equals("")

或

注意：第二个检查（第一个和第二个选项）假设str不为null。这是可以的，因为第一次检查就是这样做的（如果第一次检查为false，Java不会进行第二次检查）

重要提示：不要使用==表示字符串相等检查指针是否相等，而不是值是否相等。两个字符串可以位于不同的内存地址（两个实例），但具有相同的值

那么：

if(str!= null && str.length() != 0 )

那怎么办

请确保按此顺序使用

&&

的部分，因为如果

&&&

的第一部分失败，java将不会继续计算第二部分，从而确保如果

str.isEmpty（）

为null，则不会从

str.isEmpty（）中获得null指针异常

注意，它只在JavaSE1.6之后才可用。您必须在以前的版本中检查
str.length（）==0


要同时忽略空白，请执行以下操作：

if(str != null && !str.trim().isEmpty())

Function<String, Boolean> isNotEmpty = s -> s != null && !"".equals(s)

（因为Java 11
str.trim（）.isEmpty（）
可以简化为
str.isBlank（）
，这也将测试其他Unicode空格）

包装在一个方便的功能中：

public static boolean empty( final String s ) {
  // Null-safe, short-circuit evaluation.
  return s == null || s.trim().isEmpty();
}

if(!StringUtils.areSet(firstName,lastName,address)
{
    //do something
}

变成：

if( !empty( str ) )

使用
我喜欢将Apache用于这类事情，尤其是实用程序类：

import org.apache.commons.lang.StringUtils;

if (StringUtils.isNotBlank(str)) {
    ...
} 

if (StringUtils.isBlank(str)) {
    ...
} 

我所知道的几乎每个库都定义了一个名为
StringUtils
、
StringUtil
或
StringHelper
的实用程序类，它们通常包含您正在寻找的方法

我个人最喜欢的是，在课堂上，你可以同时获得

和
方法
（第一个检查字符串是否为null或空，第二个检查字符串是否为null、空或仅为空白）

Spring、Wicket和许多其他LIB中都有类似的实用程序类。如果不使用外部库，可能需要在自己的项目中引入StringUtils类。


更新：很多年过去了，现在我推荐使用的方法。
正如seanizer在上面所说的，ApacheStringutils在这方面非常棒，如果你要包括番石榴，你应该做以下几点

public List<Employee> findEmployees(String str, int dep) {
 Preconditions.checkState(StringUtils.isNotBlank(str), "Invalid input, input is blank or null");
 /** code here **/
}

公共列表查找员工（字符串str，int dep）{
前提条件.checkState（StringUtils.isNotBlank（str），“输入无效，输入为空或空”）；
/**代码在这里**/
}

我还建议您按名称而不是索引引用结果集中的列，这将使您的代码更易于维护。
使用Apache StringUtils的isNotBlank方法，如

StringUtils.isNotBlank(str)

只有当str不为null且不为空时，才会返回true。
要添加到@BJorn和@SeanPatrickFloyd，番石榴的方法是：

Strings.nullToEmpty(str).isEmpty(); 
// or
Strings.isNullOrEmpty(str);

Commons Lang有时更具可读性，但我一直在慢慢地更多地依赖Guava plus，有时Commons Lang在谈到
isBlank（）
（比如什么是空格或不是空格）时会感到困惑

番石榴的Commons Lang
isBlank
版本是：

Strings.nullToEmpty(str).trim().isEmpty()

我要说的是，不允许
”
（空）和
null
的代码是可疑的，并且可能存在缺陷，因为它可能无法处理所有不允许
null
的情况（尽管对于SQL，我可以理解为SQL/HQL在
”
方面很奇怪）.
只需在此处添加Android：

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)) {
...
}

如果你不想包括整个图书馆；只需包含您想要的代码即可。你必须自己维护它；但这是一个非常直接的函数。这是抄袭自

test等于一个空字符串，在同一条件中为null：

import com.google.common.base.Strings;

if (!Strings.isNullOrEmpty(myString)) {
       return myString;
}

如果str为null，则不会抛出
NullPointerException
，因为如果arg为
null，则返回false

另一个构造
str.equals（“”）
将抛出可怕的
NullPointerException
。有些人可能会考虑使用字符串文字作为坏的形式，在WiS>代码>等式（）/<代码>上调用该对象，但它完成了任务。p>
也请检查以下答案：
这对我来说很有用：

public class StringUtils{

    public static boolean areSet(String... strings)
    {
        for(String s : strings)
            if(s == null || s.isEmpty)
                return false;

        return true;
    }   

}

如果给定字符串为null或为空字符串，则返回true

考虑使用nullToEmpty规范化字符串引用。如果你
如果要，可以使用String.isEmpty（）代替此方法，但不会
需要特殊的空安全形式的方法，如String.toUpperCase
任何一个或者，如果你想“在另一个方向”正常化
将空字符串转换为null时，可以使用emptyToNull

我创建了自己的实用函数，可以一次检查多个字符串，而不是让if语句中充满
if（str！=null&&！str.isEmpty&&str2！=null&&！str2.isEmpty）
。这就是功能：

public static boolean empty( final String s ) {
  // Null-safe, short-circuit evaluation.
  return s == null || s.trim().isEmpty();
}

if(!StringUtils.areSet(firstName,lastName,address)
{
    //do something
}

所以我可以简单地写：

 String str1 = "";
 String str2 = null;

 if(StringUtils.isEmpty(str)){
     System.out.println("str1 is null or empty");
 }

 if(StringUtils.isEmpty(str2)){
     System.out.println("str2 is null or empty");
 }

您可以使用StringUtils.isEmpty（），如果字符串为null或空，则结果为true

import com.google.common.base.Strings;
import org.apache.commons.lang.StringUtils;

/**
 * Created by hu0983 on 2016.01.13..
 */
public class StringNotEmptyTesting {
  public static void main(String[] args){
        String a = "  ";
        String b = "";
        String c=null;

    System.out.println("Apache:");
    if(!StringUtils.isNotBlank(a)){
        System.out.println(" a is blank");
    }
    if(!StringUtils.isNotBlank(b)){
        System.out.println(" b is blank");
    }
    if(!StringUtils.isNotBlank(c)){
        System.out.println(" c is blank");
    }
    System.out.println("Google:");

    if(Strings.isNullOrEmpty(Strings.emptyToNull(a))){
        System.out.println(" a is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(b)){
        System.out.println(" b is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(c)){
        System.out.println(" c is NullOrEmpty");
    }
  }
}

将导致

str1为null或空

str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()

str2为null或空
您应该使用
org.apache.commons.lang3.StringUtils.isNotBlank（）
或
org.apache.commons.lang3.StringUtils.isNotEmpty
。这两者之间的决定是基于您实际想要检查的内容

str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()

检查输入参数是否为：


不为空
不是空字符串（“”）
不是空格字符序列（“”）

仅检查输入参数是否正确


非空
不是空字符串（“”）
我会根据您的实际需要向您推荐番石榴或Apache Commons。检查示例代码中的不同行为：

private boolean stringNotEmptyOrNull(String st) {
    return st != null && !st.isEmpty();
}

结果：

阿帕奇：

a为空

b为空

c为空

谷歌：

b是空的

c是空的
简单解：

org.springframework.util.StringUtils.hasLength(String str)

完整性：如果您已经在使用Spring框架，提供了方法

org.springframework.util.StringUtils.hasText(String str)

Optional.ofNullable(str)
    .filter(s -> !(s.trim().isEmpty()))
    .ifPresent(result -> {
       // your query setup goes here
    });

返回：
如果字符串不为null且具有长度，则为true

以及方法

org.springframework.util.StringUtils.hasText(String str)

Optional.ofNullable(str)
    .filter(s -> !(s.trim().isEmpty()))
    .ifPresent(result -> {
       // your query setup goes here
    });

返回：
如果字符串不正确，则为true
String emptyString = "";
isNotEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
isNotEmpty.apply(notEmptyString); // this will return true

Function<String, Boolean> isEmpty = s -> s == null || "".equals(s)

String emptyString = "";
!isEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true

Predicate<String> p = (s)-> ( s != null && !s.isEmpty());
p.test(string);

org.springframework.util.StringUtils.isEmpty(@Nullable Object str);

public Boolean isStringCorrect(String str) {
    return Optional.ofNullable(str)
            .map(String::trim)
            .map(string -> !str.isEmpty())
            .orElse(false);
}

jshell> "".isBlank()
$7 ==> true

jshell> " ".isBlank()
$8 ==> true

jshell> " ! ".isBlank()
$9 ==> false

boolean isNullOrEmpty = Optional.ofNullable(str).map(String::isBlank).orElse(true);

str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()

str.length()>0 && !str.equalsIgnoreCase("null")

private String name1;
private String name2;
private String name3;

public boolean isEmpty()  {

    for (Field field : this.getClass().getDeclaredFields()) {
        try {
            field.setAccessible(true);
            if (field.get(this) != null) {
                return false;
            }
        } catch (Exception e) {
            System.out.println("Exception occurred in processing");
        }
    }
    return true;
}

StringUtils.hasLength(str)

public boolean isEmpty(String testString) {
  return ((null==testString) || "".equals((""+testString).trim()) || "null".equals((""+testString).toLowerCase()));
}

public class StringUtils {

    static boolean anyEmptyString(String ... strings) {
        return Stream.of(strings).anyMatch(s -> s == null || s.isEmpty());
    }

}

public String concatenate(String firstName, String lastName) {
    if(StringUtils.anyBlankString(firstName, lastName)) {
        throw new IllegalArgumentException("Empty field found");
    }
    return firstName + " " + lastName;
}