Hashtable 实现了一个 set 接口，但 1 个测试不起作用

Question

我写了一个代码，一个哈希表实现了一个集合接口。 该代码在此处。 我的大部分测试都在 Junit 中进行，但其中一个不是（“public void addUniqueElementsWithEqualHashesIncrementsSize()”）请帮助我解决我的代码中缺少的内容。

//TODO: 我应该在 HashSet class 的代码中添加什么来完成我在此处添加的 1 测试。

import java.util.LinkedList;
import java.util.List;
import java.util.Objects;

import static java.util.Objects.hash;

/**
 * A hash table-based implementation of the Set interface.
 */
public class HashSet<T> implements Set<T> {
   private List<T>[] table;
    private int size;
    private int capacity;
    private int index;



     /**
     * Creates a hash table with the given capacity (amount of buckets).
     *
     * @throws IllegalArgumentException if capacity <= 0.
     */
    public HashSet(int capacity) {
        if (capacity <= 0) {
            throw new IllegalArgumentException(
                "capacity must be a positive, non-zero value! Provided: " + capacity);
        }

        // We want to do the following:
        //
        //     table = new LinkedList<String>[capacity];
        //
        // However, that won't compile ("generic array creation")
        // since Java generics and arrays don't get along very well.
        // Instead we need to do the following:
        //
        //     table = new LinkedList[capacity];
        //
        // The above will compile, but with a warning. The proper
        // approach is to document why the warning can be safely
        // ignored and then suppress the warning. Thus:

        /* 
         * This array will contain only LinkedList<T>
         * instances, all created in the add method. This
         * is sufficient to ensure type safety.
         */
     @SuppressWarnings("unchecked") // for this declaration only
      List<T>[] t = new LinkedList[capacity];
      table = t;
      size = 0;
    }


    /**
     * Adds the given element to the set.
     *
     * Complexity: O(1) expected time.
     *
     * @param elem An element to add to the set.
     * @return true if the set did not contain the element, otherwise false.
     */
    @Override
    public boolean add(T elem) {
    if (elem == null || elem.equals("")){
            return false;
        }

        int hash = Math.abs(elem.hashCode() % table.length);

        if (table[hash]== null){
            table[hash] = new LinkedList<T>();
            table[hash].add(elem);
            size ++;
            return true;
        }
        if (table[hash].contains(elem)){
            return false;
        }else{
            table[hash].add(elem);
            return true;
        }
    }

    /**
     * Removes the given element from the dictionary, if it is present.
     *
     * Complexity: O(1) expected time.
     *
     * @param elem An element to remove from the set.
     * @return true if the set contained the element, false otherwise.
     */
    @Override
    public boolean remove(T elem) {
        if (elem == null || elem.equals("")){
            return false;
        }

        int hash = Math.abs(elem.hashCode() % table.length);

        if (table[hash] != null && table[hash].contains(elem)){
            table[hash].remove(elem);
            size --;
            return true;
        }else{
            return false;
        }
    }


    /**
     * Check if an element is in the Set.
     *
     * Complexity: O(1) expected time.
     *
     * @param elem An element to look for.
     * @return true if the element is in the set, false otherwise.
     */
    @Override
    public boolean contains(T elem) {
        if (elem == null || elem .equals("")){
            return false;
        }
        int hash = Math.abs(elem.hashCode() % table.length);

        if (table[hash] != null && table[hash].contains(elem)){
            return true;
        }else{
            return false;
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        HashSet<?> hashSet = (HashSet<?>) o;
        return capacity == hashSet.capacity && size == hashSet.size && index == hashSet.index && Objects.equals(table, hashSet.table);
    }

    @Override
    public int hashCode() {
        return hash(capacity, size, index, table);
    }

    /**
     * Returns the number of elements in this set.
     *
     * Complexity: O(1) expected time.
     *
     * @return The amount of elements in this set.
     */
    @Override
    public int size() {
        return size;
    }
}

测试 class：

import org.junit.Test;
import org.junit.Before;
import static org.junit.Assert.*;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.CoreMatchers.*;

import java.util.Arrays;

/**
 * Test for the HashSet implementation of the Set interface. Runs both the
 * SetTest tests, as well as tests specific to hashing.
 *
 * This test class mostly contains only hash collision tests.
 */
public class HashSetTest extends SetTest {
    private Set<SingleHashUnequal> set;
    private SingleHashUnequal[] uniqueObjsWithEqualHashes;

    /**
     * Returns an implementation of Set that can hold at least 'minCapacity'
     * Integers.
     *
     * @param minCapacity The least amount of elements the Set must be able to
     * hold.
     * @return An implementation of Set.
     */
    @Override
    protected Set<Integer> getIntegerSet(int minCapacity) {
        return new HashSet<Integer>(minCapacity);
    }

    @Override
    @Before
    public void setUp() {
        // We are overriding the setUp method of SetTest, so we need to call
        // it explicitly to not break everything.
        super.setUp();

        int numDummies = 10;
        uniqueObjsWithEqualHashes = new SingleHashUnequal[numDummies];
        set = new HashSet<SingleHashUnequal>(numDummies * 2);
        for (int i = 0; i < numDummies; i++) {
            SingleHashUnequal dummy = new SingleHashUnequal();
            set.add(dummy);
            uniqueObjsWithEqualHashes[i] = dummy;
        }
    }

    
    @Test
    public void addUniqueElementsWithEqualHashesIncrementsSize() {
        // Arrange
        int capacity = uniqueObjsWithEqualHashes.length;
        Set<SingleHashUnequal> set = new HashSet<SingleHashUnequal>(capacity);
        int expectedSize = 0;
        for (SingleHashUnequal elem : uniqueObjsWithEqualHashes) {
            expectedSize++;
            // Act
            set.add(elem);
            // Assert
            assertThat(set.size(), equalTo(expectedSize));
        }
    }

  
    /**
     * A helper class for testing hash collisions. Instances equal only
     * themselves, and all instances have the same hashCode.
     */
    private static class SingleHashUnequal {
        private static final int HASH = 0;

        @Override
        public boolean equals(Object o) {

            return this == o;
        }

        @Override
        public int hashCode() {
            return HASH;
        }
    }
}

/**
 * An interface describing a generic set. Duplicates are not allowed.
 */
public interface Set<T> {

    boolean add(T elem);

    boolean remove(T elem);

    boolean contains(T elem);
  
    int size();
}

Answer 1

我认为您缺少size++; 在else分支中

        if (table[hash].contains(elem)){
            return false;
        }else{
            table[hash].add(elem);
            return true;
        }

在您的add方法中。