Java （业余程序员）自定义哈希映射大小总是比预期的小一个？

下午好

在我当前的计算机科学课程中，我们的教授让我们实现一个HashMap类，而不使用Java内置的Map类（除了使用它的接口）。我已经完成了大部分，现在处于调试模式。我的教授评分服务器告诉我，我总是返回一个“尺寸”比预期的少，即我的班级返回尺寸48时，预计尺寸49。我想我已经把它缩小到put（）方法中，因为它是唯一一个大小向上递增的方法，但我不确定。如有关于本课程的任何信息，将不胜感激。另外，作为一个重要的补充，我正在使用“链接”冲突解决技术

谢谢大家

  {package adt;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;

  @SuppressWarnings("unchecked")


  public class HashMap<K , V> implements Map<K, V>{

//linked list style
private class Entry<K, V> {
    private K key;
    private V value;
    private Entry<K, V> next;

    private Entry( K key, V value){
        this.key = key;
        this.value = value;
        this.next = null;
    }
}


private Entry<K, V>[] table = new Entry[1024]; // Creates a table of Entries. Because of the chaining implementation, each Entry will be treated like a linked list, so each Entry has a .next.
int size = 0;


public HashMap(){
    for(int i =0; i<table.length; i++){
        table[i] = null;
    }
}


@Override
public int size() {
    return size;
}

@Override
public boolean isEmpty() {
return size ==0;
}

@Override
public boolean containsKey(Object key) {
    int location = Hash(key) % table.length;
    Entry<K, V> e = table[location];
    if(table[location] == null){
        return false;
    }else{
        while (e!= null && e.key.equals(key) == false){
            e = e.next;

            if( e.key.equals(key)){
                return true;
            }
        }
    }
    return false;
}

@Override
public boolean containsValue(Object value) {
    for (int i = 0; i<table.length; i++){
        if(table[i] != null){
            Entry<K, V> e = table[i];
            while( e.value.equals(value)==false){
                e = e.next;
                if(e.value.equals(value)){
                    return true;
                }
            }
        }
    }
    return false;
}
@Override
public V get(Object key) {
    V value = null;
    int location = Hash(key)% table.length;
    if (table[location] == null){
        value = null;
    }else{
        Entry<K, V> e = table[location];

        while(e !=null && e.key.equals(key) == false){
            e = e.next;

            if (e == null){
                value = null;
            }
            else{
                value = (V) e.value;
            }
        }
    }
    return value;
}

@Override
public V put(K key, V value) {
    V returnValue = null;
    int location = Hash(key) % table.length;

    if ( table[location]== null){
        table[location] = new Entry< K, V>(key, value);
        size++;

    }
    else{
        Entry<K, V> e = table[location];
        while ( e.next != null && e.key.equals(key) == false){
            e = e.next;

            if( e.key.equals(key)){
                e.value = value;
                returnValue =  e.value;

            }else if(e.next == null){
                e.next = new Entry<K, V>(key, value);
                returnValue = e.value;
                size++;
            }

        }
    }

    return returnValue;

}

@Override
public V remove(Object key) {
    int location = Hash(key) % table.length;
    V value = null;
    Entry<K, V> e = table[location];
    if(table[location] == null){
        value = null;
    }else {
        while(e.next != null && e.key.equals(key) == false){
            e = e.next;
            if(e.key.equals(key)){
                value = e.value;
                e = null;
                size--;
            }else{
                value = null;

            }

        }
    }

    return value;
}

@Override
public void putAll(Map<? extends K, ? extends V> m) {
    // TODO Auto-generated method stub

}

@Override
public void clear() {
    for(int i =0; i<table.length; i++){
        table[i] = null;
    }
    size = 0;
}

@Override
public Set<K> keySet() {
    Set<K> s = new HashSet<K>();
    Entry<K, V> e;
    if(!isEmpty()){
    for(int i = 0; i<table.length; i++){
        e = table[i];
        if(e != null){
            s.add(e.key);
            while(e.next != null){
                s.add(e.key);
                e=e.next;
            }
        }
    }
    }
    return s;
}

@Override
public Collection<V> values() {
    Collection<V> c = new ArrayList<V>();
    Entry<K,V> e;
    if(isEmpty()==false){
        for(int i=0; i<table.length;i++){
            e = table[i];
            if(e != null){
                c.add(e.value);
                while(e.next !=null){
                    c.add(e.value);
                }
            }
        }
    }
    return c;
}

@SuppressWarnings("rawtypes")
@Override
public Set entrySet() {

    Set<Entry> s = new HashSet<Entry>();
    Entry<K,V> e;
    if(isEmpty()==false){
        for(int i = 0; i<table.length; i++){
            e = table[i];
            if( e!=null){
                while(e.next != null){
                    s.add(e);
                }
            }
        }
    }
    return s;
}

public int Hash(Object k){
    String key = k.toString();
    int n = 13;
    for(int i = 0; i<key.length(); i++){
    n += n + key.charAt(i);
    }
    n = n*31;
    return n;
}

public boolean equals(Object o){
    Map<K, V> m2;
    if( o instanceof Map){

    m2 = (Map<K,V>)o;
    if(entrySet().equals(m2.entrySet())){
        return true;
    }
}
    return false;
  }
 }  
}

{package adt；
导入java.util.ArrayList；
导入java.util.Collection；
导入java.util.HashSet；
导入java.util.Map；
导入java.util.Set；
@抑制警告（“未选中”）
公共类HashMap实现映射{
//链表样式
私人班级入学{
私钥；
私人价值；
下一步是私人进入；
专用条目（K键，V值）{
this.key=key；
这个值=值；
this.next=null；
}
}
private Entry[]table=new Entry[1024]；//创建一个条目表。由于链接实现，每个条目将被视为一个链表，因此每个条目都有一个.next。
int size=0；
公共HashMap（）{
对于（int i=0；i一般来说，似乎有几种情况下，您将
e
值预增量为
e.next
，甚至不比较
e.key

以
put
为例，因为这就是我们正在谈论的

您可以从表中获得一个条目
虽然它后面的键不为null，并且它的当前键不等于要放置的键
移动条目？？为什么？您还没有检查第一个条目的键是否与任何内容相等
您正在跳过第一个条目的密钥

你应该像对待for循环一样对待它。初始化，测试一些条件，然后递增

int location = Hash(key) % table.length;
Entry<K, V> e = table[location];
while ( e.next != null && !e.key.equals(key)) {
    if( e.key.equals(key)) {
        // do some stuff 
    }
    e = e.next;
}

一般来说，似乎有几种情况下，您将
e
值预增量为
e.next
，甚至不比较
e.key

以
put
为例，因为这就是我们正在谈论的

您可以从表中获得一个条目
虽然它后面的键不为null，并且它的当前键不等于要放置的键
移动条目？？为什么？您还没有检查第一个条目的键是否与任何内容相等
您正在跳过第一个条目的密钥

你应该像对待for循环一样对待它。初始化，测试一些条件，然后递增

int location = Hash(key) % table.length;
Entry<K, V> e = table[location];
while ( e.next != null && !e.key.equals(key)) {
    if( e.key.equals(key)) {
        // do some stuff 
    }
    e = e.next;
}

@cricket_007发现你哪里弄错了，但我还是想发布我的版本。我认为它更可读，逻辑更清晰

@Override
public V put(K key, V value) {
    int index = hash(key) % table.length;

    Entry<K, V> prev = null;        
    for (Entry<K, V> entry = table[index]; entry != null; prev = entry, entry = entry.next) {
        if (Objects.equals(entry.key, key)) {
            V res = entry.value;
            entry.value = value;
            return res;
        }
    }

    Entry<K, V> newEntry = new Entry<K, V>(key, value);

    if (prev == null) table[index] = newEntry;
    else              prev.next = newEntry;

    size++;
    return null;
}

@覆盖
公共V输入（K键，V值）{
int index=散列（键）%table.length；
条目prev=null；
for（Entry=table[index]；Entry！=null；prev=Entry，Entry=Entry.next）{
if（Objects.equals（entry.key，key））{
V res=输入值；
entry.value=值；
返回res；
}
}
条目newEntry=新条目（键、值）；
如果（prev==null）表[索引]=newEntry；
else prev.next=新条目；
大小++；
返回null；
}

此代码有两个明显不同的部分：第一部分是搜索现有密钥，直到用尽所有密钥。只要找到一个匹配作为参数传递的密钥，就可以返回

第二部分是找不到匹配项时发生的情况。在这种情况下，大小总是递增的。这使您在需要或不需要递增大小以及插入和元素时变得非常清楚

奖励：
对象。equals
处理现有密钥为
null
的情况。如果您将其与
对象一起使用。hashCode
或任何接受
null
的哈希，您的地图可以支持
null
密钥。
@cricket 007发现了错误的地方，但我想发布我的版本我认为它更可读，逻辑更清晰

@Override
public V put(K key, V value) {
    int index = hash(key) % table.length;

    Entry<K, V> prev = null;        
    for (Entry<K, V> entry = table[index]; entry != null; prev = entry, entry = entry.next) {
        if (Objects.equals(entry.key, key)) {
            V res = entry.value;
            entry.value = value;
            return res;
        }
    }

    Entry<K, V> newEntry = new Entry<K, V>(key, value);

    if (prev == null) table[index] = newEntry;
    else              prev.next = newEntry;

    size++;
    return null;
}

@覆盖
公共V输入（K键，V值）{
int index=散列（键）%table.length；
条目prev=null；
for（Entry=table[index]；Entry！=null；prev=Entry，Entry=Entry.next）{
if（Objects.equals（entry.key，key））{
V res=输入值；
entry.value=值；
返回res；
}
}
条目newEntry=新条目（键、值）；
如果（prev==null）表[索引]=newEntry；
else prev.next=新条目；
大小++；
返回null；
}

此代码有两个明显不同的部分：第一部分是搜索现有密钥，直到用尽所有密钥。只要找到一个匹配作为参数传递的密钥，就可以返回

第二部分是找不到匹配项时发生的情况。在这种情况下，大小总是递增的。这使您在需要或不需要递增大小以及插入和元素时变得非常清楚

奖励：
对象。equals
处理现有密钥为
null
的情况。如果您将其与
对象一起使用。hashCode
或任何接受
null
的哈希，则您的地图可以支持
null
密钥。
您说过要缩小它的范围，请将所有的具体代码放在地图上。请提供在检查
e.key
之前，你的put函数调用
e=e.next；”
，从而错误地处理了第一个元素匹配的情况。@DavidSchwartz是的，我的错，我不得不重读几次代码你说你缩小了范围，把你所有的重要代码都放进去了。请提供