Come posso verificare se una stringa non è nulla e non è vuota?

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

Che dire di isEmpty () ?

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

Assicurati di usare le parti &&in questo ordine, perché java non procederà alla valutazione della seconda parte se la prima parte &&fallisce, assicurandoti così di non ottenere un'eccezione puntatore null da str.isEmpty()se strè null.

Attenzione, è disponibile solo da Java SE 1.6. Devi controllare str.length() == 0le versioni precedenti.

Per ignorare anche gli spazi bianchi:

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

(poiché Java 11 str.trim().isEmpty()può essere ridotto al str.isBlank()quale testerà anche altri spazi bianchi Unicode)

Avvolto in una comoda funzione:

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

diventa:

if( !empty( str ) )

Usa org.apache.commons.lang.StringUtils

Mi piace usare Apache commons-lang per questo tipo di cose, e in particolare la classe di utilità StringUtils :

import org.apache.commons.lang.StringUtils;

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

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

Basta aggiungere Android qui:

import android.text.TextUtils;

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

Per aggiungere a @BJorn e @SeanPatrickFloyd Il modo Guava di farlo è:

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

Commons Lang è più leggibile a volte, ma mi sono lentamente affidato di più a Guava, a volte Commons Lang è fonte di confusione quando si tratta di isBlank()(come in quello che è lo spazio bianco o meno).

La versione di Commons Lang di Guava isBlanksarebbe:

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

Dirò che il codice che non consente ""(vuoto) E null è sospetto e potenzialmente difettoso in quanto probabilmente non gestisce tutti i casi in cui non lo consente nullha senso (anche se per SQL posso capire come SQL / HQL sia strano '').

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

in alternativa

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

o

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

Nota: il secondo controllo (prima e seconda alternativa) presuppone che str non sia nullo. Va bene solo perché il primo controllo lo sta facendo (e Java non esegue il secondo controllo se il primo è falso)!

IMPORTANTE: NON usare == per l'uguaglianza delle stringhe. == verifica che il puntatore sia uguale, non il valore. Due stringhe possono trovarsi in indirizzi di memoria diversi (due istanze) ma hanno lo stesso valore!

Quasi ogni biblioteca So che definisce una classe di utilità chiamato StringUtils, StringUtiloStringHelper , e di solito includono il metodo che si sta cercando.

Il mio preferito è Apache Commons / Lang , dove nella classe StringUtils ottieni entrambi

(Il primo controlla se una stringa è nulla o vuota, il secondo controlla se è solo nulla, vuota o vuota)

Esistono classi di utilità simili in Spring, Wicket e molte altre librerie. Se non usi librerie esterne, potresti voler introdurre una classe StringUtils nel tuo progetto.

Aggiornamento: sono passati molti anni e in questi giorni consiglierei di usare il metodo GuavaStrings.isNullOrEmpty(string) .

Questo funziona per me:

import com.google.common.base.Strings;

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

Restituisce vero se la stringa specificata è nulla o è la stringa vuota.

Prendi in considerazione la normalizzazione dei riferimenti alle stringhe con nullToEmpty. Se lo fai, puoi usare String.isEmpty () invece di questo metodo e non avrai nemmeno bisogno di speciali forme nulle di metodi come String.toUpperCase. Oppure, se desideri normalizzare "nell'altra direzione", convertendo le stringhe vuote in null, puoi usare emptyToNull.

Che ne dite di:

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

Usa il metodo isNotBlank di Apache StringUtils come

StringUtils.isNotBlank(str)

Restituirà vero solo se str non è nullo e non è vuoto.

Dovresti usare org.apache.commons.lang3.StringUtils.isNotBlank()o org.apache.commons.lang3.StringUtils.isNotEmpty. La decisione tra questi due si basa su ciò che si desidera effettivamente verificare.

I isNotBlank () controlla che il parametro di ingresso è:

• non nullo,
• non la stringa vuota ("")
• non una sequenza di caratteri di spazi bianchi ("")

L'isNotEmpty () controlla solo che il parametro di ingresso è

• non nullo
• non la stringa vuota ("")

Restituisce vero o falso in base all'input

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

Se non si desidera includere l'intera libreria; includi semplicemente il codice che desideri da esso. Dovrai mantenerlo tu stesso; ma è una funzione piuttosto semplice. Qui è copiato da 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;
}

È un po 'troppo tardi, ma ecco uno stile funzionale di controllo:

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

C'è un nuovo metodo in java-11: String#isBlank

Restituisce vero se la stringa è vuota o contiene solo punti di codice spazio bianco, altrimenti falso.

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

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

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

Questo potrebbe essere combinato con Optionalper verificare se la stringa è nulla o vuota

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

String # ISBLANK

test è uguale a una stringa vuota e null nella stessa condizione:

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

Non genera NullPointerExceptionse str è null, poiché Object.equals()restituisce false se arg è null.

l'altro costrutto str.equals("")avrebbe gettato il temuto NullPointerException. Alcuni potrebbero considerare una cattiva forma usando un valore letterale String come l'oggetto su cui equals()viene chiamato ma fa il lavoro.

Controlla anche questa risposta: https://stackoverflow.com/a/531825/1532705

Soluzione semplice:

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

Come detto sopra da Seanizer, Apache StringUtils è fantastico per questo, se dovessi includere la guava dovresti fare quanto segue;

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

Posso anche raccomandare di fare riferimento alle colonne nel set di risultati per nome piuttosto che per indice, questo renderà il tuo codice molto più facile da mantenere.

Ho creato la mia funzione di utilità per controllare più stringhe contemporaneamente, anziché avere un'istruzione if piena di if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). Questa è la funzione:

public class StringUtils{

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

        return true;
    }   

}

così posso semplicemente scrivere:

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

Nel caso in cui si utilizzi Java 8 e si desideri avere un approccio di programmazione funzionale più, è possibile definire un approccio Functionche gestisce il controllo e quindi è possibile riutilizzarlo e apply()ogni volta che è necessario.

Venendo alla pratica, puoi definire l' Functionas

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

Quindi, puoi usarlo semplicemente chiamando il apply()metodo come:

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

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

Se preferisci, puoi definire un Functionche controlla se Stringè vuoto e quindi negarlo con !.

In questo caso, Functionsarà simile a:

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

Quindi, puoi usarlo semplicemente chiamando il apply()metodo come:

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

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

Con Java 8 opzionale puoi fare:

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

In questa espressione, gestirai anche Strings che consistono in spazi.

Puoi usare StringUtils.isEmpty (), risulterà vero se la stringa è nulla o vuota.

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

si tradurrà in

str1 è nullo o vuoto

str2 è nullo o vuoto

Consiglierei Guava o Apache Commons in base alle vostre reali esigenze. Controlla i diversi comportamenti nel mio codice di esempio:

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

Risultato:
Apache:
a è vuoto
b è vuoto
c è vuoto
Google:
b è NullOrEmpty
c è NullOrEmpty

Se si utilizza Spring Boot, il codice seguente eseguirà il lavoro

StringUtils.hasLength(str)

Per completezza: se si sta già utilizzando il framework Spring , StringUtils fornisce il metodo

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

Restituisce: vero se la stringa non è nulla e ha lunghezza

così come il metodo

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

Restituisce: vero se la stringa non è nulla, la sua lunghezza è maggiore di 0 e non contiene solo spazi bianchi

Semplicemente, per ignorare anche lo spazio bianco:

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

Se si utilizza il framework Spring, è possibile utilizzare il metodo:

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

Questo metodo accetta qualsiasi oggetto come argomento, confrontandolo con null e String vuoto. Di conseguenza, questo metodo non restituirà mai true per un oggetto non String non null.

Il modo migliore per gestire null nella stringa è,

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

In breve,

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

Per verificare se tutti gli attributi di stringa in un oggetto sono vuoti (Invece di usare! = Null su tutti i nomi dei campi seguendo l'approccio api di riflessione 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;
}

Questo metodo restituisce true se tutti i valori del campo String sono vuoti. Restituisce false se è presente uno qualsiasi degli attributi String

Ho riscontrato una situazione in cui devo verificare che "null" (come stringa) debba essere considerato vuoto. Anche lo spazio bianco e un nullo effettivo devono restituire true. Ho finalmente optato per la seguente funzione ...

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

Nel caso in cui sia necessario convalidare i parametri del metodo, è possibile utilizzare seguire il metodo semplice

public class StringUtils {

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

}

Esempio:

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