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

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

作为进一步的评论，你应该注意 equals合同中的这个条款:

来自 Object.equals(Object):

对于任何非空参考值 x，x.equals(null)应该是 return false。

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

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

您需要检查 myString对象是否为 null:

if (myString != null) {
doSomething
}

试试看,

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

如果 myString是 null，那么调用 myString.equals(null)或 myString.equals("")将以 NullPointerException失败。不能对空变量调用任何实例方法。

首先像下面这样检查 null:

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

如果 myString未能通过空检查，则使用 短路求值不尝试 .equals。

如果字符串为 null，则此类调用应抛出 NullReferenceException:

等于(null)

但不管怎样，我认为这样的方法是你想要的:

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

然后在你的代码中，你可以这样做:

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

这应该会奏效:

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

如果没有，那么 myString 很可能有一个您不希望看到的值:

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

使用’+’符号包围字符串将显示是否有额外的空格，您没有计算在内。

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

• 测试 null 检查 myString 是否包含 String 的实例。
• Length ()返回长度，等效于等于(“”)。
• 首先检查 myString 是否为 null 将避免 NullPointerException。

如果(str.isEmpty () | | str = = null){ 做你想做的 }

我鼓励使用现有的实用程序，或者创建自己的方法:

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

那就在你需要的时候使用它:

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

如上所述，| | 和 & & 操作员短路。这意味着一旦他们能够确定自己的价值，他们就会停止。因此，如果(string = = null)为 true，则不需要计算长度部分，因为表达式将始终为 true。与 & & 类似，如果左边为 false，则表达式始终为 false，不需要进一步计算。

另外，使用长度通常比使用。等于。性能稍微好一点(不是很好) ，而且不需要创建对象(尽管大多数编译器可能会优化这一点)。

如果 myString 实际上是 Null，那么对引用的任何调用都将失败，并出现 Null 指针异常(NPE)。 从 java 6开始，使用 # 是空的代替长度检查(在任何情况下都不要用检查创建一个新的空字符串)。

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

顺便说一句，如果像您这样比较 String 文本，将会反转语句，以便不必使用 null 检查，即,

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

而不是:

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

每次我不得不处理字符串时(几乎每次) ，我都会停下来想知道哪种方法真的是检查空字符串的最快方法。当然是绳子。Llength = = 0检查应该是最快的，因为 Llength 是一个属性，除了检索属性值之外，不应该有任何处理。然后我问自己，为什么有一个字符串。空的？检查 String 应该会更快。我告诉自己，空空如也。我终于决定试试。我编写了一个小的 Windows 控制台应用程序，告诉我需要多长时间来做一个特定的检查1000万次重复。我检查了3个不同的字符串: 一个 NULL 字符串、一个空字符串和一个“”字符串。我使用了5种不同的方法: String.IsNullOrEmpty () ，str = = null，str = = null | | str = = String。空，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()看起来更好，编写起来更容易(也更快) ，我建议使用它而不是其他解决方案。

Apache commons StringUtils.isNotEmpty是最好的方法。

我在 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);
}

我认为 myString 不是一个字符串，而是一个字符串数组:

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

您可以使用以下命令检查字符串是否等于 null:

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

如果结果为0，则(Test +”) = “ null”。

我更喜欢用:

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

阅读 IsBlank () vs String.isEmpty ()。

您必须使用空 if(str != null).进行检查

在 Android 中，你可以使用来自 TextUtils的实用方法 isEmpty来检查这一点,

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

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

我尝试了上面给出的大多数例子，在一个 Android 应用程序的空我正在建设，它全部失败。所以我想出了一个随时都可行的解决方案。

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


}

所以只需要像上面一样连接一个空字符串，并对“ null”进行测试，就可以正常工作了。事实上，不会引发任何异常

工作! ! ！

 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

我一直在用 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;
}

例外情况也可能有所帮助:

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

这就是 Java 中数据类型的工作方式。(请原谅我的英语不好，我可能说错了。)。用词不当。 你必须区分他们两个。基本数据类型和普通数据类型。基本数据类型几乎构成了现有的一切。 例如，有所有的数字，字符，布尔等。 常规数据类型或复杂数据类型就是其他的一切。 String 是一个字符数组，因此是一个复杂的数据类型。

您创建的每个变量实际上都是指向内存中值的指针。 例如:

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

变量“ 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;

在这种情况下，我不存储指针。我将存储整数值123(字节 ofc)。

好，让我们回到 ==操作员。 它总是比较指针，而不是内存中保存在指针位置的内容。

例如:

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


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


>>>>> false

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

Null 意味着指针为空。默认情况下，空基元数据类型为0(表示数字)。对于任何复杂对象，则表示该对象不存在。

你好

对我来说，检查一个字符串是否在 Java 中有任何有意义的内容的最好方法是:

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

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

如果您使用的是 Android 系统，那么您可以使用简单的 TextUtils 类。 检查以下代码:

if(!TextUtils.isEmpty(myString)){
//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);

如果为空或为空，则返回 true。如果为空或为空，则返回 < br > b=true

或者您可以在它为 null 时使用 try catch and catch。

我使用的函数类似于这样，我将 get 字符串结果传递给它，这样我就不必不断地检查 null，它要么返回你传回的字符串，要么返回空值:

public static String safeGet(String str) {
try {
if (str == null) throw new Exception();
return "" + str;
} catch (Exception e) {
return "";
}
}