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

172

Я хочу выполнить какое-то действие ТОЛЬКО ЕСЛИ моя строка имеет значимое значение. Итак, я попробовал это.

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"))работает.

Римский
источник
2
nullнет никаких методов, так что нет equals(). Если бы вы myStringбыли null, как бы вы вызвали метод для этого? :)
BalusC
1
Могу ли я предложить вам System.out.println(myString)непосредственно перед блоком if, чтобы вы могли увидеть, что там?
Майкл Майерс
1
Откуда ты знаешь, что "это равно null"?
Ричард Дж.П. Ле Гуэн,
6
nullприсвоение этой переменной было преобразовано в "null"- это ужасная идея. Попробуйте изменить этот дизайн, если это вообще возможно.
полигенасмазочные материалы
8
Тьфу - не думаю, что проверка того, является ли (! MyString.equals ("null")) лучшим решением. Я подозреваю, что большинство будет считать, что точка, в которой строка «null» была присвоена myString, является ошибкой.
Берт F

Ответы:

231
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()кидает NullPointerExceptionесли x == null.

polygenelubricants
источник
2
Вы должны сделать проверку длины, а не равных в целях эффективности. Проверьте эту ссылку hanuska.blogspot.com/2006/08/empty-string.html
CoolBeans
7
Я бы сказал, что вы должны сделать s.isEmpty()вместо s.length() == 0читабельности. Любая разница в производительности незначительна. Я согласен, что s.equals("")это ужасно.
полигенасмазочные материалы
6
Я согласен с удобочитаемостью. Это зависит от того, используем ли мы Java 5 против Java 6, поскольку isEmpty () только в Java 6.
CoolBeans
@CoolBeans: Хороший комментарий! Я не понял этого! Я немного опаздываю на вечеринку Java =)
полигеномасла
26

Если myStringесть null, то вызов myString.equals(null)или myString.equals("")не удастся с NullPointerException. Вы не можете вызывать какие-либо методы экземпляра для пустой переменной.

Сначала проверьте на null вот так:

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

Это использует оценку короткого замыкания, чтобы не пытаться выполнить проверку .equalsif myStringnull.

Майкл Майерс
источник
+1 за короткое замыкание; важно, чтобы выражение работало. Тем не менее, вы действительно должны использовать .isEmpty()вместо .equals("").
полигенасмазочные материалы
1
Хорошо, я хотел оставить свой комментарий к этому сообщению. ржунимагу. -> «Вы должны делать проверку длины, а не равных в целях эффективности. Проверьте эту ссылку hanuska.blogspot.com/2006/08/empty-string.html»
CoolBeans
@CoolBeans: Конечно, и с Java 6 вы могли бы даже сделать myString.isEmpty(). Но на этом уровне удобочитаемость важнее оптимизации, и люди могут более привыкнуть к чтению myString.equals(""). (Или, возможно, нет.)
Майкл Майерс
20

Apache Commons StringUtils.isNotEmpty- лучший способ.

Кедар
источник
13

Если myString на самом деле имеет значение null, то любой вызов ссылки завершится с исключением 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();
}
клубнелуковица
источник
1
Хороший вопрос, но последние два if не эквивалентны. При myString = "abc" средний не вызывает doSomething, а третий вызывает.
Римский
@ rimsky это исправлено
pavi2410
7

РАБОТАЕТ !!!!

if (myString != null && !myString.isEmpty()) {
    return true;
}
else {
    return false;
}
Салман Назир
источник
6

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

if (myString != null) {
    doSomething
}
Вихрь
источник
5

Если ваша строка пуста, вызовы, подобные этому, должны генерировать исключение NullReferenceException:

myString.equals (нуль)

Но в любом случае, я думаю, что такой метод, как вы хотите:

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

Затем в своем коде вы можете делать такие вещи:

if (!StringUtils.isNullOrEmpty(myString))
{
    doSomething();
}
Энди Уайт
источник
5

Я бы рекомендовал использовать существующую утилиту или создать свой собственный метод:

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

Тогда просто используйте его, когда вам это нужно:

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

Как отмечено выше, || и && операторы короткого замыкания. Это означает, что как только они могут определить свою ценность, они останавливаются. Поэтому, если (string == null) имеет значение true, часть длины не нужно оценивать, поскольку выражение всегда будет истинным. Аналогично с &&, где, если левая сторона ложна, выражение всегда ложно и не нуждается в дальнейшей оценке.

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

Matt
источник
4

Пытаться,

myString!=null && myString.length()>0
bragboy
источник
это невозможно, если myString имеет значение null
hsmit
4
это в значительной степени возможно, когда myString имеет значение null. Вы должны знать, что когда левая часть && не сработает, правое выражение вообще не будет оцениваться ..
bragboy
4

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

ldsant
источник
3

Я бы сделал что-то вроде этого:

( myString != null && myString.length() > 0 )
    ? doSomething() : System.out.println("Non valid String");
  • Проверка на нулевое значение проверяет, содержит ли myString экземпляр String.
  • length () возвращает длину и эквивалентно равно ("").
  • Проверка, является ли myString нулевой первой, позволит избежать исключения NullPointerException.
Джеймс П.
источник
3

Я использую 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;
    } 
Максимум
источник
2

Это должно работать:

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

Если нет, то, вероятно, myString имеет значение, которое вы не ожидаете. Попробуйте напечатать это так:

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

Использование символов «+» для окружения строки покажет вам, есть ли там лишние пробелы, которые вы не учитываете.

elduff
источник
2

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

Моу
источник
3
isEmpty перевернуто .. если вы вызываете метод для нулевого объекта, вы получаете NPE
Brian
Если строка равна нулю, вы получите исключение нулевого указателя, даже до того, как вы проверите, что это пустое значение. Этот код никогда не должен использоваться!
gil.fernandes
2

Хорошо, вот как типы данных работают в Java. (Вы должны извинить мой английский, я, вероятно, не использую правильный словарь. Вы должны различать два из них. Базовые типы данных и обычные типы данных. Базовые типы данных в значительной степени составляют все, что существует. Например, есть все числа, символы, логические значения и т. д. Обычные типы данных или сложные типы данных - это все остальное. Строка - это массив символов, поэтому сложный тип данных.

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

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

переменная "s" НЕ содержит строку. Это указатель. Этот указатель указывает на переменную в вашей памяти. При вызове System.out.println(anyObject), то toString()метод этого объекта называется. Если он не переопределил 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) однако сравнивает содержимое. Вы можете сравнивать примитивные типы данных с оператором '==', поскольку указатель двух разных объектов с одинаковым содержимым одинаков.

Ноль будет означать, что указатель пуст. Пустой примитивный тип данных по умолчанию равен 0 (для чисел). Null для любого сложного объекта, однако, означает, что этот объект не существует.

Приветствую

Luecx
источник
2

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

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

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

gil.fernandes
источник
1

У меня была эта проблема в 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);
}
А.А.
источник
1

В Android вы можете проверить это с помощью метода полезности isEmptyот TextUtils,

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

isEmpty(CharSequence str)Метод проверки как состояния, так nullи длины.

NSK
источник
1

Я всегда использую так:

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

он вернет истину, если он пуст или равен нулю.
b=trueесли пусто или ноль

или вы можете использовать try catch и catch, когда оно пустое.

Web.11
источник
0

Я думаю, что myString - это не строка, а массив строк. Вот что вам нужно сделать:

String myNewString = join(myString, "")
if (!myNewString.equals(""))
{
    //Do something
}
mimit
источник
Мой код для обработки. Обработка - это язык программирования на основе Java. Более подробная информация о join: processing.org/reference/join_.html .
Mimit
0

Вы можете проверить строку, равную нулю, используя это:

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

Если результат равен 0, то (Test + "") = "null".

Харручи Тахер
источник
это просто создает ненужную строку
svarog
0

Я попробовал большинство примеров, приведенных выше, для нулевого значения в приложении для Android, которое я собирал, и ЭТО ВСЕ ОШИБЛО. Поэтому я нашел решение, которое работало в любое время для меня.

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

}

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

leeCoder
источник
1
Нет, это абсолютно ужасное решение. Ответы выше работают.
Конрад Рудольф
@KonradRudolph Я действительно попробовал некоторые из этих решений выше, прежде чем прийти к своему выводу. Я попытался использовать эти солютоны в адаптере для повторного просмотра, и они не дали мне правильного результата, пока я не пришел к этому ответу.
leeCoder
Я могу с уверенностью сказать, что это означает, что с вашим кодом что - то не так, и вы просто исправляете симптомы, а не источник ошибки. Не поймите это неправильно, но это типичный случай программирования культа грузов .
Конрад Рудольф
0

Исключение также может помочь:

try {
   //define your myString
}
catch (Exception e) {
   //in that case, you may affect "" to myString
   myString="";
}
Хериманитра Ранаивосон
источник
0

Если вы работаете в Android, вы можете использовать простой класс TextUtils. Проверьте следующий код:

if(!TextUtils.isEmpty(myString)){
 //do something
}

Это простое использование кода. Ответ может быть повторен. Но просто иметь один и тот же чек для вас.

Манмохан Сони
источник
-5

Вы должны проверить с нуля if(str != null).

Рава Равандзе
источник
5
Ваше решение было опубликовано другими пользователями много лет назад ... Какой смысл повторять это?
TDG
1
я вижу, что ни один из ответов не подтвержден, поэтому я отвечаю ему
rawa rawandze
6
Да, он не подтвердил ответы с 2010 года, поэтому вы просто повторите предыдущий ответ, и он подтвердит ваш ответ ...
TDG