Java bucket是单个内存位置还是类似于内存位置数组？

正如我们所说的，对于具有相同哈希代码的两个不相等的对象，对象存储在同一个bucket中，这实际上意味着什么？

当多个对象落入同一个bucket中时，它们存储为该bucket中的单个链表

---

哈希表的优点是，您可以计算一个键在O（1）时间内到达哪个存储桶。这意味着，如果每个bucket只有一个元素，那么无论表中有多少个元素，您的查找时间都保持不变。当你在一个桶里有多把钥匙时，如果不检查每把钥匙，你就无法分辨出你要找的是哪把钥匙。当你有一个糟糕的散列函数，将许多元素放入同一个bucket时，你就失去了哈希表的优势，它的行为开始更像一个链表。

当多个对象落在同一个bucket中时，它们被存储为该bucket中的单个链表

哈希表的优点是，您可以计算一个键在O（1）时间内到达哪个存储桶。这意味着，如果每个bucket只有一个元素，那么无论表中有多少个元素，您的查找时间都保持不变。当你在一个桶里有多把钥匙时，如果不检查每把钥匙，你就无法分辨出你要找的是哪把钥匙。当你有一个糟糕的散列函数，它把许多元素放在同一个bucket中，你就失去了哈希表的优势，它开始表现得更像一个链表

2个具有相同哈希代码的不相等对象，这些对象存储在 同样的桶，它实际上意味着什么

我将用下面的

产品
类示例向您解释这个概念：

产品类别：

public class Product {

     private int id;

     public Product(int id) {
        this.id = id;
     }

     //add getters and settes for id

     public boolean equals(Object obj) {
         Product product = (Product)obj;
         if(id == product.getId()) {
             return true;
         }
         return false;
     }

     public int hashcode() {
         return 1;
     }
}

public class Test {

    public static void main(String[] args) {
        Set<Product> set = new HashSet<>();
        Product p1 = new Product(1);
        Product p2 = new Product(2);
        set.add(p1);
        set.add(p2);
    }
}

测试类：

public class Product {

     private int id;

     public Product(int id) {
        this.id = id;
     }

     //add getters and settes for id

     public boolean equals(Object obj) {
         Product product = (Product)obj;
         if(id == product.getId()) {
             return true;
         }
         return false;
     }

     public int hashcode() {
         return 1;
     }
}

public class Test {

    public static void main(String[] args) {
        Set<Product> set = new HashSet<>();
        Product p1 = new Product(1);
        Product p2 = new Product(2);
        set.add(p1);
        set.add(p2);
    }
}

公共类测试{
公共静态void main（字符串[]args）{
Set=newhashset（）；
产品p1=新产品（1）；
产品p2=新产品（2）；
集合。添加（p1）；
集合。添加（p2）；
}
}

假设您已经为
Product
类创建了两个对象
p1
和
p2
，并添加到
HashSet
，如上所示

根据
产品
类的合同，
p1
和
p2
对象不相等，因为它们的产品ID不同。
在
HashSet
中，这些
p1
和
p2
对象根据
Product
对象返回的
hashcode
存储到不同的存储桶中（只需放置不同的内存位置）。
由于
p1
和
p2
对象都返回相同的hashcode（来自
hashcode（）
方法，来自
Product
类），因此它们都将保存到同一个存储桶（内存位置）。
同样，所有
产品
对象（即使
产品
对象不相等）将被推到相同的存储桶中，因为它们的哈希代码相同

因此，当您尝试使用
set.contains（）
从
HashSet
中搜索
product
对象时，必须从整个产品中扫描并找到该对象（假设您存储了10000个对象）

但是当您正确地实现
hashcode（）
时，即为不同的
产品
对象返回不同的hashcode，那么
产品
对象将分布在不同的存储桶中，并且检索变得更快（无需扫描所有对象），即，它显著提高了性能

相同的概念适用于Java中所有
Hash
*相关的集合API（HashMap、HashSet等）方法

bucket是单个内存位置还是类似于内存数组
地点

一个Bucket存储多个对象引用，每个Hash Bucket在内部使用数据结构，如
LinkedList
或
TreeMap
来定位存储的对象

你可以在这里查看关于同一主题的更多细节

2个具有相同哈希代码的不相等对象，这些对象存储在
同样的桶，它实际上意味着什么

我将用下面的
产品
类示例向您解释这个概念：

产品类别：

public class Product {

     private int id;

     public Product(int id) {
        this.id = id;
     }

     //add getters and settes for id

     public boolean equals(Object obj) {
         Product product = (Product)obj;
         if(id == product.getId()) {
             return true;
         }
         return false;
     }

     public int hashcode() {
         return 1;
     }
}

public class Test {

    public static void main(String[] args) {
        Set<Product> set = new HashSet<>();
        Product p1 = new Product(1);
        Product p2 = new Product(2);
        set.add(p1);
        set.add(p2);
    }
}

测试类：

public class Product {

     private int id;

     public Product(int id) {
        this.id = id;
     }

     //add getters and settes for id

     public boolean equals(Object obj) {
         Product product = (Product)obj;
         if(id == product.getId()) {
             return true;
         }
         return false;
     }

     public int hashcode() {
         return 1;
     }
}

public class Test {

    public static void main(String[] args) {
        Set<Product> set = new HashSet<>();
        Product p1 = new Product(1);
        Product p2 = new Product(2);
        set.add(p1);
        set.add(p2);
    }
}

公共类测试{
公共静态void main（字符串[]args）{
Set=newhashset（）；
产品p1=新产品（1）；
产品p2=新产品（2）；
集合。添加（p1）；
集合。添加（p2）；
}
}

假设您已经为
Product
类创建了两个对象
p1
和
p2
，并添加到
HashSet
，如上所示

根据
产品
类的合同，
p1
和
p2
对象不相等，因为它们的产品ID不同。
在
HashSet
中，这些
p1
和
p2
对象根据
Product
对象返回的
hashcode
存储到不同的存储桶中（只需放置不同的内存位置）。
由于
p1
和
p2
对象都返回相同的hashcode（来自
hashcode（）
方法，来自
Product
类），因此它们都将保存到同一个存储桶（内存位置）。
同样，所有
产品
对象（即使
产品
对象不相等）将被推到相同的存储桶中，因为它们的哈希代码相同

因此，当您尝试使用
set.contains（）
从
HashSet
中搜索
product
对象时，必须从整个产品中扫描并找到该对象（假设您存储了10000个对象）

但是当您正确地实现
hashcode（）
时，即为不同的
Product
对象返回不同的hashcode，那么