Java Strings: compareTo () vs. equals ()
https://stackoverflow.com/questions/1551235
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Lors du test pour l'égalité des String de Java J'ai toujours utilisé equals() parce que pour moi cela semble être la méthode la plus naturelle pour elle. Après tout, son nom l'indique déjà ce qu'il est censé faire. Cependant, un de mes collègues m'a dit récemment avait appris à utiliser compareTo() == 0 au lieu de equals(). Cela se sent naturel (comme compareTo() est destiné à fournir une commande et non comparer pour l'égalité) et même un peu dangereux (parce compareTo() == 0 ne signifie pas nécessairement l'égalité dans tous les cas, même si je sais qu'il fait pour son String) pour moi.
Il ne savait pas pourquoi il a appris à utiliser compareTo() au lieu de equals() pour des années String, et je ne pouvais pas non plus trouver aucune raison. Est-ce vraiment une question de goût personnel, ou est-il une vraie raison ou l'autre méthode?
La solution
Une différence est que "foo".equals((String)null) retourne false alors "foo".compareTo((String)null) == 0 jette un NullPointerException. Donc, ils ne sont pas toujours interchangeables, même pour les chaînes.
Autres conseils
Les 2 principales différences sont les suivantes:
-
equalsprendra tout objet comme paramètre, maiscompareTone prendra que des chaînes. -
equalsvous indique que si elles sont égales ou non, maiscompareTodonne des informations sur la façon dont les chaînes se comparent lexicographique.
J'ai regardé le code de classe String , et l'algorithme dans les compareTo et égaux semble fondamentalement les mêmes. Je crois que son opinion était juste une question de goût, et je suis d'accord avec vous - si tout ce que vous devez savoir est l'égalité des cordes et non que l'on vient d'abord lexicographique, alors j'utiliser equals
Lorsque l'on compare l'égalité, vous devez utiliser equals(), parce qu'il exprime votre intention de façon claire.
compareTo() a l'inconvénient supplémentaire que cela ne fonctionne que sur des objets qui mettent en œuvre l'interface Comparable.
Ceci est valable en général, non seulement pour les chaînes.
compareTo a do faire plus de travail si les chaînes ont des longueurs différentes. equals peut juste retourner faux, alors que compareTo doit toujours examiner suffisamment de caractères pour trouver l'ordre de tri.
compareTo() applique non seulement aux chaînes mais aussi tout autre objet, car compareTo<T> prend un T argument générique. La chaîne est l'une des classes qui a mis en œuvre la méthode de compareTo() en mettant en œuvre l'interface Comparable. (compareTo () est une méthode fo l'interface comparable). Ainsi, toute classe est libre de mettre en œuvre l'interface Comparable.
Mais compareTo() donne l'ordre des objets , utilisé généralement dans les objets de tri par ordre croissant ou décroissant tandis que equals() ne parlerons que de l'égalité et dire si elles sont égales ou pas.
dans la chaîne Contexte:
compareTo: Compare deux chaînes lexicographique
.
est égal à: cette chaîne Compare l'objet spécifié
compareTo compare deux chaînes par leurs caractères (au même index) et renvoie un entier (positif ou négatif) en conséquence.
String s1 = "ab";
String s2 = "ab";
String s3 = "qb";
s1.compareTo(s2); // is 0
s1.compareTo(s3); // is -16
s3.compareTo(s1); // is 16
equals () peut être plus efficace puis compareTo () .
Une différence très importante entre compareTo et est égal à:
"myString".compareTo(null); //Throws java.lang.NullPointerException
"myString".equals(null); //Returns false
equals () vérifie si deux objets sont identiques ou non et retourne une valeur booléenne.
compareTo () (de l'interface Comparable) renvoie un nombre entier. Il vérifie lequel des deux objets est « inférieur à », « égal à » ou « supérieur à » l'autre. Tous les objets peuvent être commandés logiquement, donc une méthode compareTo () ne fait pas toujours sens.
Notez que equals () ne définit pas la commande entre les objets qui compareTo () fait.
Maintenant, je vous conseille de consulter le code source des deux méthodes pour conclure que Égale est préférable à compareTo qui implique des calculs mathématiques.
Il semble que les deux méthodes à peu près font la même chose, mais la méthode compareTo () prend dans une méthode String, pas un objet, et ajoute quelques fonctionnalités supplémentaires au-dessus des normales égaux (). Si tout ce que vous aimez est l'égalité, la méthode equals () est le meilleur choix, tout simplement parce qu'il est plus logique à l'autre programmeur qui prend un coup d'oeil à votre code. La différence de temps entre les deux fonctions différentes ne devrait pas d'importance à moins que vous bouclez une énorme quantité d'articles. Le compareTo () est vraiment utile lorsque vous avez besoin de connaître l'ordre des chaînes dans une collection ou lorsque vous avez besoin de connaître la différence de longueur entre les chaînes qui commencent par la même séquence de caractères.
source: http: //java.sun. com / JavaSE / 6 / docs / api / java / lang / String.html
equals() devrait être la méthode de choix dans le cas de l'OP.
Regarder la mise en œuvre de equals() et compareTo() dans java.lang.String sur grepcode, on peut voir facilement que égale est mieux si nous sommes juste préoccupés par l'égalité des deux chaînes:
equals():
1012 public boolean equals(Object anObject) {
1013 if (this == anObject) {
1014 return true;
1015 }
1016 if (anObject instanceof String) {
1017 String anotherString = (String)anObject;
1018 int n = count;
1019 if (n == anotherString.count) {
1020 char v1[] = value;
1021 char v2[] = anotherString.value;
1022 int i = offset;
1023 int j = anotherString.offset;
1024 while (n-- != 0) {
1025 if (v1[i++] != v2[j++])
1026 return false;
1027 }
1028 return true;
1029 }
1030 }
1031 return false;
1032 }
et compareTo():
1174 public int compareTo(String anotherString) {
1175 int len1 = count;
1176 int len2 = anotherString.count;
1177 int n = Math.min(len1, len2);
1178 char v1[] = value;
1179 char v2[] = anotherString.value;
1180 int i = offset;
1181 int j = anotherString.offset;
1183 if (i == j) {
1184 int k = i;
1185 int lim = n + i;
1186 while (k < lim) {
1187 char c1 = v1[k];
1188 char c2 = v2[k];
1189 if (c1 != c2) {
1190 return c1 - c2;
1191 }
1192 k++;
1193 }
1194 } else {
1195 while (n-- != 0) {
1196 char c1 = v1[i++];
1197 char c2 = v2[j++];
1198 if (c1 != c2) {
1199 return c1 - c2;
1200 }
1201 }
1202 }
1203 return len1 - len2;
1204 }
Lorsque l'une des chaînes est un préfixe d'un autre, la performance de compareTo() est pire car il doit encore déterminer l'ordre lexicographique tout equals() ne vous inquiétez plus et return false immédiatement.
À mon avis, nous devrions utiliser ces deux comme ils étaient destinés:
-
equals()pour vérifier l'égalité, et -
compareTo()pour trouver l'ordre lexical.
Il y a certaines choses que vous devez garder à l'esprit tout en remplaçant compareTo en Java par exemple CompareTo doit être compatible avec égaux et la soustraction ne doit pas être utilisé pour comparer les champs entiers car ils peuvent déborder. consultez Les choses à ne pas oublier tout en remplaçant en Java Comparator pour plus de détails.
Equals peuvent être plus efficaces que compareTo.
Si la longueur des séquences de caractères dans la chaîne ne correspond pas il n'y a aucune façon dont les chaînes sont égales si le rejet peut être beaucoup plus rapide.
En outre, si elle est même objet (égalité d'identité plutôt que l'égalité logique), il sera également plus efficace.
S'ils ont également mis en œuvre la mise en cache de hashCode il pourrait être encore plus rapide à rejeter non égaux dans le cas ne correspond pas à celle de leur hashCode.
String.equals() nécessite de faire appel opérateur instanceof en compareTo() exige pas. Mon collègue a noté forte baisse vers le bas de la performance causée par un nombre excessif d'appels instanceof dans la méthode de equals(), mais mon test a prouvé compareTo() être légèrement plus rapide.
J'utilisais, cependant, Java 1.6. Sur les autres versions (ou d'autres fournisseurs de JDK) la différence pourrait être plus grande.
Le test compare chacun à chaque chaîne dans 1000 groupements d'éléments, répété 10 fois.
contrôles égaux () si deux chaînes sont égales ou not.It donne valeur booléenne. chèques compareTo () si l'objet de chaîne est égal, supérieur ou inférieur à l'autre chaîne object.It donne comme résultat: 1 si l'objet de chaîne est supérieure 0 si les deux sont égaux -1 si la chaîne est plus petite que l'autre chaîne
eq:
String a = "Amit";
String b = "Sumit";
String c = new String("Amit");
System.out.println(a.equals(c));//true
System.out.println(a.compareTo(c)); //0
System.out.println(a.compareTo(b)); //1
-
equalspeut prendre tout objet en tant que paramètre, maiscompareTone peut prendre String. -
null Cometo,
compareTolancera une exception -
quand vous voulez savoir où la diff arrive, vous pouvez utiliser
compareTo.
Ceci est une expérience nécromancie: -)
La plupart des réponses comparer les différences de performance et de l'API. Ils manquent le point fondamental que les deux opérations ont simplement une sémantique différente.
Votre intuition est correcte. x.equals (y) ne sont pas interchangeables avec x.compareTo (y) == 0. La première identité compare, tandis que l'autre compare la notion de « taille ». Il est vrai que dans de nombreux cas, en particulier avec les types primitifs, ces deux co-align.
Le cas général est le suivant:
Si x et y sont identiques, ils partagent le même 'taille': si x.equals (y) est vrai => x.compareTo (y) est 0.
Cependant, si x et y partagent la même taille, cela ne signifie pas qu'ils sont identiques.
si x.compareTo (y) est 0 ne signifie pas nécessairement x.equals (y) est vrai.
Un exemple convaincant où l'identité est différente de la taille serait des nombres complexes. On suppose que la comparaison est faite par leur valeur absolue. Donc, étant donné deux nombres complexes: Z1 = a1 + b1 * i et Z2 = a2 + b2 * i:
Z1.equals (z2) renvoie vrai si et seulement si a1 = a2 et b1 = b2.
Cependant Z1.compareTo (Z2) renvoie 0 et nombre infini de (a1, b1) et (A2, B2) des paires dans la mesure où ils satisfont à la condition a1 + b1 ^ 2 ^ 2 ^ 2 == a2 + b2 2 ^.
-
equals: nécessaire pour vérifier l'égalité et en limitant les doublons. De nombreuses classes de Java Library utilisent ce dans le cas où ils ont voulu trouver des doublons. par exemple.HashSet.add(ob1)ajoutera seulement si cela n'existe pas. Donc, si vous étendez certaines classes comme celui-ci alors passer outreequals(). -
compareTo: nécessaire pour la commande de l'élément. Encore une fois pour le tri stable vous avez besoin d'égalité, donc il y a un retour 0.
Égale -
1- substituez la méthode GetHashCode pour permettre un type de fonctionner correctement dans une table de hachage.
2- Ne pas jeter une exception dans la mise en œuvre d'une méthode Equals. Au lieu de cela, return false pour un argument nul.
3 -
x.Equals(x) returns true.
x.Equals(y) returns the same value as y.Equals(x).
(x.Equals(y) && y.Equals(z)) returns true if and only if x.Equals(z) returns true.
invocations successives de x.Equals (y) renvoient la même valeur tant que l'objet référencé par x et y ne sont pas modifiés.
x.Equals(null) returns false.
4- Pour certains types d'objets, il est souhaitable d'avoir Égal test pour l'égalité de valeur au lieu de l'égalité référentielle. Ces implémentations de Equals return true si les deux objets ont la même valeur, même si elles ne sont pas la même instance.
Par exemple -
Object obj1 = new Object();
Object obj2 = new Object();
Console.WriteLine(obj1.Equals(obj2));
obj1 = obj2;
Console.WriteLine(obj1.Equals(obj2));
Sortie: -
False
True
alors que compareTo -
compare l'instance en cours avec un autre objet du même type et retourne un entier qui indique si l'occurrence précède, suit, ou se produit dans la même position dans l'ordre de tri que l'autre objet.
Il retourne -
Moins de zéro - Cette instance obj précède dans l'ordre de tri. Zero - Cette instance se produit dans la même position dans l'ordre de tri comme obj. Supérieur à zéro - Cette instance obj suit dans l'ordre de tri
.Il peut jeter ArgumentException si l'objet n'est pas le même type que par exemple.
Par exemple, vous pouvez visiter ici.
Je suggère donc préférable d'utiliser Egal à la place de compareTo.
« égal à » comparer des objets et retourner true ou false et « Comparer à » retour 0 si est vrai ou un numéro [> 0] ou [<0] si est faux voici un exemple:
<!-- language: lang-java -->
//Objects Integer
Integer num1 = 1;
Integer num2 = 1;
//equal
System.out.println(num1.equals(num2));
System.out.println(num1.compareTo(num2));
//New Value
num2 = 3;//set value
//diferent
System.out.println(num1.equals(num2));
System.out.println(num1.compareTo(num2));
Résultats:
num1.equals(num2) =true
num1.compareTo(num2) =0
num1.equals(num2) =false
num1.compareTo(num2) =-1
Documentation Comparer à: https: // docs. oracle.com/javase/7/docs/api/java/lang/Comparable.html
Je crois que égaux et equalingnorecase de String renvoient vrai et faux qui est utile si vous voulez comparer les valeurs de l'objet chaîne, mais en cas de mise en œuvre compareTo et compareToIgnoreCase renvoie une valeur positive, négative et nulle qui sera utile en cas de tri.
