标签: hashcode

我正在阅读Java 1.6 API提供的HashMap类的代码,无法完全理解以下操作的需要(在put和get方法的主体中找到):

int hash = hash(key.hashCode());

方法hash()具有以下主体:

 private static int hash(int h) {
         h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

这通过对提供的哈希码执行位操作来有效地重新计算哈希值.即使API声明如下,我也无法理解这样做的必要性:

这很关键,因为HashMap使用两个幂的长度哈希表,否则会遇到低位不同的hashCodes的冲突.

我确实理解键值是存储在数据结构数组中的,并且该数组中项的索引位置由其哈希确定.我无法理解的是这个函数如何为哈希分布添加任何值.

我有一个类,内部只是一个整数数组.一旦构造,阵列永远不会改变.我想预先计算一个好的哈希码,以便这个类可以非常有效地用作词典中的键.数组的长度小于约30项,并且整数通常在-1000和1000之间.

从我正在阅读Head First Java的书中引用:

关键是,哈希码可以是相同的,而不必保证对象是相等的,因为hashCode()方法中使用的"哈希算法" 可能会为多个对象返回相同的值.

为什么该hashCode()方法可能为不同的对象返回相同的值？这不会导致问题吗？

我理解为什么为两个相等(通过equals)对象提供相同的哈希码很重要.但反过来也是如此,如果两个对象具有相同的哈希码,它们必须相等吗？合同是否仍然有效？我无法找到可能发生这种情况的示例,因为如果所有参与equals方法的属性也被用于覆盖hashcode方法,那么我们将始终使用相同的对象的哈希码.请评论.

如果我运行以下代码,则输出为2,这意味着该集合包含2个元素.但是我认为该集应该包含1,因为两个对象基于hashcode()值以及.equals()方法是相等的.在我的理解中似乎有些明显的错误？

package HELLO;

import java.util.HashSet;
import java.util.Set;

public class Test {

    public static void main(String[] args) throws Exception {
        Set<Alpha> s = new HashSet<Alpha>();
        Alpha a1 = new Alpha();
        Alpha a2 = new Alpha();
        s.add(a1);
        s.add(a2);
        System.out.println(s.size());
    }
}   

class Alpha {
    int a = 10;

    public int hashcode() {
        return a;
    }

    public boolean equals(Object obj) {
        return (obj instanceof Alpha && ((Alpha) obj).a == this.a);
    }

    public String toString() {
        return "Alpha : " …

我正在编写一个函数来查找Python列表中的多数.

认为如果我可以编写一个哈希函数,可以将每个元素映射到新数组中的单个插槽,或者映射到唯一标识符,也许是字典,那应该是最好的,它应该是可撤销的.我不确定如何进步.我的哈希函数显然是无用的,任何关于我能/应该做什么的提示,或者这是否是一个合理的方法？

def find_majority(k):
    def hash_it(q):
        return q

    map_of = [0]*len(k)

    for i in k:
        mapped_to = hash_it(i) #hash function
        map_of[mapped_to]+=1


find_majority([1,2,3,4,3,3,2,4,5,6,1,2,3,4,5,1,2,3,4,6,5])

请考虑以下代码:

import java.util.*;

class Employee {

    String name;

    public Employee(String nm) {
        this.name=nm;
    }
}

public class HashMapKeyNullValue {

    Employee e1;

    public void display(){

        Employee e2=null;
        Map map=new HashMap();

        map.put(e2, "25");
        System.out.println("Getting the Value When e2 is set as KEY");
        System.out.println("e2 : "+map.get(e2));
        System.out.println("e1 : "+map.get(e1));
        System.out.println("null : "+map.get(null));

        map.put(e1, "");
        System.out.println("Getting the Value when e1 is set as KEY");
        System.out.println("e2 : "+map.get(e2));
        System.out.println("e1 : "+map.get(e1));
        System.out.println("null : "+map.get(null));

        map.put(null, null);   // null as key and null as value
        System.out.println("Getting …

我的自定义类将由HashSet包含

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "hashcode='" + this.hashCode() + '\'' +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        if (!name.equals(person.name)) …

是否有一个函数可以调用以防止浏览器在更改哈希值时记录后面的历史记录条目？

我正在编写一个简单的JavaScript库,当用户浏览每个图像时,它会更改浏览器URL而无需重新加载页面.

这可以通过将location.hash设置为图像的唯一ID来完成.

window.location.hash = imageID;

问题是当用户点击浏览器后退按钮时,他们必须向后移动每个图像,就像页面加载一样.

如果他们使用图库旋转了20张图像,则必须再次单击21次才能返回上一页.

如何防止使用javascript记录回溯历史记录？

Hashcode()和equals()的概念是

1)如果两个对象根据equal()相等,则在这两个对象中的每一个上调用hashcode方法应该产生相同的哈希码.

而另一个是

2)如果两个对象根据equal()不相等,则不需要在两个对象中的每一个上调用hashcode方法必须产生不同的值.

我尝试并理解了第一个,这是第一点的代码.

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 ");
        }
    }
}

上面的程序为两个不同的对象提供相同的哈希码.

有人可以用一个例子来解释我,根据equals()不同的两个不同对象如何具有相同的哈希码.