Проверьте, не является ли строка null и не пустой

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

public void doStuff(String str)
{
    if (str != null && str != "**here I want to check the 'str' is empty or not**")
    {
        /* handle empty string */
    }
    /* ... */
}
413
java string string-comparison

26 ответов

насчет isEmpty () ?

if(str != null && !str.isEmpty())

обязательно используйте части && в этом порядке, потому что java не будет продолжать оценивать вторую часть, если первая часть && терпит неудачу, таким образом, гарантируя, что вы не получите исключение нулевого указателя от str.isEmpty() если str равно null.

остерегайтесь, он доступен только с Java SE 1.6. Вы должны проверить str.length() == 0 на предыдущих версиях.

игнорировать пробелы как хорошо:

if(str != null && !str.trim().isEmpty())

обернутый в удобной функции:

public static boolean empty( final String s ) {
  // Null-safe, short-circuit evaluation.
  return s == null || s.trim().isEmpty();
}

будет:

if( !empty( str ) )
811

использовать org.апаш.палата общин.ленг.StringUtils

мне нравится использовать Apache commons-lang для таких вещей, и особенно StringUtils утилиты > класс:

import org.apache.commons.lang.StringUtils;

if (StringUtils.isNotBlank(str)) {
    ...
} 

if (StringUtils.isBlank(str)) {
    ...
}
184

просто добавив Android здесь:

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)) {
...
}
102

чтобы добавить в @BJorn и @SeanPatrickFloyd способ гуавы сделать это:

Strings.nullToEmpty(str).isEmpty(); 
// or
Strings.isNullOrEmpty(str);

Commons Lang иногда более читаем, но я медленно полагался больше на Guava plus иногда Commons Lang сбивает с толку, когда дело доходит до isBlank() (как в том, что является пробелом или нет).

версия гуавы Commons Lang isBlank будет:

Strings.nullToEmpty(str).trim().isEmpty()

Я скажу код, который не позволяет "" (пусто) и null подозрительно и потенциально багги в том, что он, вероятно, не обрабатывает все случаи, когда не позволяет null имеет смысл (хотя для SQL я могу понять, как SQL / HQL странно о '').

41
str != null && str.length() != 0

как вариант

str != null && !str.equals("")

или

str != null && !"".equals(str)

Примечание: вторая проверка (первая и вторая альтернативы) предполагает, что str не является нулевым. Это нормально только потому, что первая проверка делает это (и Java не делает вторую проверку, если первая ложная)!

важно: не используйте == для равенства строк. = = проверяет, что указатель равен, а не значение. Две строки могут быть в разных адресах памяти (два экземпляра), но имеют одинаковое значение!

31

это работает для меня:

import com.google.common.base.Strings;

if (!Strings.isNullOrEmpty(myString)) {
       return myString;
}

возвращает true, если данная строка имеет значение null или является пустой строкой.

рекомендуется нормализовать строку ссылок с nullToEmpty. Если вы вы можете использовать строку.пустой() вместо этого метода, и вы не нужны специальные null-безопасные формы методов, таких как String.метод touppercase любой. Или, если вы хотите нормализовать "в другом направлении," преобразования пустой строки в null, вы можете использовать emptyToNull.

23

почти каждая библиотека, которую я знаю, определяет класс утилиты под названием StringUtils, StringUtil или StringHelper, и они обычно включают метод, который вы ищете.

мой личный фаворит Apache Commons / Lang, где в StringUtils класс, вы получите как

  1. StringUtils.isEmpty (String) и
  2. StringUtils.епусто(строка) метод

(первый проверяет, является ли строка нулевой или пустой, второй проверяет, является ли она нулевой, пустой или только пробел)

есть аналогичные классы полезности весной, калитка и много других библиотек. Если вы не используете внешние библиотеки, вы можете ввести класс StringUtils в свой собственный проект.

обновление: прошло много лет, и в эти дни я бы рекомендовал использовать гуавы ' s Strings.isNullOrEmpty(string) метод.

21

Как насчет:

if(str!= null && str.length() != 0 )
10

используйте метод isNotBlank Apache StringUtils, например 

StringUtils.isNotBlank(str)

он вернет true только в том случае, если str не равен null и не пуст.

6

Если вы не хотите включать всю библиотеку; просто включите код, который вы хотите от него. Вам придется поддерживать его самостоятельно; но это довольно прямая функция. Вот он скопирован из commons.apache.org

    /**
 * <p>Checks if a String is whitespace, empty ("") or null.</p>
 *
 * <pre>
 * StringUtils.isBlank(null)      = true
 * StringUtils.isBlank("")        = true
 * StringUtils.isBlank(" ")       = true
 * StringUtils.isBlank("bob")     = false
 * StringUtils.isBlank("  bob  ") = false
 * </pre>
 *
 * @param str  the String to check, may be null
 * @return <code>true</code> if the String is null, empty or whitespace
 * @since 2.0
 */
public static boolean isBlank(String str) {
    int strLen;
    if (str == null || (strLen = str.length()) == 0) {
        return true;
    }
    for (int i = 0; i < strLen; i++) {
        if ((Character.isWhitespace(str.charAt(i)) == false)) {
            return false;
        }
    }
    return true;
}
4

вы должны использовать org.apache.commons.lang3.StringUtils.isNotBlank() или org.apache.commons.lang3.StringUtils.isNotEmpty. Решение между этими двумя основано на том, что вы действительно хотите проверить.

на isNotBlank () проверяет, что входной параметр:

  • не Null,
  • не пустая строка ("")
  • не последовательность пробелов ("")

на isNotEmpty() проверяет только, что входной параметр

  • не значение null
  • не пустая строка ("")
4

немного поздно, но вот функциональный стиль проверки:

Optional.ofNullable(str)
    .filter(s -> !(s.trim().isEmpty()))
    .ifPresent(result -> {
       // your query setup goes here
    });
4

Как сказал seanizer выше, Apache StringUtils фантастичен для этого, если вы должны были включить гуаву, вы должны сделать следующее;

public List<Employee> findEmployees(String str, int dep) {
 Preconditions.checkState(StringUtils.isNotBlank(str), "Invalid input, input is blank or null");
 /** code here **/
}

могу ли я также рекомендовать вам ссылаться на столбцы в вашем результирующем наборе по имени, а не по индексу, это сделает ваш код намного проще в обслуживании.

2

test равно с пустой строкой и null в том же условном:

if(!"".equals(str) && str != null) {
    // do stuff.
}

не бросает NullPointerException если str равно null, так как Object.equals() возвращает false, если arg null.

другое строительство str.equals("") бросил бы страшный NullPointerException. Некоторые могут посчитать дурным тоном, используя строковый литерал в качестве объекта, на который equals() называется, но он выполняет свою работу.

также проверьте этот ответ: https://stackoverflow.com/a/531825/1532705

2

Я сделал свою собственную функцию утилиты, чтобы проверить несколько строк сразу, а не иметь оператор if, полный if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). Это функция:

public class StringUtils{

    public static boolean areSet(String... strings)
    {
        for(String s : strings)
            if(s == null || s.isEmpty)
                return false;

        return true;
    }   

}

Так что я могу просто написать:

if(!StringUtils.areSet(firstName,lastName,address)
{
    //do something
}
2

простое решение : 

private boolean stringNotEmptyOrNull(String st) {
    return st != null && !st.isEmpty();
}
2

возвращает true или false на основе input

Predicate<String> p = (s)-> ( s != null && !s.isEmpty());
p.test(string);
2

есть новый метод в java-11: String#isBlank

возвращает true, если строка пуста или содержит только пробелы, в противном случае false.

jshell> "".isBlank()
 ==> true

jshell> " ".isBlank()
 ==> true

jshell> " ! ".isBlank()
 ==> false

это может быть объединено с Optional чтобы проверить, является ли строка null или пустой

boolean isNullOrEmpty = Optional.ofNullable(str).map(String::isBlank).orElse(true);

строка#isBlank

2

вы можете использовать StringUtils.isEmpty (), это приведет к true, если строка либо null, либо пуста.

 String str1 = "";
 String str2 = null;

 if(StringUtils.isEmpty(str)){
     System.out.println("str1 is null or empty");
 }

 if(StringUtils.isEmpty(str2)){
     System.out.println("str2 is null or empty");
 }

в результате

str1 равно null или пусто

str2 равно null или пусто

1

Я бы посоветовал Guava или Apache Commons В соответствии с вашими фактическими потребностями. Проверьте различные поведения в моем примере кода:

import com.google.common.base.Strings;
import org.apache.commons.lang.StringUtils;

/**
 * Created by hu0983 on 2016.01.13..
 */
public class StringNotEmptyTesting {
  public static void main(String[] args){
        String a = "  ";
        String b = "";
        String c=null;

    System.out.println("Apache:");
    if(!StringUtils.isNotBlank(a)){
        System.out.println(" a is blank");
    }
    if(!StringUtils.isNotBlank(b)){
        System.out.println(" b is blank");
    }
    if(!StringUtils.isNotBlank(c)){
        System.out.println(" c is blank");
    }
    System.out.println("Google:");

    if(Strings.isNullOrEmpty(Strings.emptyToNull(a))){
        System.out.println(" a is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(b)){
        System.out.println(" b is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(c)){
        System.out.println(" c is NullOrEmpty");
    }
  }
}

результат:
Апач:
a пуст
B является пустым
C является пустым
Google:
б NullOrEmpty
C-это NullOrEmpty

1

если вы используете Java 8 и хотите иметь более функциональный подход программирования, вы можете определить Function, управляющего управления, а затем вы можете использовать его и apply() всякий раз, когда это необходимо.

приходя на практику, вы можете определить Function as 

Function<String, Boolean> isNotEmpty = s -> s != null && !"".equals(s)

тогда вы можете использовать его, просто вызвав apply() метод as:

String emptyString = "";
isNotEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
isNotEmpty.apply(notEmptyString); // this will return true

если вы предпочитаете, вы можете определить Function это проверяет, если String пусто, а затем отрицает его с !.

в этом случае Function будет выглядеть как :

Function<String, Boolean> isEmpty = s -> s == null || "".equals(s)

тогда вы можете использовать его, просто вызвав apply() метод as:

String emptyString = "";
!isEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true
1

для полноты: если вы уже используя Spring framework, the StringUtils обеспечить метод

org.springframework.util.StringUtils.hasLength(String str)

возвращает: true, если строка не имеет значения null и имеет длину

а также метод

org.springframework.util.StringUtils.hasText(String str)

возвращает: true если строка не имеет значения null, ее длина больше 0 и она не содержит пробелов только

0

просто, чтобы игнорировать пробелы, а также:

if (str == null || str.trim().length() == 0) {
    // str is empty
} else {
    // str is not empty
}
0

Если вы используете Spring framework, вы можете использовать метод:

org.springframework.util.StringUtils.isEmpty(@Nullable Object str);

этот метод принимает объект в качестве аргумента, сравнивая его с null и пустую строку. Как следствие, этот метод никогда не будет возвращать true для ненулевого объекта без строки.

0

С Java 8 Необязательно вы можете сделать:

public Boolean isStringCorrect(String str) {
        return Optional.ofNullable(str)
                .map(String::trim)
                .map(string -> !str.isEmpty())
                .orElse(false);
    }

в этом выражении, вы будете обрабатывать String, состоящие из помещений.

0

лучший способ обработки null в строке -

str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()

короче,

str.length()>0 && !str.equalsIgnoreCase("null")
0