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

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

Что насчет isEmpty () ?

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

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

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

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

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

(поскольку Java 11 str.trim().isEmpty()может быть уменьшена доstr.isBlank() который также будет проверять другие пробелы Юникода)

Завернут в удобную функцию:

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

становится:

if( !empty( str ) )

Используйте org.apache.commons.lang.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 Guava способ сделать это:

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

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

Версия Commons Lang для Guava isBlank:

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

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

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

альтернативно

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

или

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

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

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

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

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

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

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

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

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

import com.google.common.base.Strings;

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

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

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

Как насчет:

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

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

StringUtils.isNotBlank(str)

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

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

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

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

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

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

Возвращает истину или ложь на основе ввода

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

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

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

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

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

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

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

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

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

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

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

Строка # ISBLANK

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

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

Не выдает, NullPointerExceptionесли str равен нулю, так как Object.equals()возвращает false, если аргумент равен null.

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

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

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

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

Как сказал выше 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 **/
}

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

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

Если вы используете 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

С Java 8 дополнительно вы можете сделать:

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

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

Вы можете использовать StringUtils.isEmpty (), он будет иметь значение true, если строка является пустой или пустой.

 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 является нулевым или пустым

str2 является нулевым или пустым

Я бы посоветовал 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:
a пусто
b пусто
c пусто
Google:
b равно NullOrEmpty
c равно NullOrEmpty

Если вы используете Spring Boot, то нижеприведенный код сделает работу

StringUtils.hasLength(str)

Для полноты: если вы уже используете среду Spring , StringUtils предоставляет метод

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

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

а также метод

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

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

Лучший способ обработать нуль в строке:

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

Короче говоря,

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

Проверить, все ли строковые атрибуты в объекте пусты (вместо использования! = Null во всех именах полей в соответствии с подходом API Java-отражения)

private String name1;
private String name2;
private String name3;

public boolean isEmpty()  {

    for (Field field : this.getClass().getDeclaredFields()) {
        try {
            field.setAccessible(true);
            if (field.get(this) != null) {
                return false;
            }
        } catch (Exception e) {
            System.out.println("Exception occurred in processing");
        }
    }
    return true;
}

Этот метод возвратил бы true, если все значения поля String являются пустыми, Он возвратил бы false, если в атрибутах String присутствует какое-либо одно значение

Я столкнулся с ситуацией, когда я должен проверить, что «ноль» (как строка) должен рассматриваться как пустой. Также пробел и фактический нуль должны возвращать true. Я наконец остановился на следующей функции ...

public boolean isEmpty(String testString) {
  return ((null==testString) || "".equals((""+testString).trim()) || "null".equals((""+testString).toLowerCase()));
}

Если вам нужно проверить параметры вашего метода, вы можете использовать следующий простой метод

public class StringUtils {

    static boolean anyEmptyString(String ... strings) {
        return Stream.of(strings).anyMatch(s -> s == null || s.isEmpty());
    }

}

Пример:

public String concatenate(String firstName, String lastName) {
    if(StringUtils.anyBlankString(firstName, lastName)) {
        throw new IllegalArgumentException("Empty field found");
    }
    return firstName + " " + lastName;
}