Come verificare se la mia stringa è uguale a null?

Voglio eseguire alcune azioni SOLO SE la mia stringa ha un valore significativo. Quindi ho provato questo.

if (!myString.equals("")) {
doSomething
}

e questo

if (!myString.equals(null)) {
doSomething
}

e questo

if ( (!myString.equals("")) && (!myString.equals(null))) {
doSomething
}

e questo

if ( (!myString.equals("")) && (myString!=null)) {
doSomething
}

e questo

if ( myString.length()>0) {
doSomething
}

E in ogni caso il mio programma doSomethingnonostante il fatto che la mia stringa sia VUOTA. È uguale a null. Quindi, cosa c'è di sbagliato in questo?

AGGIUNTO:

Ho trovato il motivo del problema. La variabile è stata dichiarata come una stringa e, di conseguenza, nullassegnata a questa variabile è stata trasformata in "null"! Quindi if (!myString.equals("null"))funziona.

if (myString != null && !myString.isEmpty()) {
  // doSomething
}

Come ulteriore commento, dovresti essere a conoscenza di questo termine nel equalscontratto:

Da Object.equals(Object):

Per qualsiasi valore di riferimento non nullo x, x.equals(null)dovrebbe return false.

Il modo di confrontare nullè usare x == nulle x != null.

Inoltre, x.fielde x.method()genera NullPointerExceptionif x == null.

Se lo myStringè null, quindi chiamare myString.equals(null)o myString.equals("")fallirà con a NullPointerException. Non è possibile chiamare alcun metodo di istanza su una variabile null.

Controlla prima null come questo:

if (myString != null && !myString.equals("")) {
    //do something
}

Questo utilizza la valutazione del corto circuito per non tentare il controllo null .equalsse myStringfallisce.

Apache Commons StringUtils.isNotEmptyè il modo migliore per andare.

Se myString è effettivamente nullo, qualsiasi chiamata al riferimento fallirà con un'eccezione del puntatore null (NPE). Da java 6, usa #isEmpty invece del controllo di lunghezza (in ogni caso NON creare MAI una nuova stringa vuota con il controllo).

if (myString != null &&  !myString.isEmpty()){
    doSomething();
}

Per inciso, se confrontato con i letterali String come fai tu, invertiresti l'istruzione in modo da non dover avere un controllo nullo, cioè,

if ("some string to check".equals(myString)){
  doSomething();
} 

invece di :

if (myString != null &&  myString.equals("some string to check")){
    doSomething();
}

LAVORANDO !!!!

if (myString != null && !myString.isEmpty()) {
    return true;
}
else {
    return false;
}

Devi verificare che l' myStringoggetto sia null:

if (myString != null) {
    doSomething
}

Se la tua stringa è nulla, chiamate come questa dovrebbero generare una NullReferenceException:

myString.equals (null)

Ma comunque, penso che un metodo come questo sia quello che vuoi:

public static class StringUtils
{
    public static bool isNullOrEmpty(String myString)
    {
         return myString == null || "".equals(myString);
    }
}

Quindi nel tuo codice, puoi fare cose come queste:

if (!StringUtils.isNullOrEmpty(myString))
{
    doSomething();
}

Incoraggerei l'uso di un'utilità esistente o la creazione del proprio metodo:

public static boolean isEmpty(String string) {
    return string == null || string.length() == 0;
}

Quindi usalo quando ne hai bisogno:

if (! StringUtils.isEmpty(string)) {
  // do something
}

Come notato sopra, il || e && operatori in corto circuito. Ciò significa che non appena possono determinare il loro valore, si fermano. Quindi se (stringa == null) è vero, la parte lunghezza non deve essere valutata, poiché l'espressione sarebbe sempre vera. Allo stesso modo con &&, dove se il lato sinistro è falso, l'espressione è sempre falsa e non è necessario valutarla ulteriormente.

Come nota aggiuntiva, l'utilizzo della lunghezza è generalmente un'idea migliore rispetto all'utilizzo di .equals. Le prestazioni sono leggermente migliori (non molto) e non richiedono la creazione di oggetti (anche se la maggior parte dei compilatori potrebbe ottimizzarlo).

Provare,

myString!=null && myString.length()>0

 if (myString != null && myString.length() > 0) {

        // your magic here

 }

Per inciso, se stai facendo molta manipolazione delle stringhe, c'è una grande classe Spring con tutti i tipi di metodi utili:

http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html

Ogni volta che ho a che fare con le stringhe (quasi ogni volta) mi fermo e mi chiedo quale sia il modo più veloce per controllare una stringa vuota. Ovviamente il controllo string.Length == 0 dovrebbe essere il più veloce poiché Length è una proprietà e non dovrebbe esserci alcuna elaborazione diversa dal recupero del valore della proprietà. Ma poi mi chiedo, perché c'è String.Empty? Dovrebbe essere più veloce controllare String.Empty che in lunghezza, mi dico. Bene, alla fine ho deciso di provarlo. Ho codificato una piccola app di Windows Console che mi dice quanto tempo ci vuole per fare un certo controllo per 10 milioni di ripetizioni. Ho controllato 3 stringhe diverse: una stringa NULL, una stringa vuota e una "" stringa. Ho usato 5 metodi diversi: String.IsNullOrEmpty (), str == null, str == null || str == String.Empty, str == null || str == "", str == null || str.

String.IsNullOrEmpty()
NULL = 62 milliseconds
Empty = 46 milliseconds
"" = 46 milliseconds

str == null
NULL = 31 milliseconds
Empty = 46 milliseconds
"" = 31 milliseconds

str == null || str == String.Empty
NULL = 46 milliseconds
Empty = 62 milliseconds
"" = 359 milliseconds

str == null || str == ""
NULL = 46 milliseconds
Empty = 343 milliseconds
"" = 78 milliseconds

str == null || str.length == 0
NULL = 31 milliseconds
Empty = 63 milliseconds
"" = 62 milliseconds

In base a questi risultati, il controllo medio str == nullè il più veloce, ma potrebbe non fornire sempre ciò che stiamo cercando. if str = String.Emptyoppure str = "", risulta falso. Quindi hai 2 che sono legati al secondo posto: String.IsNullOrEmpty()e str == null || str.length == 0. Dal momento che String.IsNullOrEmpty()sembra più bello ed è più facile (e più veloce) scrivere che consiglierei di usarlo sull'altra soluzione.

Farei qualcosa del genere:

( myString != null && myString.length() > 0 )
    ? doSomething() : System.out.println("Non valid String");

• Il test per null verifica se myString contiene un'istanza di String.
• lunghezza () restituisce la lunghezza ed equivale a uguale a "" ".
• Controllare se myString è null per primo eviterà una NullPointerException.

Sto usando StringUtil.isBlank(string)

Verifica se una stringa è vuota: null, emtpy o solo spazi bianchi.

Quindi questo è il migliore finora

Ecco il metodo originale dai documenti

/**
    * Tests if a string is blank: null, emtpy, or only whitespace (" ", \r\n, \t, etc)
    * @param string string to test
    * @return if string is blank
    */
    public static boolean isBlank(String string) {
        if (string == null || string.length() == 0)
            return true;

        int l = string.length();
        for (int i = 0; i < l; i++) {
            if (!StringUtil.isWhitespace(string.codePointAt(i)))
                return false;
        }
        return true;
    } 

Questo dovrebbe funzionare:

if (myString != null && !myString.equals(""))
    doSomething
}

In caso contrario, probabilmente myString ha un valore che non ti aspetti. Prova a stamparlo in questo modo:

System.out.println("+" + myString + "+");

L'uso dei simboli '+' per circondare la stringa ti mostrerà se ci sono spazi bianchi extra che non stai considerando.

if(str.isEmpty() || str==null){ do whatever you want }

Bene, ecco come funzionano i tipi di dati in Java. (Devi scusare il mio inglese, probabilmente non sto usando il vocabolario giusto. Devi distinguere tra due di essi. I tipi di dati di base e i tipi di dati normali. I tipi di dati di base costituiscono praticamente tutto ciò che esiste. Ad esempio, lì sono tutti numeri, caratteri, booleani ecc. I normali tipi di dati o tipi di dati complessi sono tutto il resto. Una stringa è un array di caratteri, quindi un tipo di dati complesso.

Ogni variabile che crei è in realtà un puntatore al valore nella tua memoria. Per esempio:

String s = new String("This is just a test");

la variabile "s" NON contiene una stringa. È un puntatore. Questo puntatore punta sulla variabile nella tua memoria. Quando chiami System.out.println(anyObject), toString()viene chiamato il metodo di quell'oggetto. Se non sovrascrive toStringda Object, stamperà il puntatore. Per esempio:

public class Foo{
    public static void main(String[] args) {
        Foo f = new Foo();
        System.out.println(f);
    }
}

>>>>
>>>>
>>>>Foo@330bedb4

Tutto dietro "@" è il puntatore. Funziona solo con tipi di dati complessi. I tipi di dati primitivi vengono salvati DIRETTAMENTE nel loro puntatore. Quindi in realtà non esiste un puntatore e i valori vengono memorizzati direttamente.

Per esempio:

int i = 123;

in questo caso NON memorizzo un puntatore. memorizzerò il valore intero 123 (in byte ofc).

Va bene, quindi torniamo ==all'operatore. Confronta sempre il puntatore e non il contenuto salvato nella posizione del puntatore nella memoria.

Esempio:

String s1 = new String("Hallo");
String s2 = new String("Hallo");

System.out.println(s1 == s2);

>>>>> false

Entrambe le stringhe hanno un puntatore diverso. String.equals (String altro) confronta tuttavia il contenuto. È possibile confrontare i tipi di dati primitivi con l'operatore '==' perché il puntatore di due oggetti diversi con lo stesso contenuto è uguale.

Null significherebbe che il puntatore è vuoto. Un tipo di dati primitivo vuoto per impostazione predefinita è 0 (per i numeri). Nulla per qualsiasi oggetto complesso significa tuttavia che quell'oggetto non esiste.

Saluti

Per me il miglior controllo se una stringa ha contenuti significativi in ​​Java è questo:

string != null && !string.trim().isEmpty()

Per prima cosa controlla se la stringa deve nullessere evitata NullPointerExceptione poi ritaglia tutti i caratteri dello spazio per evitare di controllare le stringhe che hanno solo spazi bianchi e infine controlli se la stringa tagliata non è vuota, ovvero ha lunghezza 0.

Ho avuto questo problema in Android e lo uso in questo modo (Lavora per me):

String test = null;
if(test == "null"){
// Do work
}

Ma nel codice Java uso:

String test = null;
if(test == null){
// Do work
}

E :

private Integer compareDateStrings(BeanToDoTask arg0, BeanToDoTask arg1, String strProperty) {
    String strDate0 = BeanUtils.getProperty(arg0, strProperty);_logger.debug("strDate0 = " + strDate0);
    String strDate1 = BeanUtils.getProperty(arg1, strProperty);_logger.debug("strDate1 = " + strDate1);
    return compareDateStrings(strDate0, strDate1);
}

private Integer compareDateStrings(String strDate0, String strDate1) {
    int cmp = 0;
    if (isEmpty(strDate0)) {
        if (isNotEmpty(strDate1)) {
            cmp = -1;
        } else {
            cmp = 0;
        }
    } else if (isEmpty(strDate1)) {
        cmp = 1;
    } else {
        cmp = strDate0.compareTo(strDate1);
    }
    return cmp;
}

private boolean isEmpty(String str) {
    return str == null || str.isEmpty();
}
private boolean isNotEmpty(String str) {
    return !isEmpty(str);
}

Preferisco usare:

if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null
    // do something
}

Leggi StringUtils.isBlank () vs String.isEmpty () .

In Android puoi verificarlo con il metodo di utilità isEmptyda TextUtils,

public static boolean isEmpty(CharSequence str) {
    return str == null || str.length() == 0;
}

isEmpty(CharSequence str)il metodo controlla sia la condizione, nullsia la lunghezza.

Uso sempre così:

if (mystr != null && !mystr.isEmpty()){
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}else {
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}

oppure puoi copiarlo nel tuo progetto:

private boolean isEmptyOrNull(String mystr){
    if (mystr != null && !mystr.isEmpty()){ return true; }
    else { return false; }
}

e chiamalo semplicemente come:

boolean b = isEmptyOrNull(yourString);

restituirà vero se è vuoto o nullo.
b=truese è vuoto o nullo

oppure puoi usare try catch and catch quando è null.

Penso che myString non sia una stringa ma una matrice di stringhe. Ecco cosa devi fare:

String myNewString = join(myString, "")
if (!myNewString.equals(""))
{
    //Do something
}

Puoi controllare una stringa uguale a null usando questo:

String Test = null;
(Test+"").compareTo("null")

Se il risultato è 0, allora (Test + "") = "null".

Ho provato la maggior parte degli esempi sopra riportati per un null in un'app Android che stavo costruendo e TUTTO NON È RIUSCITO. Quindi ho trovato una soluzione che ha funzionato in qualsiasi momento per me.

String test = null+"";
If(!test.equals("null"){
       //go ahead string is not null

}

Quindi concatena semplicemente una stringa vuota come ho fatto sopra e prova contro "null" e funziona benissimo. In effetti non viene generata alcuna eccezione

L'eccezione può anche aiutare:

try {
   //define your myString
}
catch (Exception e) {
   //in that case, you may affect "" to myString
   myString="";
}

Se lavori in Android, puoi utilizzare la semplice classe TextUtils. Controlla il seguente codice:

if(!TextUtils.isEmpty(myString)){
 //do something
}

Questo è un semplice utilizzo del codice. La risposta può essere ripetuta. Ma è semplice avere un controllo singolo e semplice per te.

Devi controllare con null if(str != null).