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

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.

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.

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.

Apache commons StringUtils.isNotEmptyest la meilleure solution.

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();
}

TRAVAIL !!!!

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

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

if (myString != null) {
    doSomething
}

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();
}

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).

Essayer,

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

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

        // your magic here

 }

Incidemment, si vous faites beaucoup de manipulation de chaînes, il existe une excellente classe Spring avec toutes sortes de méthodes utiles:

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

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.

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.

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

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.

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

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

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.

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);
}

Je préfère utiliser:

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

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

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

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.

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
}

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".

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

L'exception peut également aider:

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

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.

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