Java 试图打印哈希表，但我一直在获取内存位置

嘿，我一直试图打印我的哈希表，但即使我使用toArray和toString方法，它打印的都是内存位置。我真的很困惑，因为我以为ToArray和ToString就是为了这个问题。任何帮助都将不胜感激

我声明我的哈希表如下：

 HashTable<Integer,EmployeeInfo> phone =  new HashTable<>(300);

HashTable电话=新的HashTable（300）；

同样，当我尝试执行这些操作时，我得到的只是内存位置，而不是哈希表所保存的实际数据。例如，当我执行phone.toString（）时，我得到的只是：散列。HashTable@55f96302. 任何帮助都将不胜感激，谢谢：）

包散列；
导入java.util.array；
公共类散列{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
哈希表电话=新哈希表（300）；
System.out.println（phone.toString（））；
}
公共静态类哈希表
{
私人整数；
专用静态最终int默认_容量=5；
私有HashHolder[]哈希表；
私有int表大小；
公共哈希表（）
{
这（默认容量）；
}
公共哈希持有者[]toArray（）
{
int size=hashTable.length；
@抑制警告（“未选中”）
HashHolder[]tempArray=Arrays.copyOf（hashTable，size）；/（HashHolder[]）新对象[size]；
返回数组；
}
公共哈希表（int initCapacity）
{   
//注意：我没有在这里对容量限制进行严格检查。我可能应该。。。
@抑制警告（“未选中”）
HashHolder[]临时=（HashHolder[]）新的HashHolder[initCapacity]；
哈希表=温度；
numberEntries=0；
}
}
公共静态类哈希持有者
{
私钥；
私有数据；
下一步是私有哈希持有者；
私人国家；
私有枚举状态{CURRENT，REMOVED}；
@凌驾
公共字符串toString（）
{
if（state！=States.REMOVED）
返回String.format（“%s:%s”、hashKey.toString（）、data.toString（））；
其他的
返回String.format（“已删除”）；
}
公共哈希持有者（K键，V值）
{
hashKey=key；
数据=价值；
state=States.CURRENT；
}
}
}

您的

哈希表

类需要自己的

toString（）

方法来生成一些合理的输出。否则，您只需从

对象

获取默认的

toString

行为，该行为会打印或多或少无用的

散列。HashTable@55f96302

您看到了。

您是否覆盖了

EmployeeInfo.java

中的

toString（）

方法请注意，自java 2以来，

HashTable

已被弃用（那是15年前的事了）.

HashMap

是首选的数据结构。您不需要发布所有代码。您只需要显示足够的代码，以便任何人都能理解您的问题。此外，我们应该能够复制、粘贴并编译它，而不会出现任何其他错误。您有一个良好的开端。但是，

HashTable

HashHolder

缺少一个右括号，并且没有方法。原始帖子中的哪些方法应该在

哈希表

中？哪些应该在

哈希表

中？将它们移到它们所属的位置。您发布了一个

toString

方法。它是用于什么类的？您的

哈希表

类需要一个

toString

方法，这样当您尝试打印它时，您会得到一个字符串，该字符串可能会显示它包含的内容或描述性名称。您需要在

哈希表中重写
toString（）
，以获得任何有意义的输出。（注意：当前版本的代码有编译器错误，因为
哈希表
没有带参数的构造函数。解决此问题的最佳方法是删除无参数构造函数，依赖默认构造函数，并在使用
新建
创建
哈希表
时不传递参数）
package hashing;

import java.util.Arrays;

public class Hash {

public static void main(String[] args) {
    // TODO Auto-generated method stub

     HashTable<Integer,EmployeeInfo> phone =  new HashTable<>(300);
     System.out.println(phone.toString());
}

public static class HashTable<K,V>
{
    private int numberEntries;
    private static final int DEFAULT_CAPACITY = 5;

    private HashHolder<K,V>[] hashTable;
    private int tableSize;

    public HashTable()
    {
        this(DEFAULT_CAPACITY);
    }


    public HashHolder<K,V>[] toArray()
    {
        int size = hashTable.length;
        @SuppressWarnings("unchecked")
        HashHolder<K,V>[] tempArray = Arrays.copyOf(hashTable,size);//(HashHolder<K,V>[]) new Object[size];
        return tempArray;
    }
    public HashTable(int initCapacity)
    {   
        //Note: I'm not implementing a rigorous check for capacity constraints here.  I probably should...
        @SuppressWarnings("unchecked")
        HashHolder<K,V>[] temp = (HashHolder<K,V>[]) new HashHolder[initCapacity];
        hashTable = temp;

        numberEntries = 0;
    }



}

public static class HashHolder<K,V> 
{
    private K hashKey;
    private V data;
    private HashHolder<K,V> next;
    private States state;
    private enum States {CURRENT,REMOVED};


    @Override
    public String toString()
    {
        if(state != States.REMOVED)
            return String.format("%s: %s", hashKey.toString(), data.toString());
        else
            return String.format("REMOVED");
    }
    public HashHolder(K key, V value)
    {
        hashKey = key;
        data = value;
        state = States.CURRENT;
    }

}

}