Je veux comparer deux chaînes pour l'égalité lorsque l'une ou les deux peuvent l'être null
.
Donc, je ne peux pas simplement appeler .equals()
car il peut contenir des null
valeurs.
Le code que j'ai essayé jusqu'à présent:
boolean compare(String str1, String str2) {
return ((str1 == str2) || (str1 != null && str1.equals(str2)));
}
Quelle sera la meilleure façon de vérifier toutes les valeurs possibles, y compris null
?
compare
, cela a une signification différente pour les chaînes. Vous devriez l'appelerequals
.Réponses:
Voici ce que le code interne Java utilise (sur d'autres
compare
méthodes):public static boolean compare(String str1, String str2) { return (str1 == null ? str2 == null : str1.equals(str2)); }
la source
<0
,==0
ou>0
indiquer lequel est plus bas / plus râpé que l'autreObjects.equals(Object, Object)
comme Mark Rotteveel l'a souligné dans sa réponse (veuillez voter pour)Depuis Java 7, vous pouvez utiliser la méthode statique
java.util.Objects.equals(Object, Object)
pour effectuer des vérifications égales sur deux objets sans vous soucier de leur existencenull
.Si les deux objets sont,
null
il retourneratrue
, si l'un estnull
et l'autre non, il reviendrafalse
. Sinon, il renverra le résultat de l'appelequals
du premier objet avec le second comme argument.la source
Object.equals(Object)
il n'y a pas de vérification de type à la compilation. CelaObjects.equals(Object, Object)
fonctionne à peu près de la même manière qu'uneequals
inférence / vérifications normale par IDE, ces règles sont des heuristiques qui sont également prises en charge pourObjects.equals(Object, Object)
(par exemple, IntelliJ IDEA 2016.2 a le même contrôle pour les égaux normaux et celui des objets).Dans ces cas, il serait préférable d'utiliser Apache Commons StringUtils # equals , il gère déjà les chaînes nulles. Exemple de code:
public boolean compare(String s1, String s2) { return StringUtils.equals(s1, s2); }
Si vous ne souhaitez pas ajouter la bibliothèque, copiez simplement le code source de la
StringUtils#equals
méthode et appliquez-le lorsque vous en avez besoin.la source
Pour ceux sur Android, qui ne peuvent pas utiliser Objects.equals (str1, str2) de l'API 19, il y a ceci:
C'est nul sûr. Il doit rarement utiliser la méthode string.equals () plus chère car les chaînes identiques sur Android se comparent presque toujours à l'opérande "==" grâce au regroupement de chaînes d' Android , et les vérifications de longueur sont un moyen rapide de filtrer la plupart des incompatibilités.
Code source:
/** * Returns true if a and b are equal, including if they are both null. * <p><i>Note: In platform versions 1.1 and earlier, this method only worked well if * both the arguments were instances of String.</i></p> * @param a first CharSequence to check * @param b second CharSequence to check * @return true if a and b are equal */ public static boolean equals(CharSequence a, CharSequence b) { if (a == b) return true; int length; if (a != null && b != null && (length = a.length()) == b.length()) { if (a instanceof String && b instanceof String) { return a.equals(b); } else { for (int i = 0; i < length; i++) { if (a.charAt(i) != b.charAt(i)) return false; } return true; } } return false; }
la source
Depuis la version 3.5 Apache Commons StringUtils a les méthodes suivantes:
static int compare(String str1, String str2) static int compare(String str1, String str2, boolean nullIsLess) static int compareIgnoreCase(String str1, String str2) static int compareIgnoreCase(String str1, String str2, boolean nullIsLess)
Ceux-ci fournissent une comparaison de chaîne sûre nulle.
la source
Utilisation de Java 8:
private static Comparator<String> nullSafeStringComparator = Comparator .nullsFirst(String::compareToIgnoreCase); private static Comparator<Metadata> metadataComparator = Comparator .comparing(Metadata::getName, nullSafeStringComparator) .thenComparing(Metadata::getValue, nullSafeStringComparator); public int compareTo(Metadata that) { return metadataComparator.compare(this, that); }
la source
Comparez deux chaînes en utilisant les méthodes equals (-, -) et equalsIgnoreCase (-, -) de la classe Apache Commons StringUtils.
StringUtils.equals (-, -) :
StringUtils.equals(null, null) = true StringUtils.equals(null, "abc") = false StringUtils.equals("abc", null) = false StringUtils.equals("abc", "abc") = true StringUtils.equals("abc", "ABC") = false
StringUtils.equalsIgnoreCase (-, -) :
StringUtils.equalsIgnoreCase(null, null) = true StringUtils.equalsIgnoreCase(null, "abc") = false StringUtils.equalsIgnoreCase("xyz", null) = false StringUtils.equalsIgnoreCase("xyz", "xyz") = true StringUtils.equalsIgnoreCase("xyz", "XYZ") = true
la source
Vous pouvez utiliser
java.util.Objects
comme suit.public static boolean compare(String str1, String str2) { return Objects.equals(str1, str2); }
la source
boolean compare(String str1, String str2) { if(str1==null || str2==null) { //return false; if you assume null not equal to null return str1==str2; } return str1.equals(str2); }
est-ce ce que vous vouliez?
la source
false
si les deux chaînes ne correspondentnull
peut-être pas au résultat souhaité.boolean compare(String str1, String str2) { if (str1 == null || str2 == null) return str1 == str2; return str1.equals(str2); }
la source
boolean compare(String str1, String str2) { return (str1==null || str2==null) ? str1 == str2 : str1.equals(str2); }
la source
OK, alors que signifie «meilleure solution possible»?
Si vous voulez dire la plus lisible, alors toutes les solutions possibles sont à peu près équivalentes pour un programmeur Java expérimenté. Mais l'OMI le plus lisible est celui-ci
public boolean compareStringsOrNulls(String str1, String str2) { // Implement it how you like }
En d'autres termes, cachez l'implémentation dans une méthode simple qui (idéalement) peut être intégrée.
(Vous pouvez également «out-source» vers une bibliothèque d'utilitaires tiers ... si vous l'utilisez déjà dans votre base de code.)
Si vous voulez dire le plus performant, alors:
null
arguments,la source