验证字符串为空或 null 的最佳方法

Question

我相信这之前一定以不同的方式被问过——因为 isEmptyOrNull 是如此普遍，但人们以不同的方式实现它。 但我有以下关于最佳可用方法的好奇查询，这对内存和性能都有好处。

1) 下面没有像空 XML 标签那样考虑所有空格

return inputString==null || inputString.length()==0;

2）下面一个要小心但是trim可以吃一些性能+内存

return inputString==null || inputString.trim().length()==0;

3）结合一和二可以节省一些性能+内存（正如克里斯在评论中建议的那样）

return inputString==null || inputString.trim().length()==0 || inputString.trim().length()==0;

4) 转换为模式匹配器（仅在字符串非零长度时调用）

private static final Pattern p = Pattern.compile("\\s+");

return inputString==null || inputString.length()==0 || p.matcher(inputString).matches();

5) 使用像 - Apache Commons ( StringUtils.isBlank/isEmpty ) 或 Spring ( StringUtils.isEmpty ) 或 Guava ( Strings.isNullOrEmpty ) 或任何其他选项之类的库？

Answer 1

来自 Apache Commons 的有用方法：

 org.apache.commons.lang.StringUtils.isBlank(String str)

https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/StringUtils.html#isBlank(java.lang.String)

Answer 2

要检测字符串是否为 null 或为空，您可以使用以下内容，而无需在您的项目中包含任何外部依赖项，并且仍然保持您的代码简单/干净：

if(myString==null || myString.isEmpty()){
    //do something
}

或者如果还需要检测空格：

if(myString==null || myString.trim().isEmpty()){
    //do something
}

您可以轻松地将它们包装到实用方法中以使其更加简洁，因为这些是非常常见的检查：

public final class StringUtils{

    private StringUtils() { }   

    public static bool isNullOrEmpty(string s){
        if(s==null || s.isEmpty()){
            return true;
        }
        return false;
    }

    public static bool isNullOrWhiteSpace(string s){
        if(s==null || s.trim().isEmpty()){
            return true;
        }
        return false;
    }
}

然后通过以下方式调用这些方法：

if(StringUtils.isNullOrEmpty(myString)){...}

和

if(StringUtils.isNullOrWhiteSpace(myString)){...}

Answer 3

只是为了表明 java 8 删除空值的立场。

String s = Optional.ofNullable(myString).orElse("");
if (s.trim().isEmpty()) {
    ...
}

如果您可以使用Optional<String>就有意义。

Answer 4

这个来自Google Guava 的可以同时检查“空字符串和空字符串”。

Strings.isNullOrEmpty("Your string.");

使用 Maven 添加依赖项

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>20.0</version>
</dependency>

使用 Gradle

dependencies {
  compile 'com.google.guava:guava:20.0'
}

Answer 5

还没有看到任何完全本机的解决方案，所以这里有一个：

return str == null || str.chars().allMatch(Character::isWhitespace);

基本上，使用原生 Character.isWhitespace() 函数。 从那里，您可以实现不同级别的优化，具体取决于它的重要性（我可以向您保证，在 99.99999% 的用例中，不需要进一步优化）：

return str == null || str.length() == 0 || str.chars().allMatch(Character::isWhitespace);

或者，要真正优化（但真丑）：

int len;
if (str == null || (len = str.length()) == 0) return true;
for (int i = 0; i < len; i++) {
  if (!Character.isWhitespace(str.charAt(i))) return false;
}
return true;

我喜欢做的一件事：

Optional<String> notBlank(String s) {
  return s == null || s.chars().allMatch(Character::isWhitepace))
    ? Optional.empty()
    : Optional.of(s);
}

...

notBlank(myStr).orElse("some default")

Answer 6

Apache Commons Lang 有StringUtils.isEmpty(String str)方法，如果参数为空或为空则返回 true

Answer 7

springframework库 检查给定的 String 是否为空。

f(StringUtils.isEmpty(str)) {
    //.... String is blank or null
}

Answer 8

Optional.ofNullable(label)
.map(String::trim)
.map(string -> !label.isEmpty)
.orElse(false)

或者

TextUtils.isNotBlank(label);

最后一个解决方案将检查是否为空并同时修剪 str

Answer 9

在大多数情况下，来自 apache 公共库的StringUtils.isBlank(str)可以解决它。 但是，如果存在被检查的输入字符串在引号内具有空值的情况，则无法检查这种情况。

以我有一个使用String.valueOf(obj) API 转换为字符串的输入对象为例。 如果 obj 引用为 null，则 String.valueOf 返回“null”而不是 null。

当您尝试使用StringUtils.isBlank("null") ，API 惨遭失败，您可能还必须检查此类用例以确保您的验证正确。

Answer 10

使用 openJDK 11，您可以使用内部验证来检查字符串是否为空或只是空格

import jdk.internal.joptsimple.internal.Strings;
...

String targetString;
if (Strings.isNullOrEmpty(tragetString)) {}

Answer 11

简单明了：

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

Answer 12

您可以使用 Optional 和 Apache commons Stringutils 库

Optional.ofNullable(StringUtils.noEmpty(string1)).orElse(string2);

在这里它将检查string1是否不为 null 且不为空，否则将返回string2

Answer 13

如果您必须在同一个验证中测试多个字符串，您可以执行以下操作：

import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StringHelper {

  public static Boolean hasBlank(String ... strings) {

    Predicate<String> isBlank = s -> s == null || s.trim().isEmpty();

    return Optional
      .ofNullable(strings)
      .map(Stream::of)
      .map(stream -> stream.anyMatch(isBlank))
      .orElse(false);
  }

}

因此，您可以像StringHelper.hasBlank("Hello", null, "", " ")或StringHelper.hasBlank("Hello")以通用形式使用它。

Answer 14

我们可以利用以下

Optional.ofNullable(result).filter(res -> StringUtils.isNotEmpty(res))
            .ifPresent( s-> val.set(s));