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

Question

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

 stringname.equalsignorecase(null)
 

mais ça ne marche pas.

Answer 1

string == null compare si l'objet est null. string.equals("foo") compare la valeur à l'intérieur de cet objet. string == "foo" ne fonctionne jamais, parce que vous essayez de voir si les objets de correspondance, pas de les valeurs à l'intérieur d'eux.

Plus de réponse:

Si vous essayez cela, il ne fonctionne pas, comme vous l'avez trouvé:

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

La raison en est que foo est nulle, de sorte qu'il ne sait pas quoi .est égal à est; il n'y a pas d'objet .équivaut à être appelés à partir.

Ce que vous avez probablement voulu, c'était:

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

Typique de la façon de vous protéger contre une valeur null lorsque l'on traite 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 toto est nulle, il n'a pas d'évaluer la seconde moitié du conditionnel, et les choses sont tous de droite.

Le moyen le plus facile, si vous utilisez une Chaîne littérale (au lieu d'une variable), est:

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

Si vous souhaitez travailler autour de cela, Apache Commons dispose d'une classe - StringUtils - null-sécurité de la Chaîne des opérations.

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

Une autre réponse a été plaisante, et dit que vous devriez faire ceci:

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

Merci de ne pas le faire. Vous ne devez lancer des exceptions pour les erreurs qui sont exceptionnelles; si vous vous attendez à une valeur null, vous devriez vérifier pour qu'elle avance, et ne le laissez pas jeter l'exception.

Dans ma tête, il y a deux raisons à cela. Tout d'abord, les exceptions sont lents; la vérification par rapport à null est rapide, mais lorsque la JVM déclenche une exception, il prend beaucoup de temps. Deuxièmement, le code est beaucoup plus facile à lire et à maintenir si vous venez de vérifier le pointeur null à l'avance.

Answer 2

 s == null
 

ne fonctionnera pas?

Answer 3

Bien sûr ça marche. Vous manquez une partie essentielle du code. Vous avez juste besoin de faire comme ça:

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

;)

Answer 4

Si nous regardons la mise en œuvre de la equalsIgnoreCase méthode, nous trouvons cette partie:

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

Donc, il va toujours revenir false si l'argument est - null. Et c'est évidemment le droit, parce que le seul cas où il doit retourner true , c'est quand equalsIgnoreCase a été appelée sur un null String, mais

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

va certainement entraîner une NullPointerException.

Donc égal méthodes ne sont pas conçus pour tester si un objet est null, juste parce que vous ne pouvez pas les invoquer sur l' null.

Answer 5

Je ne suis pas sûr de ce qui va mal avec La MYYN de réponse.

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

Le ci-dessus null check est tout à fait correct.

Si vous essayez de vérifier si une Chaîne de référence est égal (en ignorant les cas) à une autre chaîne que vous savez 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
}

Si il y a un doute quant à savoir si ou non vous avez des références nulles pour les deux Chaînes que vous comparez, vous aurez besoin de vérifier une référence null sur au moins l'un d'entre eux afin d'éviter la possibilité d'une NullPointerException.