Comment vérifier si ma chaîne est égale à null?

172

Je veux effectuer une action UNIQUEMENT SI ma chaîne a une valeur significative. Alors, j'ai essayé ça.

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

et ça

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

et ça

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

et ça

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

et ça

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

Et dans tous les cas mon programme doSomethingmalgré le fait que ma chaîne EST VIDE. Cela équivaut à null. Alors, qu'est-ce qui ne va pas avec ça?

AJOUTÉE:

J'ai trouvé la raison du problème. La variable a été déclarée sous forme de chaîne et, par conséquent, nullaffectée à cette variable a été transformée en "null"! Alors, ça if (!myString.equals("null"))marche.

romain
la source
2
nulln'a aucune méthode, donc pas non plus equals(). Si myStringc'était le cas null, comment invoqueriez-vous une méthode dessus? :)
BalusC
1
Puis-je vous suggérer System.out.println(myString)immédiatement avant le bloc if afin que vous puissiez voir ce qu'il y a?
Michael Myers
1
Comment savez-vous que "c'est égal à null"?
Richard JP Le Guen
6
nullattribué à cette variable a été transformé en "null"- c'est une idée terrible. Essayez de changer cette conception si possible.
polygenelubricants
8
Beurk - Je ne pense pas que vérifier si (! MyString.equals ("null")) est la meilleure solution. Je soupçonne que la plupart considéreraient le point auquel la chaîne «null» a été assignée à myString comme un bogue.
Bert F

Réponses:

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

Comme autre commentaire, vous devez être conscient de cette condition dans le equalscontrat:

De Object.equals(Object):

Pour toute valeur de référence non nulle x, x.equals(null)should return false.

La façon de comparer avec nullest d'utiliser x == nullet x != null.

De plus, x.fieldet x.method()jette NullPointerExceptionsi x == null.

lubrifiants polygènes
la source
2
Vous devriez faire une vérification de la longueur par opposition à l'égale pour des raisons d'efficacité. Vérifiez ce lien hanuska.blogspot.com/2006/08/empty-string.html
CoolBeans
7
Je dirais que vous devriez faire s.isEmpty()au lieu de s.length() == 0pour la lisibilité. Toute différence de performance est négligeable. Je suis d'accord que s.equals("")c'est terrible.
polygenelubricants
6
Je suis d'accord sur la lisibilité. Cela dépend si nous utilisons Java 5 vs Java 6 puisque isEmpty () n'est que dans Java 6.
CoolBeans
@CoolBeans: Bon commentaire! Je n'avais pas réalisé ça! Je suis un peu en retard à la fête Java =)
polygenelubricants
26

Si myStringc'est le cas null, alors l'appel myString.equals(null)ou myString.equals("")échouera avec un NullPointerException. Vous ne pouvez appeler aucune méthode d'instance sur une variable nulle.

Vérifiez d'abord null comme ceci:

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

Cela utilise une évaluation de court-circuit pour ne pas tenter le .equalssi myStringéchoue la vérification nulle.

Michael Myers
la source
+1 pour court-circuit; il est essentiel que l'expression fonctionne. Cependant, vous devriez vraiment utiliser à la .isEmpty()place de .equals("").
polygenelubricants
1
D'accord, je voulais laisser mon commentaire sur ce post. lol. -> "Vous devriez faire une vérification de longueur plutôt que d'égalité pour des raisons d'efficacité. Vérifiez ce lien hanuska.blogspot.com/2006/08/empty-string.html"
CoolBeans
@CoolBeans: Bien sûr, et avec Java 6, vous pouvez même le faire myString.isEmpty(). Mais à ce niveau, la lisibilité l'emporte sur l'optimisation, et les gens pourraient être plus habitués à la lecture myString.equals(""). (Ou peut-être pas.)
Michael Myers
20

Apache commons StringUtils.isNotEmptyest la meilleure solution.

kedar
la source
13

Si myString est en fait nul, tout appel à la référence échouera avec une exception de pointeur nul (NPE). Depuis java 6, utilisez #isEmpty au lieu de la vérification de la longueur (dans tous les cas, ne créez JAMAIS une nouvelle chaîne vide avec la vérification).

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

Incidemment, si la comparaison avec des littéraux String comme vous le faites, inverserait l'instruction afin de ne pas avoir à avoir une vérification nulle, c'est-à-dire,

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

au lieu de :

if (myString != null &&  myString.equals("some string to check")){
    doSomething();
}
corme
la source
1
Bon point, mais les deux derniers ifs ne sont pas équivalents. Avec myString = "abc", celui du milieu n'appelle pas doSomething mais le troisième le fait.
rimsky
@rimsky c'est corrigé
pavi2410
7

TRAVAIL !!!!

if (myString != null && !myString.isEmpty()) {
    return true;
}
else {
    return false;
}
Salman Nazir
la source
6

Vous devez vérifier que l' myStringobjet est null:

if (myString != null) {
    doSomething
}
Tourbillon
la source
5

Si votre chaîne est null, les appels comme celui-ci devraient lever une NullReferenceException:

myString.equals (null)

Mais de toute façon, je pense qu'une méthode comme celle-ci est ce que vous voulez:

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

Ensuite, dans votre code, vous pouvez faire des choses comme ceci:

if (!StringUtils.isNullOrEmpty(myString))
{
    doSomething();
}
Andy White
la source
5

Je vous encourage à utiliser un utilitaire existant ou à créer votre propre méthode:

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

Ensuite, utilisez-le quand vous en avez besoin:

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

Comme indiqué ci-dessus, le || et && court-circuit des opérateurs. Cela signifie que dès qu'ils peuvent déterminer leur valeur, ils s'arrêtent. Donc, si (string == null) est vrai, la partie longueur n'a pas besoin d'être évaluée, car l'expression serait toujours vraie. De même avec &&, où si le côté gauche est faux, l'expression est toujours fausse et n'a pas besoin d'être évaluée davantage.

De plus, utiliser length est généralement une meilleure idée que d'utiliser .equals. Les performances sont légèrement meilleures (pas beaucoup) et ne nécessitent pas de création d'objet (bien que la plupart des compilateurs puissent optimiser cela).

Mat
la source
4

Essayer,

myString!=null && myString.length()>0
bragboy
la source
ce n'est pas possible si myString est nul
hsmit
4
c'est à peu près possible lorsque myString est nul. Vous devez savoir que lorsque la partie gauche du && échoue, la bonne expression ne sera pas du tout évaluée.
bragboy
4

Chaque fois que je dois gérer des chaînes (presque à chaque fois), je m'arrête et je me demande quel est vraiment le moyen le plus rapide de vérifier une chaîne vide. Bien sûr, le contrôle string.Length == 0 devrait être le plus rapide car Length est une propriété et il ne devrait y avoir aucun traitement autre que la récupération de la valeur de la propriété. Mais alors je me demande, pourquoi y a-t-il un String.Empty? Il devrait être plus rapide de vérifier String.Empty que longueur, me dis-je. Eh bien, j'ai finalement décidé de le tester. J'ai codé une petite application Windows Console qui me dit combien de temps il faut pour faire une certaine vérification pour 10 millions de répétitions. J'ai vérifié 3 chaînes différentes: une chaîne NULL, une chaîne vide et une chaîne "". J'ai utilisé 5 méthodes différentes: 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

Selon ces résultats, la vérification str == nullest en moyenne la plus rapide, mais peut ne pas toujours donner ce que nous recherchons. if str = String.Emptyou str = "", il en résulte faux. Ensuite, vous avez 2 qui sont à égalité à la deuxième place: String.IsNullOrEmpty()et str == null || str.length == 0. Comme String.IsNullOrEmpty()il est plus beau et plus facile (et plus rapide) à écrire, je recommanderais de l'utiliser par rapport à l'autre solution.

ldsant
la source
3

Je ferais quelque chose comme ça:

( myString != null && myString.length() > 0 )
    ? doSomething() : System.out.println("Non valid String");
  • Le test de null vérifie si myString contient une instance de String.
  • length () renvoie la longueur et équivaut à égal à ("").
  • Vérifier d'abord si myString est null évitera une NullPointerException.
James P.
la source
3

J'utilisais StringUtil.isBlank(string)

Il teste si une chaîne est vide: null, emtpy ou uniquement des espaces.

Donc celui-ci est le meilleur jusqu'à présent

Voici la méthode orignal de la documentation

/**
    * 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;
    } 
Max
la source
2

Cela devrait fonctionner:

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

Sinon, myString a probablement une valeur que vous n'attendez pas. Essayez de l'imprimer comme ceci:

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

L'utilisation des symboles '+' pour entourer la chaîne vous montrera s'il y a des espaces supplémentaires que vous ne tenez pas compte.

elduff
la source
2

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

Moe
la source
3
isEmpty est inversé .. si vous appelez la méthode sur un objet nul, vous obtenez NPE
Brian
Si la chaîne est nulle, vous obtenez une exception de pointeur nul, avant même de vérifier qu'elle est nulle. Ce code ne doit jamais être utilisé!
gil.fernandes
2

Ok, c'est ainsi que fonctionnent les types de données en Java. (Vous devez excuser mon anglais, je n'utilise probablement pas le bon vocabulaire. Vous devez différencier deux d'entre eux. Les types de données de base et les types de données normaux. Les types de données de base constituent à peu près tout ce qui existe. Par exemple, il sont tous des nombres, char, booléens, etc. Les types de données normaux ou les types de données complexes sont tout le reste Une chaîne est un tableau de caractères, donc un type de données complexe.

Chaque variable que vous créez est en fait un pointeur sur la valeur dans votre mémoire. Par exemple:

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

la variable "s" ne contient PAS de chaîne. C'est un indicateur. Ce pointeur pointe sur la variable dans votre mémoire. Lorsque vous appelez System.out.println(anyObject), la toString()méthode de cet objet est appelée. S'il n'a pas remplacé toStringObject, il imprimera le pointeur. Par exemple:

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

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

Tout ce qui se trouve derrière le "@" est le pointeur. Cela ne fonctionne que pour les types de données complexes. Les types de données primitifs sont enregistrés DIRECTEMENT dans leur pointeur. Donc en fait, il n'y a pas de pointeur et les valeurs sont stockées directement.

Par exemple:

int i = 123;

Je ne stocke PAS de pointeur dans ce cas. je vais stocker la valeur entière 123 (en octet ofc).

Bon alors revenons à l' ==opérateur. Il compare toujours le pointeur et non le contenu enregistré à la position du pointeur dans la mémoire.

Exemple:

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

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

>>>>> false

Ces deux chaînes ont un pointeur différent. String.equals (String other) compare cependant le contenu. Vous pouvez comparer des types de données primitifs avec l'opérateur '==' car le pointeur de deux objets différents avec le même contenu est égal.

Null signifierait que le pointeur est vide. Un type de données primitif vide par défaut est 0 (pour les nombres). Null pour tout objet complexe signifie cependant que cet objet n'existe pas.

Salutations

Luecx
la source
2

Pour moi, le meilleur contrôle si une chaîne a un contenu significatif en Java est celui-ci:

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

Vous vérifiez d'abord si la chaîne est nullà éviter NullPointerException, puis vous coupez tous les caractères d'espacement pour éviter de vérifier les chaînes qui n'ont que des espaces et enfin vous vérifiez si la chaîne coupée n'est pas vide, c'est-à-dire qu'elle a une longueur de 0.

gil.fernandes
la source
1

J'ai eu ce problème sous Android et j'utilise de cette façon (Travaille pour moi):

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

Mais dans le code java, j'utilise:

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

Et :

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);
}
AA
la source
1

Dans Android, vous pouvez vérifier cela avec la méthode utilitaire isEmptyde TextUtils,

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

isEmpty(CharSequence str)méthode vérifie à la fois la condition, la nulllongueur et la longueur

NSK
la source
1

J'utilise toujours comme ça:

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

ou vous pouvez copier ceci dans votre projet:

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

et appelez-le simplement comme:

boolean b = isEmptyOrNull(yourString);

il retournera vrai si est vide ou nul.
b=truesi est vide ou nul

ou vous pouvez utiliser try catch and catch quand il est nul.

Web.11
la source
0

Je pense que myString n'est pas une chaîne mais un tableau de chaînes. Voici ce que tu dois faire:

String myNewString = join(myString, "")
if (!myNewString.equals(""))
{
    //Do something
}
mimer
la source
Mon code est pour le traitement. Le traitement est un langage de programmation basé sur Java. Plus d'informations sur join: processing.org/reference/join_.html .
mimiter
0

Vous pouvez vérifier la chaîne égale à null en utilisant ceci:

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

Si le résultat est 0 alors (Test + "") = "null".

Harrouchi Taher
la source
cela crée juste une chaîne inutile
svarog
0

J'ai essayé la plupart des exemples donnés ci-dessus pour un null dans une application Android que je construisais et tout a échoué. J'ai donc trouvé une solution qui fonctionnait à tout moment pour moi.

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

}

Donc, concaténez simplement une chaîne vide comme je l'ai fait ci-dessus et testez "null" et cela fonctionne bien. En fait aucune exception n'est lancée

leeCoder
la source
1
Non, c'est une solution absolument terrible. Les réponses ci-dessus fonctionnent.
Konrad Rudolph le
@KonradRudolph J'ai en fait essayé certaines de ces solutions ci-dessus avant d'arriver à ma conclusion. J'ai essayé d'utiliser ces soluton dans un adaptateur recyclerview et cela ne m'a pas donné le résultat correct jusqu'à ce que je trouve cette réponse.
leeCoder
Je peux dire en toute confiance que cela signifie qu'il y a autre chose qui ne va pas avec votre code, et que vous corrigez simplement les symptômes, pas la source de l'erreur. Ne le prenez pas mal, mais c'est un cas typique de programmation culte du fret .
Konrad Rudolph
0

L'exception peut également aider:

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

Si vous travaillez sous Android, vous pouvez utiliser la classe TextUtils simple. Vérifiez le code suivant:

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

C'est une simple utilisation du code. La réponse peut être répétée. Mais il est simple d'avoir un chèque unique et simple pour vous.

Manmohan Soni
la source
-5

Vous devez vérifier avec null if(str != null).

rawa rawandze
la source
5
Votre solution a été postée par d'autres utilisateurs il y a des années ... Quel est l'intérêt de la répéter?
TDG
1
je ne vois
aucune
6
D'accord, il n'a pas confirmé les réponses depuis 2010, donc vous allez simplement répéter une réponse précédente et il confirmera votre réponse ...
TDG