[Java] Est-il inutile de vérifier "l'identité" dans l'implémentation de la méthode equals ()?
introduction
Merci pour votre visite. Pour la méthode equals () de Java, j'ai comparé le temps d'exécution avec et sans l'implémentation suivante qui renvoie immédiatement true si elles sont identiques.
// equals()Contrôle d'identité au début de
if (this == obj){
return true;
}
Ikisatsu (désolé d'être long)
Je suis actuellement en formation de nouveau diplômé SE du SIer. C'est un peu ennuyeux parce que c'est basé sur l'hypothèse que vous êtes nouveau sur Java, mais c'est amusant. (Bien que j'aie un sentiment de crise que je dois étudier par moi-même même un peu dans l'intervalle de temps ...)
Maintenant, dans la formation, nous menons des exercices de développement. C'est comme une expérience de projet telle qu'une unité, un test d'intégration, la création d'un document de conception interne (spécification de composant) et un codage basé sur le document de conception externe créé.
Dans la conception interne, l'organigramme de la méthode est créé de manière à pouvoir être codé en fonction du nom de champ et du nom de méthode qui ont déjà été décidés. Quand j'ai commencé à travailler sur une certaine spécification DTO, il ** "Remplacer la méthode equals ()" ** Il y avait. Oh, ça continue ● Je viens de le faire dans un séminaire.
Remplacer la méthode equals ()
La méthode equals () est définie dans la classe Object comme suit.
//Extrait du code source Java 11
public boolean equals(Object obj) {
return (this == obj);
}
Cela renvoie simplement la similitude, vous devez donc l'implémenter correctement dans votre propre classe. Dans ce cas, l'équivalence est déterminée par les spécifications, donc par exemple, dans la classe self-made Person, même si le champ age est différent, si même le nom est le même, il est libre de juger de l'équivalence (si vous le souhaitez).
Et voici le sujet principal de cet article. La méthode equals () vérifie d'abord l'identité.
// equals()Contrôle d'identité au début de(Republier)
if (this == obj){
return true;
}
Autrement dit, dans le cas de ```a.equals (a) `` `, true est renvoyé immédiatement. Ce n'est pas obligatoire, mais la génération automatique d'Eclipse indique qu'il est habituel de l'implémenter car elle a un impact sur les performances. Sans cela, il faudrait déterminer si le champ de a est égal au champ de a.
Quel est ce processus?
Lorsque j'ai créé un organigramme de la méthode equals () et l'ai soumis à l'instructeur qui jouait le rôle de PM, j'ai reçu le commentaire suivant sur la partie pertinente du traitement du contrôle d'identité. ** "Quel est ce processus?" ** Lors de l'implémentation de equals (), je pensais que c'était un processus à inclure, donc je ne pensais pas qu'il serait intriqué. Même si je le mets, je connais le concept de contrôle d'identité en lui-même, et si je précise que "cette fois c'est une petite échelle, un traitement tellement strict n'est pas nécessaire", je ne peux m'empêcher de "je ne connais pas un tel traitement, même sur le terrain Cela n'a pas de sens car je ne l'ai pas vu et les résultats renvoyés sont les mêmes. " Bien sûr, jusqu'à récemment, je suis étudiant et je ne sais rien du site, alors peut-être qu'il n'y a pas de contrôle d'identité dans le monde ...? Je suis devenu méfiant, et j'ai pensé que ce serait juste un fou d'écrire une logique redondante, alors j'ai écrit cet article. Pour le moment, si je peux réaliser les avantages du temps d'exécution, je gagnerai (forcé).
environnement
Windows10 Eclipse
Méthode
Utilisez le Person.java suivant. À l'origine, la méthode equals () de la classe Object devait être remplacée, mais à des fins de comparaison, nous avons créé equalsWithSelfCheck () avec contrôle d'identité et méthode equalsWithoutSelfCheck () sans contrôle d'identité et les avons comparées. Les deux sont basés sur la méthode equals () générée automatiquement par Eclipse.
Person.java
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public boolean equalsWithoutSelfCheck(Object obj) {
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public boolean equalsWithSelfCheck(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
De plus, la différence de temps d'exécution est sortie avec les mêmes conditions dans le Main suivant. Il a été mesuré 10 fois à plusieurs reprises.
Main.java
public class Main {
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<>();
Person person = new Person("Taro", 20);
//Une liste qui contient tous la même personne
for(int i = 0; i < 10000000; i++) {
list.add(person);
}
for (int i = 0; i < 10; i++) {
long time1 = 0;
long time2 = 0;
for (Person p : list) {
long start = System.nanoTime();
person.equalsWithoutSelfCheck(p);
long end = System.nanoTime();
time1 = time1 + end - start;
}
for (Person p : list) {
long start = System.nanoTime();
person.equalsWithSelfCheck(p);
long end = System.nanoTime();
time2 = time2 + end - start;
}
System.out.println("Différence de temps d'exécution:" + (time1 - time2) * 0.000001 + "milliseconde");
}
}
}
résultat
Différence de temps d'exécution: 7.8233999999999995 millisecondes
Différence de temps d'exécution: 5.2443 millisecondes
Différence de temps d'exécution: 3.8985 millisecondes
Différence de temps d'exécution: 4.9727 millisecondes
Différence de temps d'exécution: 5.5971 millisecondes
Différence de temps d'exécution: 2.7468 millisecondes
Différence de temps d'exécution: 10.9687 millisecondes
Différence de temps d'exécution: 5.1853 millisecondes
Différence de temps d'exécution: 5.4607 millisecondes
Différence de temps d'exécution: 3.6744 millisecondes
Dans les deux cas, la méthode incluant le contrôle d'identité a donné des résultats plus rapides. Il existe quelques variantes. Comme l'ordre d'exécution peut en être la cause, j'ai essayé de changer l'ordre, mais la différence de temps d'exécution est devenue négative et la même conclusion a été tirée.
Au fait
J'ai également essayé les cas où le contenu de la liste est le même mais pas le même que celui indiqué ci-dessous.
//Tous les éléments ont la même valeur(Pas le même)liste
for(int i = 0; i < 10000000; i++) {
list.add(new Person("Taro", 20));
}
En conséquence, il n'y avait pas de différence de temps d'exécution moyenne comme indiqué ci-dessous.
Différence de temps d'exécution: 3.5603 millisecondes
Différence de temps d'exécution:-0.223 millisecondes
Différence de temps d'exécution: 1.0935 millisecondes
Différence de temps d'exécution: 0.5618 millisecondes
Différence de temps d'exécution:-0.006999999999999999 millisecondes
Différence de temps d'exécution:-1.4681 millisecondes
Différence de temps d'exécution:-0.8628 millisecondes
Différence de temps d'exécution: 1.5103 millisecondes
Différence de temps d'exécution:-1.9932999999999998 millisecondes
Différence de temps d'exécution: 0.3394 millisecondes
De là, il a été confirmé que le contrôle d'identité dans la méthode equals () contribue suffisamment à la performance.
Conclusion
Il a été confirmé que le contrôle d'identité dans la méthode equals () a suffisamment contribué à la performance, et il s'est avéré être une mise en œuvre utile. (Ma victoire (?))
à la fin
Jusqu'à la fin Merci d'avoir lu. Si vous avez des questions, faites-le nous savoir et donnez-nous vos conseils.