仅当我的字符串具有有意义的值时，我才想执行某些操作。所以，我尝试了这个。
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"))工作。
if (myString != null && !myString.isEmpty()) {
// doSomething
}
作为进一步的评论，您应该了解equals合同中的这个条款：
对于任何非空引用值
x，x.equals(null)应该return false。
比较的方法null是使用x == nulland x != null。
此外，x.field并x.method()抛出NullPointerExceptionif x == null。
如果myStringis null，那么调用myString.equals(null)ormyString.equals("")将失败并返回NullPointerException。您不能对空变量调用任何实例方法。
首先检查 null，如下所示：
if (myString != null && !myString.equals("")) {
//do something
}
这利用短路评估来不尝试.equalsifmyString未通过 null 检查。
Apache commonsStringUtils.isNotEmpty是最好的方法。
如果 myString 实际上为 null，则对引用的任何调用都将失败，并出现 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();
}
在职的 ！！！！
if (myString != null && !myString.isEmpty()) {
return true;
}
else {
return false;
}
更新
对于 Kotlin，我们通过以下方式检查字符串是否为空
return myString.isNullOrEmpty() // Returns `true` if this nullable String is either `null` or empty, false otherwise
return myString.isEmpty() // Returns `true` if this char sequence is empty (contains no characters), false otherwise
您需要检查myString对象是否null：
if (myString != null) {
doSomething
}
我鼓励使用现有的实用程序，或创建自己的方法：
public static boolean isEmpty(String string) {
return string == null || string.length() == 0;
}
然后在需要时使用它：
if (! StringUtils.isEmpty(string)) {
// do something
}
如上所述，|| 和 && 运算符短路。这意味着一旦他们可以确定他们的价值，他们就会停止。因此，如果 (string == null) 为真，则不需要计算长度部分，因为表达式始终为真。与 && 类似，如果左侧为假，则表达式始终为假，无需进一步计算。
作为附加说明，使用长度通常比使用 .equals 更好。性能稍微好一点（不多），并且不需要创建对象（尽管大多数编译器可能会对此进行优化）。
如果你的字符串为空，这样的调用应该抛出 NullReferenceException：
myString.equals(null)
但无论如何，我认为这样的方法是你想要的：
public static class StringUtils
{
public static bool isNullOrEmpty(String myString)
{
return myString == null || "".equals(myString);
}
}
然后在您的代码中，您可以执行以下操作：
if (!StringUtils.isNullOrEmpty(myString))
{
doSomething();
}
尝试，
myString!=null && myString.length()>0
每次我必须处理字符串（几乎每次）时，我都会停下来想知道哪种方法真的是检查空字符串的最快方法。当然 string.Length == 0 检查应该是最快的，因为 Length 是一个属性，除了检索属性的值之外不应该有任何处理。但后来我问自己，为什么会有 String.Empty？我告诉自己，检查 String.Empty 应该比检查长度更快。好吧，我最终决定测试一下。我编写了一个小型 Windows 控制台应用程序，它告诉我对 1000 万次重复进行特定检查需要多长时间。我检查了 3 个不同的字符串：一个 NULL 字符串、一个空字符串和一个 "" 字符串。我使用了 5 种不同的方法：String.IsNullOrEmpty()、str == null、str == null || str == String.Empty, str == null || str == "", str == null || 海峡
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()看起来更好并且更容易（并且更快）编写，我建议使用它而不是其他解决方案。
if (myString != null && myString.length() > 0) {
// your magic here
}
顺便说一句，如果您要进行大量字符串操作，那么有一个很棒的 Spring 类，其中包含各种有用的方法：
http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html
我会做这样的事情：
( myString != null && myString.length() > 0 )
? doSomething() : System.out.println("Non valid String");
对我来说，最好检查一个字符串是否在 Java 中有任何有意义的内容是这个：
string != null && !string.trim().isEmpty()
首先检查字符串是否null要避免NullPointerException，然后修剪所有空格字符以避免检查只有空格的字符串，最后检查修剪后的字符串是否不为空，即长度为 0。
我一直在使用StringUtil.isBlank(string)
它测试字符串是否为空：null、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;
}
if(str.isEmpty() || str==null){
do whatever you want
}
这应该有效：
if (myString != null && !myString.equals(""))
doSomething
}
如果不是，那么 myString 可能具有您不期望的值。尝试像这样打印出来：
System.out.println("+" + myString + "+");
使用“+”符号将字符串括起来会显示其中是否有您没有考虑到的额外空格。
好的，这就是数据类型在 Java 中的工作方式。（你必须原谅我的英语，我很可能没有使用正确的词汇。你必须区分它们中的两个。基本数据类型和普通数据类型。基本数据类型几乎构成了存在的所有内容。例如，有都是数字、字符、布尔值等。普通数据类型或复杂数据类型是其他所有类型。字符串是字符数组，因此是复杂数据类型。
您创建的每个变量实际上都是内存中值的指针。例如：
String s = new String("This is just a test");
变量“s”不包含字符串。它是一个指针。这个指针指向你内存中的变量。当您调用 时System.out.println(anyObject)，将调用toString()该对象的方法。如果它没有toString从 Object 覆盖，它将打印指针。例如：
public class Foo{
public static void main(String[] args) {
Foo f = new Foo();
System.out.println(f);
}
}
>>>>
>>>>
>>>>Foo@330bedb4
“@”后面的所有内容都是指针。这仅适用于复杂的数据类型。原始数据类型直接保存在它们的指针中。所以实际上没有指针，值是直接存储的。
例如：
int i = 123;
在这种情况下，我不存储指针。我将存储整数值 123（以字节 ofc 为单位）。
好的，让我们回到==运营商。它总是比较指针而不是保存在内存中指针位置的内容。
例子：
String s1 = new String("Hallo");
String s2 = new String("Hallo");
System.out.println(s1 == s2);
>>>>> false
这两个字符串都有不同的指针。String.equals(String other) 但是比较内容。您可以使用“==”运算符比较原始数据类型，因为具有相同内容的两个不同对象的指针是相等的。
Null 意味着指针为空。默认情况下，空的原始数据类型为 0（对于数字）。然而，任何复杂对象的 Null 都意味着该对象不存在。
问候
我在android中遇到了这个问题，我用这种方式（为我工作）：
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);
}
我更喜欢使用：
if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null
// do something
}
我总是这样使用：
if (mystr != null && !mystr.isEmpty()){
//DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}else {
//DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}
或者您可以将其复制到您的项目中：
private boolean isEmptyOrNull(String mystr){
if (mystr != null && !mystr.isEmpty()){ return true; }
else { return false; }
}
就像这样称呼它：
boolean b = isEmptyOrNull(yourString);
如果为空或 null，它将返回 true。b=trueif 为空或 null
或者你可以在它为空时使用 try catch 和 catch 。
在 Android 中，您可以使用实用程序方法检查这一点isEmpty，TextUtils
public static boolean isEmpty(CharSequence str) {
return str == null || str.length() == 0;
}
isEmpty(CharSequence str)方法检查条件null和长度。
I think that myString is not a string but an array of strings. Here is what you need to do:
String myNewString = join(myString, "")
if (!myNewString.equals(""))
{
//Do something
}
我尝试了上面给出的大多数示例，用于在我正在构建的 android 应用程序中为 null 并且它都失败了。所以我想出了一个对我有用的解决方案。
String test = null+"";
If(!test.equals("null"){
//go ahead string is not null
}
因此，只需像上面那样连接一个空字符串并针对“null”进行测试，它就可以正常工作。实际上没有抛出异常
例外也可能有帮助：
try {
//define your myString
}
catch (Exception e) {
//in that case, you may affect "" to myString
myString="";
}
您可以使用以下方法检查等于 null 的字符串：
String Test = null;
(Test+"").compareTo("null")
如果结果为 0，则 (Test+"") = "null"。
如果您在 Android 中工作，那么您可以使用简单的 TextUtils 类。检查以下代码：
if(!TextUtils.isEmpty(myString)){
//do something
}
这是代码的简单用法。答案可能会重复。但是为您提供单一和简单的检查很简单。
你必须检查 nullif(str != null).