小开

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

另外

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

或

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

注意:第二次检查(第一个和第二个替代)假设str不为空。这只是因为第一次检查是这样做的(如果第一次检查为假，Java不会进行第二次检查)!

重要:不要用==表示字符串相等。==检查指针是否相等，而不是值。两个字符串可以在不同的内存地址(两个实例)，但具有相同的值!

小开

如何:

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

小开

最佳答案

isEmpty ()怎么样?

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

请确保按此顺序使用&&的部分，因为如果&&的第一部分失败，java将不会继续计算第二部分，从而确保如果str为空，则不会从str.isEmpty()获得空指针异常。

注意，它只在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 ) )

小开

使用# EYZ0

我喜欢使用Apache commons lang来做这些事情，尤其是stringutil实用程序类:

import org.apache.commons.lang.StringUtils;


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


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

小开

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

我个人最喜欢的是Apache Commons / Lang，在stringutil类中，你得到了两个

StringUtils.isEmpty(字符串)和
# EYZ0方法

(第一个检查字符串是空的还是空的，第二个检查它是空的，空的还是空白的)

在Spring、Wicket和许多其他库中有类似的实用程序类。如果不使用外部库，您可能希望在自己的项目中引入一个StringUtils类。 < / s >

更新:许多年过去了，现在我建议使用番石榴的Strings.isNullOrEmpty(string)方法。

小开

正如seanizer上面所说，Apache StringUtils在这方面非常出色，如果你要包括guava，你应该做以下工作;

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

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

小开

使用Apache StringUtils的isNotBlank方法

StringUtils.isNotBlank(str)

只有当str不为空时，它才会返回true。

小开

加上@BJorn和@SeanPatrickFloyd的番石榴方法是:

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

Commons Lang有时更具可读性，但我已经慢慢地更多地依赖于Guava，有时Commons Lang在谈到isBlank()时令人困惑(比如什么是空白或不是空白)。

Guava版本的Commons Lang isBlank将是:

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

我会说，不允许""(空)和 null的代码是可疑的，有潜在的bug，因为它可能无法处理所有不允许null有意义的情况(尽管对于SQL，我可以理解为SQL/HQL对''很奇怪)。

小开

在这里添加Android:

import android.text.TextUtils;


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

小开

如果你不想包含整个库;只包括你想要的代码。你得自己维护;但这是一个很简单的函数。这里是从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;
}

小开

测试等于一个空字符串和null在相同的条件:

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

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

另一个构造str.equals("")将抛出可怕的NullPointerException。有些人可能认为在调用equals()时使用String字面值作为对象是一种糟糕的形式，但它确实可以完成任务。

还要检查这个答案:https://stackoverflow.com/a/531825/1532705

小开

这对我来说很管用:

import com.google.common.base.Strings;


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

如果给定字符串为null或为空字符串，则返回true。
考虑用nullToEmpty规范化字符串引用。如果你做，你可以使用String.isEmpty()而不是这个方法，你不会吗需要特殊的零安全形式的方法，如String.toUpperCase 要么。或者，如果你想“从另一个方向”正常化，将空字符串转换为null，您可以使用emptyToNull.

小开

我已经创建了自己的实用程序函数来一次检查几个字符串，而不是使用一个充满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
}

小开

你可以使用StringUtils.isEmpty()，如果字符串是空的或空的，则结果为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为null或空

小开

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

isNotBlank ()检查输入参数是:

非空,
不是空字符串("")
不是空白字符序列(" ")

isNotEmpty ()只检查输入参数是否为

非空
不是空字符串("")

小开

根据您的实际需要，我建议您选择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");
}
}
}

结果: Apache: A为空
B为空
C为空
谷歌: b是NullOrEmpty
c is NullOrEmpty

小开

简单的解决方法:

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

小开

为了完整性:如果您是已经在使用Spring框架，则StringUtils提供方法

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

的回报: 如果String不是null并且长度
，则为true

以及方法

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

的回报: 如果String不为空，长度大于0，且不包含空格
则为true

小开

你可以使用函数式检查:

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

小开

简单地说，忽略空白:

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

小开

如果您正在使用Java 8，并且希望采用更函数式编程的方法，您可以定义Function来管理控件，然后您可以在需要时重用它和apply()。

在实践中，可以将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

小开

根据输入返回true或false

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

小开

如果你使用Spring框架，那么你可以使用method:

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

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

小开

使用Java 8可选你可以做:

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

在这个表达式中，您还将处理由空格组成的# eyz0。

小开

在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 .

小开

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

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

简而言之,

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

小开

检查对象中的所有字符串属性是否为空(而不是按照java reflection 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

小开

如果您正在使用Spring Boot，那么下面的代码将完成工作

StringUtils.hasLength(str)

小开

import android.text.TextUtils;


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

小开

我遇到过一种情况，我必须检查“null”(作为字符串)必须被视为空。另外，空格和实际的空必须返回true。我最终确定了以下函数…

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

小开

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

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

小开

考虑下面的例子，我在main方法中添加了4个测试用例。当您遵循上面的注释片段时，将通过三个测试用例。

public class EmptyNullBlankWithNull {
public static boolean nullEmptyBlankWithNull(String passedStr) {
if (passedStr != null && !passedStr.trim().isEmpty() && !passedStr.trim().equals("null")) {
// TODO when string is null , Empty, Blank
return true;
}else{
// TODO when string is null , Empty, Blank
return false;
}
}


public static void main(String[] args) {
String stringNull = null; // test case 1
String stringEmpty = ""; // test case 2
String stringWhiteSpace = "  "; // test case 3
String stringWhiteSpaceWithNull = " null"; // test case 4
System.out.println("TestCase result:------ "+nullEmptyBlankWithNull(stringWhiteSpaceWithNull));
        

}
}

但是测试用例4将返回true(它在null之前有空格)，这是错误的:

String stringWhiteSpaceWithNull = " null"; // test case 4

我们必须添加以下条件才能使其正常工作:

!passedStr.trim().equals("null")

小开

如果有人使用springboot，那么下面的选项可能会有帮助，

import static org.springframework.util.StringUtils.hasLength;

if (hasLength(str)) {
// do stuff
}

小开

博士TL;

java.util.function.Predicate是一个功能界面代表一个boolean-valued函数。

Predicate提供了几个static和default方法，允许以流畅的方式执行逻辑操作AND ,,， OR ||， NOT ！和链条件。

逻辑条件不是空的&&不是null"可以表示为:

Predicate.not(Predicate.isEqual(null).or(String::isEmpty));

或者,或者:

Predicate.<String>isEqual(null).or(String::isEmpty).negate();

或者:

Predicate.<String>isEqual(null).or(""::equals).negate();

`Predicate.equal()`是你的朋友

静态方法Predicate.isEqual()期望对目标对象的引用以进行相等性比较(在本例中为空字符串)。这个比较是没有敌意的到null，这意味着isEqual()在内部执行null-check以及实用程序方法Objects.equals(Object, Object)，因此null和null的比较将返回true而不会引发异常。

引用Javadoc的一句话:

返回:

测试两个参数是否相等的谓词 # EYZ0

谓词The将给定元素与null进行比较，可以写成:

Predicate.isEqual(null)

# eyz1或||

默认方法Predicate.or()允许通过逻辑OR ||来连接条件之间的关系。

这就是我们如何结合这两个条件:Empty || null

Predicate.isEqual(null).or(String::isEmpty)

现在我们要对这个谓词求反

# EYZ2,# EYZ3

要执行逻辑否定，我们有两个选项:static方法not()和default方法negate()。

下面是如何编写结果谓词:

public static final Predicate<String> NON_EMPTY_NON_NULL =
Predicate.<String>isEqual(null).or(String::isEmpty).negate();

# eyz4 # eyz0 # eyz5 # eyz1 # eyz6 # eyz2 # eyz7 # eyz3。

或者,或者

public static final Predicate<String> NON_EMPTY_NON_NULL =
Predicate.not(Predicate.isEqual(null).or(String::isEmpty));

*# eyz5 # eyz0 # eyz6 # eyz1 # eyz7 # eyz2。# eyz8 # eyz3 # eyz9 # eyz4 # eyz10

使用的例子

Predicate使用了Stream.filter()， Collection.removeIf()， Collectors.partitioningBy()等方法的参数，您可以创建您的自定义参数。

考虑下面的例子:

List<String> strings = Stream.of("foo", "bar", "", null, "baz")
.filter(NON_EMPTY_NON_NULL)
.map("* "::concat) // append a prefix to make sure that empty string can't sneak in
.toList();
        

strings.forEach(System.out::println);

输出:

* foo
* bar
* baz

检查字符串是否为非空或非空