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

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

import org.apache.commons.lang.StringUtils;

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

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

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

import android.text.TextUtils;

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

чтобы добавить к @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 странно'').

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

как вариант

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

или

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

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

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

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

import com.google.common.base.Strings;

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

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

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

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

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

1. StringUtils.isEmpty (String) и
2. StringUtils.isBlank (String) метод

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

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

---

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

Как насчет:

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

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

StringUtils.isNotBlank(str)

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

Если вы не хотите включать всю библиотеку; просто включите код, который вы хотите от него. Вам придется поддерживать его самостоятельно; но это довольно прямолинейная функция. Здесь он скопирован из 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;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Я сделал свою собственную функцию полезности, чтобы проверить несколько строк сразу, а не иметь оператор 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
}

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

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

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

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

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

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

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

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

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

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

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

строка#isBlank

вы можете использовать StringUtils.пустой(), то результат 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 или пусто

Я бы посоветовал 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");
    }
  }
}

результат:
Apache:
в пустой
b-пустое
c-пустое
Google:
b является NullOrEmpty
c является NullOrEmpty

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

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

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

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

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() способ как:

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

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

для полноты картины: Если вы уже с помощью Spring framework на StringUtils обеспечить метод

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

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

а также метод

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

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

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

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

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

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

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

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

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

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

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

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

короче,

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