Java 在自定义哈希表上迭代

我有一个自定义的java哈希表实现

public class HashSet<T> implements HashTableInterface<T> {

private static int DEFAULT_ARRAY_SIZE = 10;

private T[] items;

public HashSet() {
    final T[] items = (T[]) new Object[DEFAULT_ARRAY_SIZE];
    this.items = items;
}

@Override
public boolean add(T item) {
    int index = getIndex(item);
    do {
        if (items[index] != null) {
            index = (index + 1) % DEFAULT_ARRAY_SIZE;
        } else {
            items[index] = item;
            break;
        }
    } while (index != getIndex(item));

    return true;
}

@Override
public boolean remove(T item) {
    if (contains(item)) {
        items[getIndex(item)] = null;
        return true;
    } else {
        return false;
    }
}

@Override
public boolean contains(T item) {
    T itemArray = items[getIndex(item)];
    if (item.equals(itemArray)) {
        return true;
    } else {
        int index = (getIndex(item) + 1) % DEFAULT_ARRAY_SIZE;
        do {
            if (items[index] != null) {
                if (items[index].equals(item)) {
                    return true;
                } else {
                    index = (index + 1) % DEFAULT_ARRAY_SIZE;
                }
            } else {
                break;
            }
        } while (index != getIndex(item));
    }
    return items[getIndex(item)] != null;
}

@Override
public int getIndex(T item) {
    return item.hashCode() % DEFAULT_ARRAY_SIZE;
}

@Override
public int size() {
    int count = 0;
    for (T item : items) {
        if (item != null) {
            count++;
        }
    }
    return count;
}

@Override
public String toString() {
    return items.toString();
}}

我在contains方法中也有同样的问题

public boolean contains(T item) {
    T itemArray = items[getIndex(item)];
    if (item.equals(itemArray)) {
        return true;
    } else {
        int index = (getIndex(item) + 1) % DEFAULT_ARRAY_SIZE;
        do {
            if (items[index] != null) {
                if (items[index].equals(item)) {
                    return true;
                } else {
                    index = (index + 1) % DEFAULT_ARRAY_SIZE;
                }
            } else {
                break;
            }
        } while (index != getIndex(item));
    }
    return items[getIndex(item)] != null;
}

---

有许多不同的方法来避免碰撞，你所做的被称为“线性探测”

还有（参考）

二次探测

双重散列

以及使用链表进行值冲突的方案

---

所有这些都有不同的权衡，你应该让自己做出明智的决定。

你的课程不是一套。当遇到“重复”项时，将覆盖其内容中的另一项，并保留原始项和副本。当添加具有相同哈希值但不同值的重复项时，应添加它们。但是就在下一个空闲的地方，你的remove方法出现了错误，它将删除第一个条目，该条目的hashcode与你实际要删除的元素相同。此外，它还使得无法再次找到其他元素。@Fabian，那么正如我所说的，这个类不是一个集合，因为向集合中添加重复项不会产生任何效果，而向数据结构中添加会替换一个完全不相关的项。@kutschkem是的，我相信它仍在开发中。

public boolean contains(T item) {
    T itemArray = items[getIndex(item)];
    if (item.equals(itemArray)) {
        return true;
    } else {
        int index = (getIndex(item) + 1) % DEFAULT_ARRAY_SIZE;
        do {
            if (items[index] != null) {
                if (items[index].equals(item)) {
                    return true;
                } else {
                    index = (index + 1) % DEFAULT_ARRAY_SIZE;
                }
            } else {
                break;
            }
        } while (index != getIndex(item));
    }
    return items[getIndex(item)] != null;
}