Java 如何在哈希映射中找到平均桶长度？

我正在做一个类赋值，它要求我们创建一个HashMap，然后用随机值填充它，首先不进行动态调整，然后进行动态调整，以查看较小的存储桶大小在存储值时产生的速度差异

为了做到这一点，它要求我创建一个方法，在HashMap中查找最短的bucket长度、平均bucket长度和最长的bucket长度

这就是我遇到问题的地方，因为当我尝试获取桶的长度时，它总是返回零。我不确定我的问题在哪里，因为我的代码在逻辑上对我来说是有意义的。任何帮助都将不胜感激

下面是我的HashMap和调用它的主程序的代码

public class MyHashMap<K, V> {
    private LinkedList<KVP <K, V>>[] bucket;
    private int M = 5;
    private int size = 0;


    public MyHashMap(int M){
        this.bucket = (LinkedList<KVP<K, V>>[]) new LinkedList[M];
        for(int i = 0; i < M; i++){
            bucket[i] = new LinkedList<KVP<K, V>>();
        }
    }
    public MyHashMap(){
        this.bucket = (LinkedList<KVP<K, V>>[]) new LinkedList[M];
        for(int i = 0; i < 5; i++){
            bucket[i] = new LinkedList<KVP<K, V>>();
        }
    }

    public int getBucketNumber(K key){
        return Math.abs(key.hashCode()) % this.bucket.length;
    }
    public void put(K key, V value){
        //resize();
        size++;
        int b = getBucketNumber(key);
        for(KVP<K, V> pair : this.bucket[b]){
            if(pair.key.equals(key)){
                pair.value = value;
                return;
            }
        }
        KVP<K, V> pair = new KVP<>(key, value);
        this.bucket[b].add(pair);
    }
    public int size(){
        return this.bucket.length;
    }
    public boolean isEmpty(){
        return size == 0;
    }
    public void resize(){
      if(size > size() * 2){
          LinkedList<KVP <K, V>>[] newHash = (LinkedList<KVP<K, V>>[]) new LinkedList[2 * size()];
          for(int i = 0; i < newHash.length; i++){
              newHash[i] = new LinkedList<KVP <K, V>>();
          }
          for(LinkedList<KVP<K, V>> map: this.bucket){
              for(KVP<K, V> pair: map){
                  int newHashCode = Math.abs(pair.key.hashCode()) % newHash.length;
                  newHash[newHashCode].add(pair);
              }
          }
          this.bucket = newHash;
      }     
    }

    public void delete(K key){
        int b = getBucketNumber(key);
        for(KVP<K, V> pair : this.bucket[b]){
            if(pair.key.equals(key)){
                key = null;
            }
        }
    }
    public boolean containsKey(K key){
        int b = getBucketNumber(key);
        boolean t = false;
        for(KVP<K, V> pair : this.bucket[b]){
            if(pair.key.equals(key)){
                t = true;
            }else{
                t = false;
            }
        }
            return t;
    }
    public V get(K key){
        int b = getBucketNumber(key);
        for(KVP<K, V> pair : this.bucket[b]){
            if(pair.key.equals(key)){
                return pair.value;
            }
        }
        return null;
    }
    public int Avg(){
        int j = 0;
        for(int i = 0; i < bucket.length; i++){
            j += bucket[i].size();
        }
        return j/bucket.length;
    }

}

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

        int N = (int) Math.pow(10, 3);
        MyHashMap<Integer, Integer> store = new MyHashMap<>();      
        for(int i = 0; i < N; i++){

            store.put((int) Math.random(), 1);
            }
        System.out.print(store.Avg());
    }
}

公共类MyHashMap{
私有LinkedList[]存储桶；
私有int M=5；
私有整数大小=0；
公共MyHashMap（int M）{
this.bucket=（LinkedList[]）新LinkedList[M]；
for（int i=0；i大小（）*2）{
LinkedList[]新哈希=（LinkedList[]）新LinkedList[2*size（）]；
for（int i=0；i

因为根据

Math.random（）

：

返回一个带正号的双精度值，大于或等于 0.0且小于1.0

由于该数字始终小于1.0，因此执行此操作时：

(int) Math.random()

它总是返回0（零）

解决方案：

若您有一系列随机数和一个最小值，请使用以下选项：

(int) (Math.random() * range) + minimum

例如：您希望随机抽取1到100之间的数字

(int) (Math.random() * 100) + 1

---

提示：int/int->int，因此1/2=0。一个与问题无关的改进是：您可以从delete中调整bucket的大小，因为这将减少空间并释放额外的空间。实际值不会影响每个bucket的键值对的平均数量，即使它们小于1，因为键在排序之前仅用于计算哈希代码装进桶里。我的意思是，它们是随机的，因此不会明显影响每个桶的平均值。对于所有

put

，键的值将为0。这不是问题吗？我现在明白你的意思，但当我现在添加最小值和范围时，每次都返回20的值，所以我不确定这是问题所在。范围和最小值是什么？我将范围设置为100，最小值设置为1，就像你一样。此外，我使用了另一个建议，并更改了平均方法计算，以生成双精度而不是整数。我不确定这两件事是否相互影响。