Come controllare una stringa rispetto a null in java?

Come posso controllare una stringa con null in java? sto usando

stringname.equalsignorecase(null)

ma non funziona.

string == nullconfronta se l'oggetto è nullo. string.equals("foo")confronta il valore all'interno di quell'oggetto. string == "foo"non sempre funziona, perché stai cercando di vedere se gli oggetti sono gli stessi, non i valori che rappresentano.

Risposta più lunga:

Se lo provi, non funzionerà, come hai scoperto:

String foo = null;
if (foo.equals(null)) {
    // That fails every time. 
}

Il motivo è che foo è null, quindi non sa cosa sia .equals; non c'è nessun oggetto da cui chiamare .equals.

Quello che probabilmente volevi era:

String foo = null;
if (foo == null) {
    // That will work.
}

Il modo tipico per proteggersi da un valore nullo quando si ha a che fare con le stringhe è:

String foo = null;
String bar = "Some string";
...
if (foo != null && foo.equals(bar)) {
    // Do something here.
}

In questo modo, se foo era null, non valuta la seconda metà del condizionale e le cose vanno bene.

Il modo più semplice, se stai usando una stringa letterale (invece di una variabile), è:

String foo = null;
...
if ("some String".equals(foo)) {
    // Do something here.
}

Se vuoi aggirare questo problema , Apache Commons ha una classe - StringUtils - che fornisce operazioni String null-safe.

if (StringUtils.equals(foo, bar)) {
    // Do something here.
}

Un'altra risposta stava scherzando e ha detto che dovresti farlo:

boolean isNull = false;
try {
    stringname.equalsIgnoreCase(null);
} catch (NullPointerException npe) {
    isNull = true;
}

Per favore, non farlo. Dovresti generare eccezioni solo per errori eccezionali; se ti aspetti un valore nullo, dovresti verificarlo in anticipo e non lasciare che generi l'eccezione.

Nella mia testa ci sono due ragioni per questo. Primo, le eccezioni sono lente; il controllo con null è veloce, ma quando la JVM genera un'eccezione, richiede molto tempo. In secondo luogo, il codice è molto più facile da leggere e mantenere se controlli in anticipo il puntatore nullo.

s == null

non funzionerà?

Certo che funziona. Ti stai perdendo una parte vitale del codice. Hai solo bisogno di fare così:

boolean isNull = false;
try {
    stringname.equalsIgnoreCase(null);
} catch (NullPointerException npe) {
    isNull = true;
}

;)

Usa il metodo TextUtils se lavori in Android.

TextUtils.isEmpty (str) : restituisce true se la stringa è null o di lunghezza 0. Parametri: str la stringa da esaminare Restituisce: vero se str è nullo o di lunghezza zero

  if(TextUtils.isEmpty(str)) {
        // str is null or lenght is 0
    }

Di seguito è riportato il codice sorgente di questo metodo.È possibile utilizzare direttamente.

 /**
     * Returns true if the string is null or 0-length.
     * @param str the string to be examined
     * @return true if str is null or zero length
     */
    public static boolean isEmpty(CharSequence str) {
        if (str == null || str.length() == 0)
            return true;
        else
            return false;
    }

Se guardiamo all'implementazione del metodo equalsIgnoreCase, troviamo questa parte:

if (string == null || count != string.count) {
    return false;
}

Quindi tornerà sempre falsese l'argomento è null. E questo è ovviamente giusto, perché l'unico caso in cui dovrebbe tornare trueè quando è stato invocato equalsIgnoreCase su un null String, ma

String nullString = null;
nullString.equalsIgnoreCase(null);

risulterà sicuramente in una NullPointerException.

Quindi i metodi uguali non sono progettati per verificare se un oggetto è nullo, solo perché non è possibile invocarli su null.

Sembra un po 'strano, ma ...

stringName == null || "".equals(stringName)

Non ho mai avuto problemi a farlo in questo modo, inoltre è un modo più sicuro per controllare evitando potenziali eccezioni di punti nulli.

Non sono sicuro di cosa ci fosse di sbagliato nella risposta di The MYYN.

if (yourString != null) {
  //do fun stuff with yourString here
}

Il controllo nullo di cui sopra va abbastanza bene.

Se stai cercando di verificare se un riferimento String è uguale (ignorando il caso) a un'altra stringa che sai non è un riferimento nullo, allora fai qualcosa del genere:

String x = "this is not a null reference"
if (x.equalsIgnoreCase(yourStringReferenceThatMightBeNull) ) {
  //do fun stuff
}

In caso di dubbi sulla presenza o meno di riferimenti nulli per entrambe le stringhe che si stanno confrontando, è necessario verificare la presenza di un riferimento nullo su almeno una di esse per evitare la possibilità di una NullPointerException.

Se la tua stringa ha un valore "null", puoi usare

if(null == stringName){

  [code]

}

else

[Error Msg]

importalo nella tua classe

import org.apache.commons.lang.StringUtils;

quindi usalo, entrambi restituiranno true

System.out.println(StringUtils.isEmpty(""));
System.out.println(StringUtils.isEmpty(null)); 

Puoi controllare con String == null

Questo funziona per me

    String foo = null;
    if(foo == null){
        System.out.println("String is null");
    }

Ovviamente user351809, stringname.equalsignorecase(null)lancerà NullPointerException.
Vedi, hai un oggetto stringa stringname, che segue 2 possibili condizioni: -

1. stringnameha un valore di stringa non nullo (ad esempio "computer"):
   il codice funzionerà correttamente poiché assume la forma
   "computer".equalsignorecase(null)
   e si ottiene la risposta prevista come false.
2. stringnameha un nullvalore:
   qui il tuo codice si bloccherà, poiché
   null.equalsignorecase(null)
   tuttavia, a prima vista, sembra buono e potresti sperare che una risposta true,
   ma, nullnon è un oggetto che può eseguire il equalsignorecase()metodo.

Quindi, ottieni l'eccezione a causa del caso 2.
Quello che ti suggerisco è semplicemente di usarestringname == null

Metodo semplice:

public static boolean isBlank(String value) {
    return (value == null || value.equals("") || value.equals("null") || value.trim().equals(""));
}

Se il valore valuerestituito è nullo, usa:

if(value.isEmpty());

A volte per controllare null, if(value == null)in java, potrebbe non dare true anche se String è null.

Con Java 7 puoi usare

if (Objects.equals(foo, null)) {
    ...
}

che restituirà truese entrambi i parametri sono null.

Mi rendo conto che questo ha avuto risposta molto tempo fa, ma non l'ho visto pubblicato, quindi ho pensato di condividere quello che faccio. Questo non è particolarmente buono per la leggibilità del codice, ma se devi eseguire una serie di controlli nulli, mi piace usare:

String someString = someObject.getProperty() == null ? "" : someObject.getProperty().trim();

In questo esempio, il taglio viene chiamato sulla stringa, che genererebbe un NPE se la stringa fosse nulla o spazi, ma sulla stessa riga, puoi verificare la presenza di null o vuoto in modo da non finire con una tonnellata di (più ) difficile da formattare se blocchi.

Se ho capito bene, questo dovrebbe farlo:

if(!stringname.isEmpty())
// an if to check if stringname is not null
if(stringname.isEmpy())
// an if to check if stringname is null

Ebbene, l'ultima volta che qualcuno ha posto questa stupida domanda, la risposta è stata:

someString.equals("null")

Questa "correzione" nasconde solo il problema più grande di come nulldiventa "null"in primo luogo, però.

Ci sono due modi per farlo ... Dire String == null o string.equals () ..

public class IfElse {

    public int ifElseTesting(String a){
        //return null;
        return (a== null)? 0: a.length();
    }

}

public class ShortCutifElseTesting {

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);
        System.out.println("enter the string please:");
        String a=scanner.nextLine();
        /*
        if (a.equals(null)){
            System.out.println("you are not correct");
        }
        else if(a.equals("bangladesh")){
            System.out.println("you are right");
        }
        else
            System.out.println("succesful tested");

        */
        IfElse ie=new IfElse();
        int result=ie.ifElseTesting(a);
        System.out.println(result);

    }

}

Controlla questo esempio. Ecco un altro esempio di versione scorciatoia di If Else ..