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

Ответ 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() выбрасывает NullPointerException, если x == null.

Ответ 2

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

Сначала проверьте значение null следующим образом:

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

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

Ответ 3

Самое лучшее, что можно сделать для Apache commons StringUtils.isNotEmpty.

Ответ 4

Если 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();
}

Ответ 5

Вам нужно проверить, что объект myString null:

if (myString != null) {
    doSomething
}

Ответ 6

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

myString.equals(нуль)

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

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

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

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

Ответ 7

Попробуйте,

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

Ответ 8

 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

Ответ 9

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

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

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

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

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

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

Ответ 10

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

Ответ 11

РАБОТА!!!!

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

Ответ 12

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

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

• Тестирование для null проверяет, содержит ли myString экземпляр String.
• length() возвращает длину и эквивалентно equals ("").
• Проверка того, что myString имеет значение null, будет исключать исключение NullPointerException.

Ответ 13

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

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

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

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

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

Ответ 14

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

Ответ 15

Я использовал StringUtil.isBlank(string)

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

Итак, это лучший пока что

Вот метод orignal из документов

/**
    * 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;
    } 

Ответ 16

У меня была эта проблема в 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);
}

Ответ 17

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

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

Прочитайте StringUtils.isBlank() vs String.isEmpty().

Ответ 18

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

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

isEmpty(CharSequence str) проверяет оба условия на null и длину.

Ответ 19

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

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

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

>>>>
>>>>
>>>>[email protected]

Все, что находится за "@", является указателем. Это работает только для сложных типов данных. Примитивные типы данных 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 для любого сложного объекта означает, что объект не существует.

Привет

Ответ 20

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

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

Ответ 21

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

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

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

Ответ 22

Я попробовал большинство приведенных выше примеров для получения нулевого значения в приложении для Android, которое было создано, и IT ALL FAILED. Поэтому я придумал решение, которое работало в любое время для меня.

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

}

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

Ответ 23

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

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

Ответ 24

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

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

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

Ответ 25

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