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 doSomething malgré le fait que ma chaîne IS EMPTY. Cela équivaut à null. Alors, qu'est-ce qui ne va pas avec ça?
ADDED:
J'ai trouvé la raison du problème. La variable a été déclarée en tant que chaîne et, par conséquent, null attribuée à cette variable a été transformée en "null"! Donc, if (!myString.equals("null")) fonctionne.
if (myString != null && !myString.isEmpty()) {
// doSomething
}
En tant que commentaire supplémentaire, vous devez connaître ce terme dans le contrat equals:
Pour toute valeur de référence non nulle
x,x.equals(null)devraitreturn false.
La façon de comparer avec null consiste à utiliser x == null et x != null.
De plus, x.field et x.method() jettent NullPointerException si x == null.
Si myString est null, l'appel de myString.equals(null) ou myString.equals("") échouera avec un NullPointerException. Vous ne pouvez appeler aucune méthode d'instance sur une variable null.
Vérifiez la valeur null en premier comme ceci:
if (myString != null && !myString.equals("")) {
//do something
}
Ceci utilise évaluation de court-circuit pour ne pas tenter le .equals si myString échoue à la vérification de null.
Apache commons StringUtils.isNotEmpty est la meilleure voie à suivre.
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 à la place 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 vous comparez avec des littéraux de chaîne comme vous le feriez, vous inverseriez l’instruction de façon à ne pas avoir de contrôle nul, c.-à-d.
if (("some string to check").equals(myString)){
doSomething();
}
au lieu de :
if (myString !=null && !myString.equals("some string to check")){
doSomething();
}
TRAVAILLE !!!!
if (myString != null && !myString.isEmpty()) {
return true;
}
else {
return false;
}
Vous devez vérifier que l'objet myString est null:
if (myString != null) {
doSomething
}
Si votre chaîne est null, les appels comme celui-ci doivent générer une exception 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 les choses suivantes:
if (!StringUtils.isNullOrEmpty(myString))
{
doSomething();
}
Essayer,
myString!=null && myString.length()>0
Chaque fois que je dois faire face à des chaînes (presque à chaque fois), je m'arrête et je me demande quel chemin est vraiment le moyen le plus rapide de vérifier si une chaîne est vide. Bien entendu, 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 l'extraction de la valeur de la propriété. Mais ensuite je me demande pourquoi il y a un String.Empty? Il devrait être plus rapide de vérifier String.Empty que de length, me dis-je. Eh bien, j'ai finalement décidé de le tester. J'ai codé une petite application de console Windows qui me dit combien de temps il faut pour effectuer un certain contrôle 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.length == 0. Voici les résultats:
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 moyenne de str == null est la plus rapide, mais ne donne pas toujours ce que nous recherchons. if str = String.Empty ou str = "", le résultat est faux. Ensuite, vous avez 2 qui sont liés à la deuxième place: String.IsNullOrEmpty() et str == null || str.length == 0. Puisque String.IsNullOrEmpty() a l'air plus joli et qu'il est plus facile (et plus rapide) d'écrire, je recommanderais de l'utiliser par rapport à l'autre solution.
if (myString != null && myString.length() > 0) {
// your magic here
}
Incidemment, si vous manipulez beaucoup 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
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 && opérateurs court-circuit. Cela signifie que dès qu'ils peuvent déterminer leur valeur, ils s'arrêtent. Ainsi, si (string == null) est true, la partie longueur n'a pas besoin d'être évaluée, car l'expression serait toujours true. 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.
En outre, l’utilisation de la longueur est généralement une meilleure idée que l’utilisation de .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).
J'utilise StringUtil.isBlank(string)
Il vérifie si une chaîne est vide: null, vide ou uniquement des espaces.
Donc, celui-ci est le meilleur jusqu'à présent
Voici la méthode originale 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;
}
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 est équivalent à equals ("").
- Vérifier si myString est nul en premier évitera une exception NullPointerException.
Cela devrait fonctionner:
if (myString != null && !myString.equals(""))
doSomething
}
Sinon, myString a probablement une valeur à laquelle vous ne vous attendez pas. Essayez de l’imprimer comme ceci:
System.out.println("+" + myString + "+");
L'utilisation des symboles '+' pour entourer la chaîne vous indiquera s'il y a des espaces supplémentaires que vous ne comptez pas.
if(str.isEmpty() || str==null){ do whatever you want }
Pour moi, le meilleur moyen de vérifier si une chaîne a un contenu significatif dans Java est celui-ci:
string != null && !string.trim().isEmpty()
Tout d'abord, vous vérifiez si la chaîne est null pour éviter NullPointerException, puis vous coupez tous les caractères d'espacement pour éviter de vérifier les chaînes ne comportant que des espaces, puis vous vérifiez si la chaîne coupée n'est pas vide, c'est-à-dire qu'elle a une longueur de 0 .
Ok, voici comment fonctionnent les types de données en Java. (Vous devez excuser mon anglais, je ne pense pas utiliser le bon vocabulaire. Vous devez distinguer 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, caractères, booléens, etc. Les types de données normaux ou complexes sont tout le reste. Une chaîne de caractères est un tableau de caractères, donc un type de données complexe.
Chaque variable que vous créez est en réalité un pointeur sur la valeur en 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 pointeur. Ce pointeur pointe sur la variable dans votre mémoire. Lorsque vous appelez System.out.println(anyObject), la méthode toString() de cet objet est appelée. S'il n'a pas remplacé toString à partir de Object, le pointeur sera imprimé. 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 DIRECTEMENT enregistrés dans leur pointeur. Donc, en réalité, il n'y a pas de pointeur et les valeurs sont stockées directement.
Par exemple:
int i = 123;
je ne stocke pas un 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
Cette chaîne a un pointeur différent. String.equals (String other) compare toutefois le contenu. Vous pouvez comparer des types de données primitifs avec l'opérateur '==' car le pointeur de deux objets différents ayant le même contenu est égal.
Null voudrait dire que le pointeur est vide. Un type de données primitif vide est par défaut 0 (pour les nombres). Null pour tout objet complexe signifie cependant que cet objet n'existe pas.
Salutations
Dans Android, vous pouvez vérifier cela avec la méthode utilitaire isEmpty à partir de TextUtils.
public static boolean isEmpty(CharSequence str) {
return str == null || str.length() == 0;
}
La méthode isEmpty(CharSequence str) vérifie les deux conditions, pour null et la longueur.
J'ai eu ce problème dans Android et je l'utilise de cette façon (travail pour moi):
String test = null;
if(test == "null"){
// Do work
}
Mais dans Java code, 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
}
Si vous travaillez dans Android, vous pouvez utiliser la simple classe TextUtils. Vérifiez le code suivant:
if(!TextUtils.isEmpty(myString)){
//do something
}
Ceci est une utilisation simple du code. La réponse peut être répétée. Mais il est simple d'avoir un contrôle simple et simple pour vous.
J'ai essayé la plupart des exemples donnés ci-dessus pour un null dans un Android application que je construisais et IT ALL FAILED. J'ai donc proposé 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-le contre "null" et cela fonctionne correctement. En fait aucune exception n'est levée
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
}
Une exception peut aussi aider:
try {
//define your myString
}
catch (Exception e) {
//in that case, you may affect "" to myString
myString="";
}
Vous pouvez vérifier une chaîne égale à null en utilisant ceci:
String Test = null;
(Test+"").compareTo("null")
Si le résultat est 0 alors (Test + "") = "null".