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

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

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договоре:

От Object.equals(Object):

Для любого ненулевого ссылочного значения x, x.equals(null)следует return false.

Способ для сравнения с nullиспользованием x == nullи x != null.

Более того x.fieldи x.method()кидает NullPointerExceptionесли x == null.

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

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

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

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

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

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

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

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

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

if (myString != null) {
    doSomething
}

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

myString.equals (нуль)

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

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

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

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

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

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

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

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

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

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

Пытаться,

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

 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

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

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

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

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

Я использую 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 (myString != null && !myString.equals(""))
    doSomething
}

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

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

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

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

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

Приветствую

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

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

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

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

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

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

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

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

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

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, когда оно пустое.

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

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

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

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

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

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

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="";
}

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

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

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

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