如何检查我的字符串是否等于null？

Question

我想只执行一些操作，如果我的字符串有一个有意义的值。所以，我试了这个。

if (!myString.equals("")) { 
doSomething 
} 

这

if (!myString.equals(null)) { 
doSomething 
} 

这

if ((!myString.equals("")) && (!myString.equals(null))) { 
doSomething 
} 

这

if ((!myString.equals("")) && (myString!=null)) { 
doSomething 
} 

这

if (myString.length()>0) { 
doSomething 
} 

而且在所有情况下我的程序doSomething尽管事实上我的字符串是空的。它等于null。那么，那有什么问题呢？

新增：

我发现这个问题的原因。该变量被声明为一个字符串，因此，分配给该变量的null被转换为"null"！所以，if (!myString.equals("null"))的作品。

Answer 1

if (myString != null && !myString.isEmpty()) { 
    // doSomething 
} 

---

随着进一步的评论，你应该知道这个词在equals合同：

从Object.equals(Object)：

对于任何非空引用值x，x.equals(null)应return false。

与null进行比较的方法是使用x == null和x != null。

而且，x.field和x.method()如果x == null则抛出NullPointerException。

Answer 2

你需要检查myString对象是null：

if (myString != null) { 
    doSomething 
} 

Answer 3

尝试，

myString!=null && myString.length()>0 

Answer 4

如果myString是null，然后调用myString.equals(null)或myString.equals("")将失败，NullPointerException。您无法在空变量上调用任何实例方法。

检查空第一这样的：

if (myString != null && !myString.equals("")) { 
    //do something 
} 

这使得利用short-circuit evaluation不尝试.equals如果myString失败，空校验。

Answer 5

如果字符串为空，称这应该抛出一个NullReferenceException：

myString.equals（空）

但无论如何，我认为这样的方法是你想要什么：

public static class StringUtils 
{ 
    public static bool isNullOrEmpty(String myString) 
    { 
     return myString == null || "".equals(myString); 
    } 
} 

然后在你的代码，你可以做这样的事情：

if (!StringUtils.isNullOrEmpty(myString)) 
{ 
    doSomething(); 
} 

Answer 6

这应该工作：

if (myString != null && !myString.equals("")) 
    doSomething 
} 

如果不是，那么myString可能有一个值，你不期望。尝试打印出来是这样的：

System.out.println("+" + myString + "+"); 

使用“+”符号包围的字符串会告诉你，如果在有多余的空格，你不占。

Answer 7

if (myString != null && myString.length() > 0) { 

     // your magic here 

} 

顺便说一句，如果你是做多的字符串操作，有一个伟大的春天类各种有用的方法：

http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html

Answer 8

我会做这样的事情：

(myString != null && myString.length() > 0) 
    ? doSomething() : System.out.println("Non valid String"); 

• 测试null检查myString是否包含String实例。
• length（）返回长度，等于equals（“”）。
• 检查myString是否为null将避免NullPointerException。

Answer 9

if(str.isEmpty() || str==null){ do whatever you want }

Answer 10

我会鼓励使用现有的工具，或者创建自己的方法：

public static boolean isEmpty(String string) { 
    return string == null || string.length() == 0; 
} 

就用它当你需要它：

if (! StringUtils.isEmpty(string)) { 
    // do something 
} 

如前所述以上，||和& &运营商短路。这意味着只要他们能确定他们的价值，他们就会停下来。因此，如果（string == null）为true，则不需要评估长度部分，因为表达式总是为true。与& &同样，如果左侧为假，表达式总是为假，不需要进一步评估。

作为附加说明，使用长度通常比使用.equals更好。性能稍好（不多），并且不需要创建对象（尽管大多数编译器可能会优化它）。

Answer 11

如果myString实际上是null，那么对引用的任何调用都将失败并显示空指针异常（NPE）。 由于Java 6，使用#isEmpty代替长度检查（无论如何不要用检查创建一个新的空字符串）。

if (myString !=null && !myString.isEmpty()){ 
    doSomething(); 
} 

顺便说一句，如果用字符串常量比较像你一样，将扭转声明，以免必须有一个空检查，即

if (("some string to check").equals(myString)){ 
    doSomething(); 
} 

代替：

if (myString !=null && !myString.equals("some string to check")){ 
    doSomething(); 
} 

Answer 12

每次我必须处理字符串（几乎每次）时，我都停下来想知道哪种方法真的是检查空字符串的最快方法。当然，由于Length是一个属性，所以string.Length == 0检查应该是最快的，除了检索属性的值之外，不应该进行任何处理。但后来我问自己，为什么会有一个String.Empty？检查String.Empty比检查长度应该更快，我告诉自己。那么我finnaly决定测试它。我编写了一个小型的Windows控制台应用程序，告诉我需要多长时间才能完成1000万次的重复检查。我检查了3个不同的字符串：一个NULL字符串，一个空字符串和一个“”字符串。我使用了5种不同的方法：String.IsNullOrEmpty（），str == null，str == null || str == String.Empty，str == null || str ==“”，str == null || str.length == 0，下面是结果：

String.IsNullOrEmpty() 
NULL = 62 milliseconds 
Empty = 46 milliseconds 
"" = 46 milliseconds 

str == null 
NULL = 31 milliseconds 
Empty = 46 milliseconds 
"" = 31 milliseconds 

str == null || str == String.Empty 
NULL = 46 milliseconds 
Empty = 62 milliseconds 
"" = 359 milliseconds 

str == null || str == "" 
NULL = 46 milliseconds 
Empty = 343 milliseconds 
"" = 78 milliseconds 

str == null || str.length == 0 
NULL = 31 milliseconds 
Empty = 63 milliseconds 
"" = 62 milliseconds 

根据这些结果，平均检查由于str == null是最快的，但可能并不总能产生我们所要寻找的。 if str = String.Empty或str = ""，它会导致错误。然后你有2个并列第二名：String.IsNullOrEmpty()和str == null || str.length == 0。由于String.IsNullOrEmpty()看起来更好，并且更容易（也更快）写入，所以我建议将其用于其他解决方案。

Answer 13

阿帕奇公用StringUtils.isNotEmpty是最好的方式去。

Answer 14

我在安卓这个问题，我用这种方式（为我工作）：

String test = null; 
if(test == "null"){ 
// Do work 
} 

但在Java代码中，我使用：

String test = null; 
if(test == null){ 
// Do work 
} 

和：

private Integer compareDateStrings(BeanToDoTask arg0, BeanToDoTask arg1, String strProperty) { 
    String strDate0 = BeanUtils.getProperty(arg0, strProperty);_logger.debug("strDate0 = " + strDate0); 
    String strDate1 = BeanUtils.getProperty(arg1, strProperty);_logger.debug("strDate1 = " + strDate1); 
    return compareDateStrings(strDate0, strDate1); 
} 

private Integer compareDateStrings(String strDate0, String strDate1) { 
    int cmp = 0; 
    if (isEmpty(strDate0)) { 
     if (isNotEmpty(strDate1)) { 
      cmp = -1; 
     } else { 
      cmp = 0; 
     } 
    } else if (isEmpty(strDate1)) { 
     cmp = 1; 
    } else { 
     cmp = strDate0.compareTo(strDate1); 
    } 
    return cmp; 
} 

private boolean isEmpty(String str) { 
    return str == null || str.isEmpty(); 
} 
private boolean isNotEmpty(String str) { 
    return !isEmpty(str); 
} 

Answer 15

我认为myString不是一个字符串，而是一串字符串。以下是你需要做的：

String myNewString = join(myString, "") 
if (!myNewString.equals("")) 
{ 
    //Do something 
} 

Answer 16

您可以检查字符串等于使用该为空：

String Test = null; 
(Test+"").compareTo("null") 

如果结果为0，那么（测试+“”）=“空”。

Answer 17

我更喜欢使用：

if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null 
    // do something 
} 

读StringUtils.isBlank() vs String.isEmpty()。

Answer 18

你有空if(str != null).

Answer 19

检查在Android中你可以用工具方法isEmpty从TextUtils检查这一点，

public static boolean isEmpty(CharSequence str) { 
    return str == null || str.length() == 0; 
} 

isEmpty(CharSequence str)方法检查这两个条件，null和长度。

Answer 20

我尝试了大部分上面给出的Android应用中的null值的示例，我正在构建它，并且它全部失败。所以我想出了一个随时为我工作的解决方案。

String test = null+""; 
If(!test.equals("null"){ 
     //go ahead string is not null 

} 

所以，简单地串联一个空字符串为L以上和反对“零”的测试没有和它工作正常。实际上也不例外

Answer 21

工作!!!!

if (myString != null && !myString.isEmpty()) { 
     return true; 
} 
else{ 
     return false; 
} 

Answer 22

我一直在使用StringUtil.isBlank(string)

它测试一个字符串是否是空白：空，emtpy，或只有空白。

所以这一块是迄今为止最好的

下面是从文档的一部开拓创新的方法

/** 
    * Tests if a string is blank: null, emtpy, or only whitespace (" ", \r\n, \t, etc) 
    * @param string string to test 
    * @return if string is blank 
    */ 
    public static boolean isBlank(String string) { 
     if (string == null || string.length() == 0) 
      return true; 

     int l = string.length(); 
     for (int i = 0; i < l; i++) { 
      if (!StringUtil.isWhitespace(string.codePointAt(i))) 
       return false; 
     } 
     return true; 
    } 

Answer 23

异常也可能会有所帮助：

try { 
    //define your myString 
} 
catch (Exception e) { 
    //in that case, you may affect "" to myString 
    myString=""; 
} 

Answer 24

好吧，这是多么的数据类型工作在Java中。 （你必须原谅我的英文，我可能不会使用正确的词汇 你必须区分它们中的两个基本数据类型和常规数据类型基本数据类型几乎弥补了存在的一切 例如，还有所有的数字，字符，布尔等 正常的数据类型或复杂数据类型是一切。 字符串是字符数组，因此一个复杂的数据类型。

您创建的每个变量实际上是在你的记忆中值的指针 例如：

String s = new String("This is just a test"); 

的VAR可以“s”不包含一个字符串。它是一个指针。这个指针指向内存中的变量。 当您致电System.out.println(anyObject)时，将调用该对象的toString()方法。如果它不覆盖Object的toString，它将打印指针。 例如：

后面的 “@”

public class Foo{ 
    public static void main(String[] args) { 
     Foo f = new Foo(); 
     System.out.println(f); 
    } 
} 

>>>> 
>>>> 
>>>>Foo@330bedb4 

一切都是指针。这只适用于复杂的数据类型。原始数据类型直接保存在其指针中。所以实际上没有指针，值直接存储。

例如：

int i = 123; 

I不存储在这种情况下的指针。我将存储整数值123（以字节为单位）。

好吧，让我们回到==运营商。 它总是比较指针而不是保存在内存中指针位置的内容。

实施例：

String s1 = new String("Hallo"); 
String s2 = new String("Hallo"); 

System.out.println(s1 == s2); 

>>>>> false 

这两个字符串具有不同的指针。 String.equals（String other）会比较内容。您可以将基本数据类型与'=='运算符进行比较，因为具有相同内容的两个不同对象的指针相等。

Null意味着指针是空的。默认情况下，空的基本数据类型为0（数字）。但是，对于任何复杂对象而言，空值表示该对象不存在。

问候

Answer 25

对于我来说，如果一个字符串在Java的任何有意义的内容最好的检查，这是一个：你检查

string != null && !string.trim().isEmpty() 

首先如果字符串是null避免NullPointerException，然后修剪所有空格字符以避免检查只有空格的字符串，最后检查修剪后的字符串是否为空，即长度为0.