Как проверить, равна ли моя строка нулевой?

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() throws NullPointerException если x == null.

Answer 2

Вы должны проверить, что myString объект null:

if (myString != null) { 
    doSomething 
} 

Answer 3

Try,

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 

} 

Incidently, если вы делаете много манипуляций со строками, есть большой Spring класс со всеми видами полезных методов:

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() возвращает длину и эквивалентен значению ("").
• Проверка того, что 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) истинно, часть длины не нужно оценивать, так как выражение всегда будет истинным. Аналогично с & &, где, если левая сторона является ложной, выражение всегда ложно и не нуждается в дальнейшей оценке.

В качестве дополнительного примечания использование длины обычно лучше, чем использование .equals. Производительность немного лучше (не много) и не требует создания объекта (хотя большинство компиляторов могли бы оптимизировать это).

Answer 11

Если myString на самом деле является нулевым, то любой вызов ссылки не будет выполнен с использованием Null Pointer Exception (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

Каждый раз, когда мне приходится иметь дело со строками (почти каждый раз), я останавливаюсь и задаюсь вопросом, каким образом это самый быстрый способ проверить пустую строку. Конечно, проверка string.Length == 0 должна быть самой быстрой, так как Length является свойством и не должно быть никакой обработки, кроме как получить значение свойства. Но потом я спрашиваю себя: почему существует String.Empty? Я должен сказать, что лучше проверить String.Empty, чем на длину. Ну, финнали решил проверить это. Я закодировал небольшое приложение Windows Console, которое сообщает мне, сколько времени потребуется, чтобы выполнить определенную проверку на 10 миллионов повторений. Я проверил 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

Apache commons 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, то (Test + "") = "нуль".

Answer 17

Я предпочитаю использовать:

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

Read 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, которое я строил, и IT ALL FAILED. Поэтому я придумал решение, которое работало в любое время для меня.

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

} 

Так просто объедините пустую строку, как я сделал выше, и протестируйте ее против «null», и она отлично работает. На самом деле исключение не выбрасывается

Answer 21

РАБОТА !!!!

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

Answer 22

Я использую StringUtil.isBlank(string)

Он проверяет, является ли строка пустой: нуль, пуста, или только пробелы.

Так что это один из лучших до сих пор

Вот оригинальная методика из документации

/** 
    * 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. (Вы должны извинить мой английский, я не могу использовать правильный vocab. Вы должны различать два из них: базовые типы данных и обычные типы данных. Базовые типы данных в значительной степени составляют все существующее. Например , есть все числа, голец, логические и т.д. нормальные типы данных или сложные типы данных, все остальное. Строка представляет собой массив символов, поэтому сложный тип данных.

Каждая переменная, которую вы создаете на самом деле указатель на значение в вашей памяти Например:.

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

вар iable "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 

Все позади "@" является указателем. Это работает только для сложных типов данных. Примитивные типы данных DIRECTLY сохраняются в указателе. Так что на самом деле нет указателя, и значения хранятся напрямую.

Например:

int i = 123; 

я не хранит указатель в этом случае. i будет хранить целочисленное значение 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 для любого сложного объекта означает, что объект не существует.

Приветствия

Answer 25

Для меня лучше проверить, если строка имеет какие-либо значимого контента в Java это одна:

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

Сначала проверить, если строка null, чтобы избежать NullPointerException, а затем вы обрезать все пробелы, чтобы избежать проверки строк, которые имеют только пробелы, и, наконец, вы проверяете, не является ли обрезанная строка пустой, т. е. имеет длину 0.