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

Question

如何检查字符串是否为空且不为空？

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

Answer 1

isEmpty()怎么办？

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

请务必按此顺序使用&&的部分，因为如果&&的第一部分失败，java将不会继续评估第二部分，从而确保您不会获得空指针如果str.isEmpty()为空，则来自str的例外。

请注意，它仅在Java SE 1.6之后可用。您必须在以前的版本上查看str.length() == 0。

---

也要忽略空格：

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

（因为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( !empty( str ) )

Answer 2

使用org.apache.commons.lang.StringUtils

我喜欢将Apache commons-lang用于这些事情，特别是StringUtils实用程序类：

import org.apache.commons.lang.StringUtils;

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

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

Answer 3

只需在此处添加Android：

import android.text.TextUtils;

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

Answer 4

添加到@BJorn和@SeanPatrickFloyd Guava的方法是：

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

Commons Lang有时候更具可读性，但我一直在慢慢依赖番石榴加上有时Commons Lang在isBlank()时会感到困惑（就像是什么空白一样）。

Guava的Commons Lang isBlank版本将是：

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

我会说不允许""（空） AND null的代码是可疑的并且可能有错误，因为它可能无法处理所有情况不允许null有意义（虽然对于SQL我可以理解为SQL / HQL对''）很奇怪。

Answer 5

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

替代地

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

或

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

注意：第二项检查（第一和第二种选择）假设str不为空。这只是因为第一次检查是这样做的（如果第一次检查是假的，那么Java不会进行第二次检查）！

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

Answer 6

这对我有用：

import com.google.common.base.Strings;

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

  

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

     

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

Answer 7

我认识的几乎每个库都定义了一个名为StringUtils，StringUtil或StringHelper的实用程序类，它们通常包含您要查找的方法。

我个人最喜欢的是Apache Commons / Lang，在StringUtils课程中你可以得到

1. StringUtils.isEmpty(String)和
2. StringUtils.isBlank(String)方法

（第一个检查字符串是空还是空，第二个检查是否为空，空或仅为空格）

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

---

更新：许多年过去了，这些天我建议使用Guava的Strings.isNullOrEmpty(string)方法。

Answer 8

怎么样：

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

Answer 9

使用Apache StringUtils的isNotBlank方法，如

StringUtils.isNotBlank(str)

仅当str不为null且不为空时才返回true。

Answer 10

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

isNotBlank()检查输入参数是：

• 不是Null，
• 不是空字符串（“”）
• 不是空格字符序列（“”）

isNotEmpty()仅检查输入参数是

• not null
• 不是空字符串（“”）

Answer 11

如果您不想包含整个图书馆;只需包含您想要的代码。你必须自己维护它;但它是一个非常直接的功能。这里是从commons.apache.org

复制的

    /**
 * <p>Checks if a String is whitespace, empty ("") or null.</p>
 *
 * <pre>
 * StringUtils.isBlank(null)      = true
 * StringUtils.isBlank("")        = true
 * StringUtils.isBlank(" ")       = true
 * StringUtils.isBlank("bob")     = false
 * StringUtils.isBlank("  bob  ") = false
 * </pre>
 *
 * @param str  the String to check, may be null
 * @return <code>true</code> if the String is null, empty or whitespace
 * @since 2.0
 */
public static boolean isBlank(String str) {
    int strLen;
    if (str == null || (strLen = str.length()) == 0) {
        return true;
    }
    for (int i = 0; i < strLen; i++) {
        if ((Character.isWhitespace(str.charAt(i)) == false)) {
            return false;
        }
    }
    return true;
}

Answer 12

根据输入

返回true或false

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

Answer 13

这有点太晚了，但这是一种功能性的检查方式：

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

Answer 14

java-11中有一个新方法：String#isBlank

  

如果字符串为空或仅包含空格代码点，则返回true；否则返回false。

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

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

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

这可以与Optional结合使用，以检查字符串是否为空或空

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

String#isBlank

Answer 15

简单的解决方案：

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

Answer 16

test等于空字符串，并且在相同的条件中为null：

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

如果str为null，则不会抛出NullPointerException，因为如果arg是null，Object.equals()将返回false。

另一个构造str.equals("")会抛出可怕的NullPointerException。有些人可能会认为使用字符串文字作为调用equals()时的对象的错误形式但是它完成了工作。

同时查看以下答案：https://stackoverflow.com/a/531825/1532705

Answer 17

正如上面所说的seanizer，Apache StringUtils非常棒，如果你要包含番石榴，你应该做以下事情;

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

我还建议您按名称而不是索引来引用结果集中的列，这将使您的代码更容易维护。

Answer 18

我已经创建了自己的实用程序函数来同时检查多个字符串，而不是使用if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty)的if语句。这是功能：

public class StringUtils{

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

        return true;
    }   

}

所以我可以简单地写一下：

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

Answer 19

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

 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");
 }

将导致

str1为空或空

str2为空或空

Answer 20

如果您使用的是Spring Boot，则下面的代码将完成工作

StringUtils.hasLength(str)

Answer 21

使用Java 8 Optional即可：

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

在此表达式中，您还将处理由空格组成的String。

Answer 22

如果您使用的是Java 8并希望采用更多功能编程方法，则可以定义管理控件的Function，然后您可以在需要时重复使用它apply()。 / p>

即将练习，您可以将Function定义为

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

然后，您只需将apply()方法调用为：

即可使用它

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

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

如果您愿意，可以定义一个Function来检查String是否为空，然后使用!取消它。

在这种情况下，Function将如下所示：

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

然后，您只需将apply()方法调用为：

即可使用它

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

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

Answer 23

我会根据您的实际需要建议Guava或Apache Commons。检查我的示例代码中的不同行为：

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");
    }
  }
}

结果：
阿帕奇：
 a是空白的  b是空白的  c是空白的 谷歌：
 b是NullOrEmpty
 c是NullOrEmpty

Answer 24

如果您使用Spring框架，那么您可以使用方法：

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

此方法接受任何Object作为参数，将其与null和空String进行比较。因此，对于非null非String对象，此方法永远不会返回true。

Answer 25

简单地说，也要忽略空格：

if (str == null || str.trim().length() == 0) {
    // str is empty
} else {
    // str is not empty
}

Answer 26

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

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

  

返回：   如果String不为null且长度为

，则为true

以及方法

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

  

返回：   如果String不为null，其长度大于0，并且它不包含空格

，则返回true

Answer 27

处理字符串中null的更好方法是

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

简而言之，

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

Answer 28

要检查对象中的所有字符串属性是否为空（而不是在遵循Java反射api方法的所有字段名称上使用！= 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;
}

如果所有String字段值均为空白，则此方法将返回true；如果String属性中存在任何一个值，则该方法将返回false

Answer 29

我遇到了一种情况，我必须检查“ null”（作为字符串）必须被视为空。空格和实际的 null 也必须返回true。 我终于确定了以下功能...

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

Answer 30

如果需要验证方法参数，可以使用以下简单方法

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;
}

Answer 31

要检查字符串是否不为空，可以检查字符串是否为null，但这不能说明带有空格的字符串。您可以使用str.trim()修剪所有空白，然后链接.isEmpty()以确保结果不为空。

    if(str != null && !str.trim().isEmpty()) { /* do your stuffs here */ }

Answer 32

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)||!str.equalsIgnoreCase("") {
    ...
}