deux objets inégaux avec le même hashcode

Hashcode() et equals() concept est

1) Si deux Objets sont égaux selon l'égalité(), puis en appelant la méthode hashcode sur chacun de ces deux objets doivent produire le même hashcode.

et un autre

2) Il n'est pas nécessaire que si deux objets sont inégales selon les égaux(), puis en appelant la méthode hashcode sur chacun des deux objets doivent produire des valeurs distinctes.

J'ai essayé et compris du premier, et c'est le code pour le premier point.

public class Test {
    public static void main(String[] args) {

        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        map.put(1, 11);
        map.put(4, 11);
        System.out.println(map.hashCode());
        Map<Integer, Integer> map1 = new HashMap<Integer, Integer>();
        map1.put(1, 11);
        map1.put(4, 11);
        System.out.println(map1.hashCode());
        if (map.equals(map1)) {
            System.out.println("equal ");
        }
    }
}

le programme ci-dessus donne le même hashcode pour deux objets différents.

Quelqu'un peut-il m'expliquer avec un exemple,comment deux objets différents qui sont inégales selon les equals() ont le même hashcode.

source d'informationauteur Saha

20

2) Il est pas nécessaire que si deux objets sont inégale selon l'égalité(), puis en appelant la méthode hashcode sur chacun des deux objets doivent produire des valeurs distinctes.

Selon la fonction de hachage, 2 objets différents peuvent avoir le même code de hachage. Cependant, les 2 objets qui sont à même de produire le même résultat lors de l'hachés (à moins que quelqu'un a mis en œuvre une fonction de hachage avec des nombres aléatoires dans ce cas, c'est inutile)

Par exemple, si je suis de hachage entiers et ma fonction de hachage est tout simplement (n % 10) puis le nombre 17 et le nombre 27 produira le même résultat. Cela ne signifie pas que ces chiffres sont les mêmes.

Exemple avec des Chaînes de caractères (toutes les chaînes ci-dessous ont un hashcode de 0):

public static void main(String[] args) {
    List<String> list = Arrays.asList("pollinating sandboxes",
                                      "amusement & hemophilias",
                                      "schoolworks = perversive",
                                      "electrolysissweeteners.net",
                                      "constitutionalunstableness.net",
                                      "grinnerslaphappier.org",
                                      "BLEACHINGFEMININELY.NET",
                                      "WWW.BUMRACEGOERS.ORG",
                                      "WWW.RACCOONPRUDENTIALS.NET",
                                      "Microcomputers: the unredeemed lollipop...",
                                      "Incentively, my dear, I don't tessellate a derangement.",
                                      "A person who never yodelled an apology, never preened vocalizing transsexuals.");
    for (String s : list) {
        System.out.println(s.hashCode());
    }
}

(vol à partir de ce post).

6

hashCode() a 32-bit valeurs possibles. Vos objets peuvent avoir beaucoup plus que cela, alors vous allez avoir quelques objets avec le même hashCode, c'est à dire vous ne pouvez pas vous assurer qu'elle sera unique.

C'est fait de pire dans une table de hachage collection d'une taille limitée. La capacité maximale de la table de hachage est de 1 << 30 ou près d'un milliard de dollars. Cela signifie que seulement 30 bits sont vraiment utilisés et si votre collection ne pas utiliser de 16 GO et est seulement dire un millier de seaux (ou 1 << 10 techniquement), alors vous avez vraiment seulement 1000 possible seaux.

Remarque: sur le HotSpot de la JVM, la valeur par défaut de l'Objet.hashCode() n'est jamais négatif, c'est à dire uniquement sur 31 bits, bien que je ne suis pas sûr de savoir pourquoi.

Si vous souhaitez générer un grand nombre d'objets avec le même hashCode regarder de Long.
```
//from Long
public int hashCode() {
    return (int)(value ^ (value >>> 32));
}

for(long i = Integer.MIN_VALUE; i < Integer.MAX_VALUE;i++) {
    Long l = (i << 32) + i;
    System.out.print(l.hashCode()+" ");
    if (i % 100 == 0)
        System.out.println();
}
```
Cela va générer 4 milliards de Long le tout avec un hashCode de 0.
1

Le but de hashCode est de permettre à la suite de l'axiom et le corollaire:
- Si l'on arrive à connaître les codes de hachage de deux objets, et ceux des codes de hachage ne correspondent pas, on n'a pas besoin de s'embêter examinant les objets de toute nouvelle de savoir que les objets ne correspond pas. Même si deux arbitrairement choisi la non-correspondance des objets ont 10% de chances d'avoir de correspondance des codes de hachage, le test des codes de hachage serait de laisser l'un d'éliminer 90% des comparaisons un serait autrement nécessaire. Pas aussi grand une victoire que l'élimination de 99,99%, mais certainement intéressant néanmoins.
- Connaissances qu'aucun des objets dans un groupe particulier, le code de hachage implique qu'aucun des objets de ce bouquet va correspondre à un objet avec ce code de hachage. Si l'on partitionné une collection d'objets dans ceux dont le code de hachage est un nombre pair et ceux dont le hachage était bizarre, et on voulait savoir si on avait un article dont le code de hachage qui est arrivé à être de même, il n'y aurait pas besoin d'examiner quoi que ce soit dans la collecte de l'impair de hachage éléments. De même il n'y aurait pas besoin de regarder d'un drôle de hachage de l'élément dans le même hachage collection. Même un deux-valeur de hachage pourrait ainsi accélérer les recherches de près de moitié. Si l'on divise une collection en partitions plus petites, on peut accélérer les choses encore plus loin.
Noter que hashCode() offrira le plus d'avantages si chaque élément renvoie un hachage différent, mais il peut offrir un avantage substantiel, même lorsque de nombreux éléments ont la même valeur de hachage. La différence entre 90% d'économies et à 99,99% de l'épargne est souvent beaucoup plus grande que les chiffres ne le laissent supposer, et donc si l'on peut raisonnablement facilement améliorer les choses à 99% 99.9%, ou mieux il convient de le faire, mais il a de la différence entre le fait d'avoir zéro faux matchs et avoir un peu de faux correspond à une collection est assez légère.
1

J'ai pas assez simple à comprendre si vous savez comment faire une table de hachage est mis en place et c'est le but. Une table de hachage prend un grand ensemble de valeurs, et les divise en beaucoup plus petits sets(seaux) pour beaucoup une récupération plus rapide des éléments. Fondamentalement, vous avez seulement besoin de chercher un seau au lieu de la liste complète pour votre élément. Les seaux sont dans un tableau dont l'indice est le code de hachage. Chaque seau contient une liste chaînée d'éléments avec le même hashcode, mais ne sont pas égaux(). Je pense que dans Java 8, ils sont passés à l'aide d'un treemap quand le seau tailles devient grand.
0

C'est assez simple en fait,

Nous devons d'abord savoir ce qu'est un code de hachage est.

En java, un code de hachage est simple un entier signé de 32 bits qui est en quelque sorte dérivée de données en question. Les types d'entiers sont généralement juste (Int) Mod (raisonnables grand nombre premier).

Nous allons faire un simple hash sur des entiers.

Définir:
```
public int hash(int num){ return num % 19 ; } 
```
Dans ce cas, les 19 et 38 sera le retour de la valeur de hachage de 0.

Pour les types de chaînes, le hash est dérivée à partir de chaque personnage et chaque position dans la chaîne, divisé par un assez grand nombre. (Ou, dans le cas de Java, en ignorant le dépassement de capacité dans un 32 bits, somme).

Donné qu'il y a arbitrairement beaucoup de chaînes de caractères possibles, et il y a un nombre limité de hashcodes (2^32) pour une chaîne de caractères, le pigeon-hole principe stipule qu'il y a au moins deux chaînes que les résultats dans le même hashcode.
0

Actullay, ce lien d'expliquer ce qui se passe si hashcode est de plus clairement.

http://www.javamadesoeasy.com/2015/02/hashmap-custom-implementation.html
-1

Ma compréhension est que le hashCode est une représentation numérique de l'adresse de la mémoire, mais n'est pas l'adresse réelle. Il peut être modifié, sans affecter l'adresse réelle. Ainsi, il devrait être possible de mettre tous les objets de la même hashCode, même si elles sont toutes choses entièrement différentes. Penser que tout le monde sur un bloc tout d'un coup avoir la même adresse. Ils sont vraiment différents des gens, mais maintenant, tous partagent la même adresse. Leur maison n'a pas bougé, un malin adolescent juste marqué tout le monde que "100 N. Principal".

Je suis assez nouveau à Java, afin de prendre ma réponse avec un peu de prudence.

Vous devez vous connecter pour publier un commentaire.