Cordes de Java: compareTo() vs est égale à()

Une différence, c'est que "foo".equals((String)null) retourne false, alors qu' "foo".compareTo((String)null) == 0 déclenche une exception NullPointerException. Donc ils ne sont pas toujours interchangeables, même pour les Chaînes.

Les 2 principales différences sont les suivantes:

1. equals vont prendre n'importe quel Objet en tant que paramètre, mais compareTo ne prendra que des Chaînes de caractères.
2. equals seulement vous dit qu'ils sont égaux ou non, mais compareTo donne des informations sur la façon dont les Chaînes de comparer de manière lexicographique.

J'ai pris un coup d'oeil à la classe String code, et l'algorithme dans compareTo et est égal semble fondamentalement la même. Je crois que son opinion était qu'une question de goût, et je suis d'accord avec vous, si tout ce que vous devez savoir, c'est l'égalité des Chaînes de caractères et non pas que l'on vient d'abord de manière lexicographique, alors je voudrais utiliser equals.

compareTo() ne s'applique pas seulement à Cordes, mais aussi de tout autre objet, car compareTo<T> prend un argument générique T. La chaîne est l'une des classes qui a mis en œuvre le compareTo() par la méthode de la mise en œuvre de la Comparable interface.(compareTo() est une méthode de fo à l'Interface comparable). de Sorte que toute la classe est libre d'implémenter l'interface Comparable.

Mais compareTo() donne l'ordre des objets, utilisé généralement dans le tri des objets dans l'ordre croissant ou décroissant, tandis que equals() ne parler de l'égalité et dire s'ils sont égaux ou non.

equals() peuvent être plus efficaces que la 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 les mêmes ou pas et retourne un booléen.

compareTo() (à partir de l'interface Comparable) renvoie un entier. Il vérifie lequel des deux objets est "moins que", "égal à" ou "supérieure" aux autres. Pas tous les objets peuvent être ordonnés de manière logique, donc un compareTo() la méthode n'est pas toujours logique.

Noter que equals() ne définit pas l'ordre entre les objets, qui compareTo() n'.

Maintenant, je vous conseille de consulter le code source des deux méthodes de conclure que est égal à est préférable par rapport à compareTo qui implique des calculs Mathématiques.

equals() devrait être la méthode de choix dans le cas de l'OP.

À la recherche à la mise en œuvre de equals() et compareTo() dans java.lang.Chaîne sur grepcode, nous pouvons facilement voir que des égaux est mieux de nous si nous sommes concernés par l'égalité de deux Chaînes:

equals():

Mille douze public boolean est égal à(Objet anObject) {
Mille treize si (ce == anObject) {
Mille quatorze retour true;
Mille quinze }
Mille seize si (anObject instanceof Chaîne) {
Mille dix sept Chaîne anotherString = (Chaîne)anObject;
Mille dix huit int n = nombre;
Mille dix neuf si (n == anotherString.count) {
Mille vingt char v1[] = valeur;
Mille vingt et un char v2[] = anotherString.valeur;
Mille vingt deux int i = offset;
Mille vingt trois int j = anotherString.offset;
Mille vingt quatre while (n-- != 0) {
Mille vingt cinq si (v1[i++] != v2[j++])
Mille vingt six retour false;
Mille vingt sept }
Mille vingt huit retour true;
Mille vingt neuf }
Mille trente }
Mille trente et un retour false;
Mille trente deux }

et compareTo():

Mille cents soixante quatorze public int compareTo(Chaîne anotherString) {
Mille cents soixante quinze int len1 = count;
Mille cents soixante seize int len2 = anotherString.comte;
Mille cents soixante dix sept int n = Math.min(len1, len2);
Mille cents soixante dix huit char v1[] = valeur;
Mille cents soixante dix neuf char v2[] = anotherString.valeur;
Mille cents quatre vingt int i = offset;
Mille cents quatre vingt un int j = anotherString.offset;
Mille cents quatre vingt trois si (i == j) {
Mille cents quatre vingt quatre int k = i;
Mille cents quatre vingt cinq int lim = n + i;
Mille cents quatre vingt six while (k < lim) {
Mille cents quatre vingt sept char c1 = v1[k];
Mille cents quatre vingt huit char c2 = v2[k];
Mille cents quatre vingt neuf si (c1 != c2) {
Mille cents quatre vingt dix retour c1 - c2;
Mille cents quatre vingt onze }
Mille cents quatre vingt douze k++;
Mille cents quatre vingt treize }
Mille cents quatre vingt quatorze } else {
Mille cents quatre vingt quinze while (n-- != 0) {
Mille cents quatre vingt seize char c1 = v1[i++];
Mille cents quatre vingt dix sept char c2 = v2[j++];
Mille cents quatre vingt dix huit si (c1 != c2) {
Mille cents quatre vingt dix neuf retour c1 - c2;
Mille deux cent }
Mille deux cent un }
Mille deux cent deux }
Mille deux cent trois retour len1 - len2;
Mille deux cent quatre }

Lorsque l'une des chaînes est un préfixe d'autre part, la performance de compareTo() est pire car il doit encore déterminer le vocabulaire de la commande alors que equals() ne vous inquiétez plus et retourne la valeur false immédiatement.

À mon avis, nous devrions utiliser ces deux comme ils étaient destinés:

• equals() pour vérifier l'égalité, et
• compareTo() de trouver le lexique de la commande.

Est égal peuvent être plus efficaces que la compareTo.

Si la longueur des séquences de caractères Chaîne de caractères ne correspondent pas, il n'y a aucun moyen de Chaînes sont égales, donc le rejet peut être beaucoup plus rapide.

Si par ailleurs c'est le même objet (l'identité de l'égalité, plutôt que de logique de l'égalité), il sera également plus efficace.

Si ils ont également mis en œuvre hashCode de la mise en cache, il pourrait être encore plus rapide pour rejeter non-égaux dans le cas où leur hashCode ne correspondent pas.

1. equals peut prendre n'importe quel Objet en tant que paramètre, mais compareTo ne peut que prendre de la Chaîne.

2. quand cometo null,compareTo va lancer une exception

3. lorsque vous voulez savoir d'où l'diff arriver,vous pouvez utiliser compareTo.

• equals:
  requis pour la vérification de l'égalité et de la restriction des doublons. De nombreuses classes de Java utilisation de la Bibliothèque dans ce cas, ils ont voulu trouver des doublons. par exemple, HashSet.add(ob1) ne fera qu'ajouter si ce n'existent pas. Donc, si vous êtes l'extension de certaines classes comme ceci ensuite remplacer equals().

• compareTo:
  requis pour la commande de l'élément. De nouveau pour la stabilité de tri vous avez besoin d'égalité, il y a donc un retour 0.

Est égal à -

1 - Remplacer la méthode GetHashCode pour permettre à un type à 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, retourner false pour un argument null.

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) retourner 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 de disposer d'Égal à tester l'égalité des valeurs à la place de référentiel de l'égalité. Mise en œuvre d'égal à Égal retourne true si les deux objets ont la même valeur, même si elles ne sont pas de 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)); 

De sortie :-

False
True

tout compareTo -

Compare la situation actuelle avec un autre objet du même type et retourne un entier qui indique si l'instance actuelle 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 précède obj dans l'ordre de tri. Zéro Cette instance se produit dans la même position dans l'ordre de tri en obj. Supérieure à zéro Cette instance suit obj dans l'ordre de tri.

Il peut jeter ArgumentException si l'objet n'est pas le même type d'instance.

Par exemple, vous pouvez visiter ici.

Je suggère donc de mieux utiliser Équivaut à la place de compareTo.

Ici, une chose est importante lors de l'utilisation compareTo() sur equals() que compareTo fonctionne pour les classes qui implémente 'Comparables' interface sinon il va jeter un NullPointerException. String classes implémente l'interface Comparable, tandis que StringBuffer n'est pas d'où vous pouvez utiliser "foo".compareTo("doo") dans String objet, mais pas dans StringBuffer Objet.