哈希表重新哈希条件不评估Java

我正在设计一个具有线性探测冲突分辨率的哈希表。我设计了一个容量，它定义了桶的数量和负载系数。当哈希表中的元素数超过容量和负载因子的乘积时，应重新设置数组的哈希值。出于某种原因，我的代码中甚至没有调用该方法。以下是我的主要方法：

public class MyJHUHashMap<K extends Comparable<? super K>, V> implements JHUHashMap<K, V>{

    private int cap;
    private int numElements;
    private double loadFactor;
    private Node<K,V>[] hashtable;

    public static void main(String[] args) {
        MyJHUHashMap<Integer, Integer> m = new MyJHUHashMap<>();
        m.put(1, 1);
        m.put(2, 2);
        m.put(3, 3);
        m.put(4, 4);
        m.put(5, 5);
        m.put(6, 6);
        m.put(7, 7);
        System.out.println(m.cap);
        System.out.println(m.size());
        for(int i=0; i<m.hashtable.length; i++) {
            if(m.hashtable[i] != null)
                System.out.println(m.hashtable[i].key);
        }
    }

这是我的代码：

private final class Node<K extends Comparable<? super K>, V>  {
        public K key;
        public V val;

        public Node() {
            this.key = null;
            this.val = null;
        }

        public Node(K theKey, V theValue) {
            this.key = theKey;
            this.val = theValue;
        }
    } 

    public MyJHUHashMap() {
        this.cap = 11;
        this.numElements = 0;
        this.loadFactor = 0.5;
        this.hashtable = new Node[cap];
    }

    public MyJHUHashMap(int pInitCap, double pLoadFactor) {
        if(pInitCap > 0 && pLoadFactor > 0) {
            this.cap = pInitCap;
            this.loadFactor = pLoadFactor;
        } else {
            throw new IllegalArgumentException();
        }
        this.numElements = 0;
        this.hashtable = new Node[cap];
    }

    @Override
    public V put(K key, V value) {
        if(containsKey(key)) {
            int foundindex = find(key);
            V prevObject = this.hashtable[foundindex].val;
            //hashtable[foundindex] = new Node(key, value);
            this.hashtable[foundindex].val = value;
            return prevObject;
        }
        int index = key.hashCode() % cap;
        if(this.hashtable[index] == null) {
            this.hashtable[index] = new Node<K,V>(key, value);
            this.numElements++;
            return null;
        } 
        boolean found = false;
        //index += 1;
        while(found) {
            index += 1;
            if(hashtable[index] == null) {
                hashtable[index] = new Node<K,V>(key, value);
                this.numElements++;
                found = true;
                //return null;
            }
            //index += 1;
        }
        if(this.numElements > this.cap * this.loadFactor) {
            System.out.println("Rehashing...");
            rehashAndResize();
        }
        return null;
    }

    public void rehashAndResize() {
        //Node<K,V>[] temp = new Node[this.hashtable.length*2];
        //Node<K,V>[] temp = new Node[this.hashtable.length*2];
        System.out.println("Calling rehash method");
        MyJHUHashMap<K,V> temp = new MyJHUHashMap<K, V>(this.hashtable.length * 2, this.loadFactor);
        for(int i=0; i<this.hashtable.length; i++) {
            temp.put(this.hashtable[i].key, this.hashtable[i].val);
        }

        this.hashtable = temp.hashtable;
    }

没有打印Rehashing和调用rehash方法，因此没有调用该方法，我不明白为什么。我输入了7个元素，当我询问哈希表元素的数量时，它正确地输出了7个元素，那么为什么不计算条件呢

---

编辑：好的，在仔细检查之后，我发现再灰化方法从未实现，因为该方法返回得很早。谢谢你的帮助

在程序运行期间，this.numElements>this.cap*this.loadFactor是否为真？这是调用方法的唯一方式…我添加了7个元素，它知道有7个元素，7>11*0.5，所以应该是真的，你确定吗？同样，如果不调用方法，则该表达式的计算结果必须为false。所发生的情况是，每当插入新值时，该方法都会返回，并且没有冲突，因此从未到达重新灰化方法。谢谢你的帮助！