Java 为什么此哈希表中的元素没有按预期排序

我最近开始学习数据结构。我根据这本书，用二次探测法写了一个哈希表。代码如下：

class QuadraticProbingHashTable<E> implements HashTable<E> {
    private static final int DEFAULT_TABLE_SIZE = 11;

    private HashEntry<E>[] array;

    private int currentSize;

    public QuadraticProbingHashTable() {
        this(DEFAULT_TABLE_SIZE);
    }

    public QuadraticProbingHashTable(int size) {
        allocateArray(size);
        makeEmpty();
    }

    @SuppressWarnings("unchecked")
    private void allocateArray(int size) {
        array = new HashEntry[nextPrime(size)];
    }

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

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

    @Override
    public void clear() {
        makeEmpty();
    }

    private void makeEmpty() {
        currentSize = 0;
        for (int i = 0; i < array.length; i++) {
            array[i] = null;
        }
    }

    @Override
    public boolean contains(E e) {
        int pos = findPos(e);
        return isActive(pos);
    }

    @Override
    public void add(E e) {
        int pos = findPos(e);
        if (isActive(pos))
            return;
        array[pos] = new HashEntry<E>(e);
        currentSize++;
        if (currentSize > array.length / 2)
            rehash();
    }

    @Override
    public void remove(E e) {
        int pos = findPos(e);
        if (isActive(pos)) {
            array[pos].isActive = false;
            currentSize--;
        }

    }

    private int findPos(E e) {
        int offset = 1;
        int currentPos = hash(e);
        while (array[currentPos] != null && !array[currentPos].data.equals(e)) {
            currentPos += offset;
            offset += 2;
            if (currentPos >= array.length)
                currentPos -= array.length;
        }
        return currentPos;
    }

    private boolean isActive(int pos) {
        return array[pos] != null && array[pos].isActive;
    }

    private int hash(E e) {
        int hashVal = e.hashCode();
        hashVal %= array.length;
        if (hashVal < 0)
            hashVal += array.length;
        return hashVal;
    }

    private void rehash() {
        HashEntry<E>[] oldArray = array;
        allocateArray(nextPrime(array.length << 1));
        currentSize = 0;
        for (int i = 0; i < oldArray.length; i++) {
            if (oldArray[i] != null && oldArray[i].isActive)
                add(oldArray[i].data);
        }
    }

    @Override
    public String toString() {
        StringJoiner joiner = new StringJoiner();
        for (int i = 0; i < array.length; i++)
            if (isActive(i))
                joiner.add(array[i].data);
        return joiner.toString();
    }

    private static class HashEntry<E> {
        E data;

        boolean isActive;

        public HashEntry(E data) {
            this(data, true);
        }

        public HashEntry(E data, boolean isActive) {
            this.data = data;
            this.isActive = isActive;
        }
    }

    // get next prime
    public int nextPrime(int n) {
        if (n % 2 == 0)
            n++;
        while (!isPrime(n))
            n += 2;
        return n;
    }

    private boolean isPrime(int n) {
        if (n == 2 || n == 3)
            return true;
        if (n == 1 || n % 2 == 0)
            return false;
        for (int i = 3; i * i <= n; i++) {
            if (n % i == 0)
                return false;
        }
        return true;
    }

    // util
    private static class StringJoiner {
        private String delimiter;

        private String prefix;

        private String suffix;

        private String emptyValue;

        private StringBuilder builder;

        public StringJoiner() {
            this(", ", "[", "]");
        }

        public StringJoiner(String delimiter, String prefix, String suffix) {
            super();
            this.delimiter = delimiter;
            this.prefix = prefix;
            this.suffix = suffix;
            emptyValue = prefix + suffix;
        }

        public StringJoiner add(Object obj) {
            prepareBuilder().append(obj.toString());
            return this;
        }

        private StringBuilder prepareBuilder() {
            if (builder == null)
                builder = new StringBuilder().append(prefix);
            else
                builder.append(delimiter);
            return builder;
        }

        @Override
        public String toString() {
            if (builder == null)
                return emptyValue;
            return builder.append(suffix).toString();
        }
    }

}

interface HashTable<E> {
    int size();
    boolean isEmpty();
    void clear();
    boolean contains(E e);
    void add(E e);
    void remove(E e);
}

然后，我在第一个测试数据中添加了10，并再次测试：

public class MainTest {
    public static void main(String[] args) {
        HashTable<Integer> table = new QuadraticProbingHashTable<>();
        // for (int i = 60; i <= 90; i++) {
        for (int i = 70; i <= 100; i++) {
            table.add(i);
        }
        System.out.println(table);
    }
}

它变得混乱了

---

我不知道我写的代码是否有问题，或者有其他原因。有人能帮我查一下吗？我刚刚谈到了数据结构。

哈希表不是用来作为排序数据结构的。它们是为快速查找而设计的，并将按允许最快速查找的顺序放置元素

---

如果您的表在某一点上被排序，那么这只是偶然的。

一旦您的表正常运行，您应该将其发布到上。这里似乎有很多无关的代码。

[60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90]

public class MainTest {
    public static void main(String[] args) {
        HashTable<Integer> table = new QuadraticProbingHashTable<>();
        // for (int i = 60; i <= 90; i++) {
        for (int i = 70; i <= 100; i++) {
            table.add(i);
        }
        System.out.println(table);
    }
}

[97, 98, 99, 100, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96]