Como posso verificar se uma sequência não é nula e não está vazia?

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

E o isEmpty () ?

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

Certifique-se de usar as partes &&nesta ordem, porque o java não procederá para avaliar a segunda parte se a primeira &&falhar, garantindo assim que você não receberá uma exceção de ponteiro nulo de str.isEmpty()se strfor nulo.

Cuidado, ele só está disponível desde o Java SE 1.6. Você precisa verificar str.length() == 0as versões anteriores.

Para ignorar o espaço em branco também:

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

(já que o Java 11 str.trim().isEmpty()pode ser reduzido para o str.isBlank()qual também será testado para outros espaços em branco Unicode)

Envolto em uma função útil:

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

Torna-se:

if( !empty( str ) )

Use org.apache.commons.lang.StringUtils

Eu gosto de usar o Apache commons-lang para esse tipo de coisa, e especialmente a classe de utilitário StringUtils :

import org.apache.commons.lang.StringUtils;

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

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

Basta adicionar o Android aqui:

import android.text.TextUtils;

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

Para adicionar ao @BJorn e ao @SeanPatrickFloyd A maneira do Guava de fazer isso é:

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

O Commons Lang às vezes é mais legível, mas eu tenho lentamente confiado mais na goiaba e, algumas vezes, o Commons Lang é confuso quando se trata isBlank()(como no que é espaço em branco ou não).

A versão do Commons Lang da Guava isBlankseria:

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

Vou dizer que o código que não permite ""(vazio) E null é suspeito e potencialmente defeituoso, pois provavelmente não lida com todos os casos em que não é permitido nullfaz sentido (embora para o SQL eu possa entender como SQL / HQL é estranho '').

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

alternativamente

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

ou

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

Nota: A segunda verificação (primeira e segunda alternativas) assume que str não é nulo. Tudo bem apenas porque a primeira verificação está fazendo isso (e Java não faz a segunda verificação se a primeira é falsa)!

IMPORTANTE: NÃO use == para igualdade de string. == verifica se o ponteiro é igual, não o valor. Duas cadeias podem estar em endereços de memória diferentes (duas instâncias), mas têm o mesmo valor!

Quase todas as bibliotecas que conheço definem uma classe de utilitário chamada StringUtils, StringUtilou StringHelper, e elas geralmente incluem o método que você está procurando.

Meu favorito pessoal é o Apache Commons / Lang , onde na classe StringUtils , você obtém os dois

(A primeira verifica se uma sequência é nula ou vazia, a segunda verifica se é nula, vazia ou apenas espaço em branco)

Existem classes de utilidade semelhantes no Spring, Wicket e muitas outras bibliotecas. Se você não usar bibliotecas externas, poderá introduzir uma classe StringUtils em seu próprio projeto.

Atualização: muitos anos se passaram e hoje em dia eu recomendo o uso do método GuavaStrings.isNullOrEmpty(string) .

Isso funciona para mim:

import com.google.common.base.Strings;

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

Retorna true se a sequência especificada for nula ou for a sequência vazia.

Considere normalizar suas referências de cadeia com nullToEmpty. Se você o fizer, poderá usar String.isEmpty () em vez deste método e também não precisará de formas especiais de métodos seguros para nulos, como String.toUpperCase. Ou, se você quiser normalizar "na outra direção", convertendo cadeias vazias para nulas, poderá usar emptyToNull.

E se:

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

Use o método isNotBlank do Apache StringUtils como

StringUtils.isNotBlank(str)

Ele retornará true somente se o str não for nulo e não estiver vazio.

Você deve usar org.apache.commons.lang3.StringUtils.isNotBlank()ou org.apache.commons.lang3.StringUtils.isNotEmpty. A decisão entre esses dois se baseia no que você realmente deseja verificar.

O isNotBlank () verifica se o parâmetro de entrada é:

• não nulo,
• não a sequência vazia ("")
• não é uma sequência de caracteres de espaço em branco ("")

O isNotEmpty () verifica apenas se o parâmetro de entrada está

• não nulo
• não a string vazia ("")

Retorna verdadeiro ou falso com base na entrada

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

Se você não deseja incluir a biblioteca inteira; inclua o código que você deseja. Você terá que manter você mesmo; mas é uma função bastante direta. Aqui é copiado de 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;
}

É um pouco tarde demais, mas aqui está um estilo funcional de verificação:

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

Existe um novo método em java-11: String#isBlank

Retorna true se a string estiver vazia ou contiver apenas pontos de código de espaço em branco, caso contrário, false.

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

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

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

Isso pode ser combinado com Optionalpara verificar se a string é nula ou vazia

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

String # isBlank

teste é igual a uma cadeia vazia e nulo na mesma condicional:

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

Não lança NullPointerExceptionse str for nulo, pois Object.equals()retorna false se arg for null.

a outra construção str.equals("")jogaria o temido NullPointerException. Alguns podem considerar uma forma incorreta usando um literal String como o objeto equals()chamado, mas ele faz o trabalho.

Verifique também esta resposta: https://stackoverflow.com/a/531825/1532705

Solução simples:

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

Como o seanizer disse acima, o Apache StringUtils é fantástico para isso, se você incluir a goiaba, faça o seguinte;

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

Também recomendo que você consulte as colunas em seu conjunto de resultados por nome e não por índice, isso facilitará a manutenção do seu código.

Eu criei minha própria função de utilitário para verificar várias strings de uma só vez, em vez de ter uma declaração if cheia de if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). Esta é a função:

public class StringUtils{

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

        return true;
    }   

}

para que eu possa simplesmente escrever:

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

Caso esteja usando o Java 8 e deseje ter uma abordagem mais de Programação Funcional, é possível definir um Functionque gerencia o controle e, em seguida, reutilizá-lo e apply()sempre que necessário.

Vindo para a prática, você pode definir o Functionquanto

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

Em seguida, você pode usá-lo simplesmente chamando o apply()método como:

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

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

Se preferir, você pode definir um Functionque verifique se o Stringestá vazio e depois negá-lo !.

Nesse caso, o Functionserá semelhante a:

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

Em seguida, você pode usá-lo simplesmente chamando o apply()método como:

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

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

Com o Java 8 Optional, você pode fazer:

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

Nesta expressão, você manipulará Strings que também consistem em espaços.

Você pode usar StringUtils.isEmpty (), resultará true se a string for nula ou vazia.

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

vai resultar em

str1 é nulo ou vazio

str2 é nulo ou vazio

Eu recomendaria o Guava ou o Apache Commons de acordo com sua necessidade real. Verifique os diferentes comportamentos no meu código de exemplo:

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

Resultado:
Apache:
a está em branco
b está em branco
c está em branco
Google:
b é NullOrEmpty
c é NullOrEmpty

Se você estiver usando o Spring Boot, o código abaixo fará o trabalho

StringUtils.hasLength(str)

Para ser completo: se você já estiver usando a estrutura Spring , o StringUtils fornecerá o método

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

Retorna: true se a String não for nula e tiver comprimento

bem como o método

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

Retorna: true se a String não for nula, seu comprimento for maior que 0 e não conter apenas espaço em branco

Simplesmente, também para ignorar o espaço em branco:

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

Se você usa o framework Spring, pode usar o método:

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

Este método aceita qualquer objeto como argumento, comparando-o com nulo e a string vazia. Como conseqüência, esse método nunca retornará true para um objeto não-nulo e não-String.

A melhor maneira de lidar com nulo na string é,

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

Em resumo,

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

Para verificar se todos os atributos de seqüência de caracteres em um objeto estão vazios (em vez de usar! = Null em todos os nomes de campos após a abordagem da API de reflexão de 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;
}

Este método retornaria true se todos os valores do campo String estivessem em branco. Retornaria false se algum valor estivesse presente nos atributos String.

Eu encontrei uma situação em que devo verificar se "nulo" (como uma string) deve ser considerado vazio. Também o espaço em branco e um nulo real devem retornar true. Finalmente resolvi a seguinte função ...

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

Caso você precise validar os parâmetros do seu método, você pode seguir o método simples

public class StringUtils {

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

}

Exemplo:

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