Ceci est un post traduit par IA.
equals() vs hashCode()
- Langue de rédaction : Coréen
- •
-
Pays de référence : Tous les pays
- •
- Technologies de l'information
0000-00-00 00:00:00
Choisir la langue
Texte résumé par l'IA durumis
- equals() est une méthode qui compare si le contenu des objets est identique, hashCode() est une méthode qui renvoie une valeur entière unique de l'objet, et les deux sont utilisés pour comparer les objets.
- Dans les structures de données de hachage, hashCode() est utilisé pour déterminer la clé, il est donc nécessaire de redéfinir equals() et hashCode() ensemble pour garantir le même code de hachage.
- L'utilisation conjointe de equals() et hashCode() permet de gérer efficacement les objets identiques dans les structures de données de hachage.
equals()
equals() compare le contenu d'un objet pour voir s'il est identique. C'est souvent appelé une comparaison d'égalité. Si equals() n'est pas redéfini, il sera implicitement égal à ==, ce qui est une comparaison d'identité. Par conséquent, si vous souhaitez comparer correctement les objets en termes d'égalité, vous devez toujours utiliser equals().
public boolean equals(Object obj) {
return (this == obj); hashCode()
hashCode() vérifie si deux objets sont le même objet. Il fonctionne comme une comparaison d'identité comme ==, mais la méthode hashCode() renvoie une valeur entière unique pour l'objet au moment de l'exécution. Il renvoie généralement l'adresse mémoire de l'objet stocké dans le tas.
Cette méthode a le mot-clé native attaché, ce qui signifie qu'elle est utilisée lorsque vous utilisez un langage développé en dehors de Java en Java.
Qu'est-ce que le hachage ?
Le hachage est le processus de génération d'une sortie de taille fixe à partir d'une entrée de taille variable à l'aide d'une fonction de hachage. La valeur obtenue par hachage est appelée code de hachage.
equals() et hashCode()
Puisque les objets identiques doivent avoir la même adresse mémoire, il est évident que les objets identiques doivent avoir le même code de hachage. Par conséquent, il est préférable d'écrire du code de manière à garantir le même code de hachage en redéfinissant également hashCode() en plus de equals().
Structure de données de hachage
public class Main {
public static void main(String[] args) throws IOException {
Set people = new HashSet<>();
people.add(new Person("제이온", 23));
people.add(new Person("제이온", 23));
System.out.println(people.size()); // 2
}
}
class Person {
private final String name;
private final int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
} Insérons deux objets identiques dans la structure de données HashSet comme indiqué ci-dessus. Si vous imprimez la taille de cet ensemble, vous obtiendrez 2. Pourquoi ?
C'est parce que la structure de données utilisant le hachage utilise hashCode() pour déterminer la clé. Autrement dit, avant de comparer si les objets sont identiques, il compare si les codes de hachage des deux objets sont identiques, puis détermine si les deux objets sont égaux. Si hashCode() n'est pas redéfini, il utilisera hashCode() de l'objet, ce qui renverra l'adresse mémoire où chaque objet est stocké. Par conséquent, il est préférable de redéfinir hashCode() en plus de equals() pour les cas où vous utilisez une structure de données de hachage.
public static void main(String[] args) throws IOException {
Set people = new HashSet<>();
people.add(new Person("제이온", 23));
people.add(new Person("제이온", 23));
System.out.println(people.size()); // 1
}
}
class Person {
private final String name;
private final int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
} Source
Questions et réponses d'entretien anticipées
Pourquoi equals() et hashCode() sont-ils utilisés ensemble ?
C'est parce que la structure de données utilisant le hachage utilise hashCode() pour déterminer la clé. Autrement dit, avant de comparer si les objets sont identiques, il compare si les codes de hachage des deux objets sont identiques, puis détermine si les deux objets sont égaux. Si hashCode() n'est pas redéfini, il utilisera hashCode() de l'objet, ce qui renverra l'adresse mémoire où chaque objet est stocké. Par conséquent, il est préférable de redéfinir hashCode() en plus de equals() pour les cas où vous utilisez une structure de données de hachage.
