Comment vérifier une chaîne contre null en java?

Comment puis-je vérifier une chaîne par rapport à null en java? j'utilise

stringname.equalsignorecase(null)

mais ça ne marche pas.

string == nullcompare si l'objet est nul. string.equals("foo")compare la valeur à l'intérieur de cet objet. string == "foo"ne fonctionne pas toujours, car vous essayez de voir si les objets sont identiques, pas les valeurs qu'ils représentent.

Réponse plus longue:

Si vous essayez ceci, cela ne fonctionnera pas, comme vous l'avez trouvé:

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

La raison en est que foo est nul, donc il ne sait pas ce qu'est .equals; il n'y a pas d'objet à partir duquel .equals peut être appelé.

Ce que vous vouliez probablement était:

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

Le moyen typique de se prémunir contre une valeur nulle lorsque vous traitez avec des chaînes est:

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

De cette façon, si foo était nul, il n'évalue pas la seconde moitié du conditionnel, et tout va bien.

Le moyen le plus simple, si vous utilisez un littéral String (au lieu d'une variable), est:

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

Si vous souhaitez contourner ce problème , Apache Commons a une classe - StringUtils - qui fournit des opérations String de sécurité nulle.

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

Une autre réponse plaisantait et disait que vous devriez faire ceci:

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

Ne fais pas ça. Vous ne devez lancer des exceptions que pour les erreurs exceptionnelles; si vous attendez un null, vous devriez le vérifier à l'avance et ne pas le laisser lever l'exception.

Dans ma tête, il y a deux raisons à cela. Premièrement, les exceptions sont lentes; la vérification par rapport à null est rapide, mais lorsque la JVM lève une exception, cela prend beaucoup de temps. Deuxièmement, le code est beaucoup plus facile à lire et à maintenir si vous vérifiez simplement le pointeur nul à l'avance.

s == null

ne fonctionnera pas?

Bien sûr que cela fonctionne. Vous passez à côté d'une partie vitale du code. Vous avez juste besoin de faire comme ceci:

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

;)

Utilisez la méthode TextUtils si vous travaillez sous Android.

TextUtils.isEmpty (str) : renvoie true si la chaîne est nulle ou de longueur 0. Paramètres: str la chaîne à examiner Renvoie: true si str est nul ou de longueur nulle

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

Vous trouverez ci-dessous le code source de cette méthode. Vous pouvez utiliser direclty.

 /**
     * 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;
    }

Si nous regardons l'implémentation de la méthode equalsIgnoreCase, nous trouvons cette partie:

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

Donc, il reviendra toujours falsesi l'argument est null. Et c'est évidemment vrai, car le seul cas où il devrait retourner trueest celui où equalsIgnoreCase a été invoqué sur un null String, mais

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

entraînera certainement une NullPointerException.

Les méthodes equals ne sont donc pas conçues pour tester si un objet est nul, simplement parce que vous ne pouvez pas les appeler dessus null.

Cela semble un peu étrange, mais ...

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

Jamais eu de problèmes pour le faire de cette façon, et c'est un moyen plus sûr de vérifier tout en évitant les exceptions potentielles de point nul.

Je ne suis pas sûr de ce qui n'allait pas avec la réponse de The MYYN.

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

La vérification nulle ci-dessus est tout à fait correcte.

Si vous essayez de vérifier si une référence de chaîne est égale (en ignorant la casse) à une autre chaîne dont vous savez qu'elle n'est pas une référence nulle, alors faites quelque chose comme ceci:

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

En cas de doute sur le fait que vous ayez ou non des références nulles pour les deux chaînes que vous comparez, vous devrez rechercher une référence nulle sur au moins l'une d'entre elles pour éviter la possibilité d'une exception NullPointerException.

Si votre chaîne a une valeur "null", vous pouvez utiliser

if(null == stringName){

  [code]

}

else

[Error Msg]

importez-le dans votre classe

import org.apache.commons.lang.StringUtils;

puis utilisez-le, ils reviendront tous les deux true

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

Vous pouvez vérifier avec String == null

Cela fonctionne pour moi

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

Bien sûr, user351809 stringname.equalsignorecase(null)lancera NullPointerException.
Vous voyez, vous avez un objet string stringname, qui suit 2 conditions possibles: -

1. stringnamea une valeur de chaîne non nulle (disons "ordinateur"):
   Votre code fonctionnera correctement car il prend la forme
   "computer".equalsignorecase(null)
   et vous obtenez la réponse attendue sous la forme false.
2. stringnamea une nullvaleur:
   Ici, votre code restera bloqué, car
   null.equalsignorecase(null)
   cependant, semble bon à première vue et vous pouvez espérer une réponse comme true,
   mais ce nulln'est pas un objet qui peut exécuter la equalsignorecase()méthode.

Par conséquent, vous obtenez l'exception en raison du cas 2.
Ce que je vous suggère est d'utiliser simplementstringname == null

Méthode simple:

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

Si le valueretour est nul, utilisez:

if(value.isEmpty());

Parfois, pour vérifier null, if(value == null)en java, cela peut ne pas donner vrai même si la chaîne est nulle.

Avec Java 7, vous pouvez utiliser

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

qui retournera truesi les deux paramètres sont null.

Je me rends compte que cela a été répondu il y a longtemps, mais je n'ai pas vu cela publié, alors j'ai pensé partager ce que je fais. Ce n'est pas particulièrement bon pour la lisibilité du code, mais si vous devez faire une série de vérifications nulles, j'aime utiliser:

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

Dans cet exemple, trim est appelé sur la chaîne, ce qui lèverait un NPE si la chaîne était nulle ou d'espaces, mais sur la même ligne, vous pouvez vérifier la valeur nulle ou vide afin de ne pas vous retrouver avec une tonne de (plus ) difficile à formater si bloque.

Si je comprends bien, cela devrait le faire:

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

Eh bien, la dernière fois que quelqu'un a posé cette question idiote, la réponse était:

someString.equals("null")

Ce "correctif" ne fait que cacher le plus gros problème de savoir comment nulldevient "null"en premier lieu, cependant.

Il y a deux façons de le faire .. Dites String == null ou 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);

    }

}

Vérifiez cet exemple. Voici un autre exemple de version raccourcie de If Else.