.gitignore

 /bin/
 .DS_Store
+.idea/
+*.iml
 

javafx/javafx.properties

+javafx.version=11.0.2
+javafx.runtime.version=11.0.2+1
+javafx.runtime.build=1

src/cse332/datastructures/containers/Item.java

 package cse332.datastructures.containers;
 
+import java.util.Objects;
+
 /**
  * Simple class to hold a piece of data and its value.
  * 
@@ -40,4 +42,18 @@ public class Item<K, V> {
     public String toString() {
         return this.key + "=" + this.value + "";
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Item<?, ?> item = (Item<?, ?>) o;
+        return Objects.equals(key, item.key) &&
+                Objects.equals(value, item.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(key, value);
+    }
 }

src/cse332/datastructures/trees/BinarySearchTree.java

@@ -13,7 +13,7 @@ import datastructures.worklists.ArrayStack;
  * BinarySearchTree implements the ComparableDictionary interface using a binary
  * search tree. Notice that the key type must be Comparable.
  */
-public class BinarySearchTree<K extends Comparable<K>, V>
+public class BinarySearchTree<K extends Comparable<? super K>, V>
         extends ComparableDictionary<K, V> {
     // The root of the BST. Root is null if and only if the tree is empty.
     protected BSTNode root;

src/cse332/interfaces/misc/ComparableDictionary.java

@@ -10,6 +10,6 @@ package cse332.interfaces.misc;
  *
  * @author Adam Blank
  */
-public abstract class ComparableDictionary<K extends Comparable<K>, V>
+public abstract class ComparableDictionary<K extends Comparable<? super K>, V>
         extends DeletelessDictionary<K, V> {
 }

src/datastructures/dictionaries/AVLTree.java

@@ -28,6 +28,6 @@ import cse332.datastructures.trees.BinarySearchTree;
  * 6. Do NOT override the toString method. It is used for grading.
  */
 
-public class AVLTree<K extends Comparable<K>, V> extends BinarySearchTree<K, V>  {
+public class AVLTree<K extends Comparable<? super K>, V> extends BinarySearchTree<K, V>  {
     // TODO: Implement me!
 }

src/datastructures/dictionaries/ChainingHashTable.java

@@ -3,7 +3,7 @@ package datastructures.dictionaries;
 import java.util.Iterator;
 import java.util.function.Supplier;
 
-import cse332.datastructures.containers.*;
+import cse332.datastructures.containers.Item;
 import cse332.exceptions.NotYetImplementedException;
 import cse332.interfaces.misc.DeletelessDictionary;
 import cse332.interfaces.misc.Dictionary;
@@ -15,10 +15,15 @@ import cse332.interfaces.misc.Dictionary;
  *    any key) or the number of inputs (i.e., it must grow as necessary).
  * 3. Your HashTable should rehash as appropriate (use load factor as
  *    shown in class!). 
- * 5. HashTable should be able to grow more than 200,000 elements.
+ * 5. HashTable should be able to resize its capacity to prime numbers for more 
+ *    than 200,000 elements. After more than 200,000 elements, it should 
+ *    continue to resize using some other mechanism.
  * 6. We suggest you hard code some prime numbers. You can use this
  *    list: http://primes.utm.edu/lists/small/100000.txt 
  *    NOTE: Do NOT copy the whole list!
+ * 7. When implementing your iterator, you should NOT copy every item to another
+ *    dictionary/list and return that dictionary/list's iterator. 
+
  */
 public class ChainingHashTable<K, V> extends DeletelessDictionary<K, V> {
     private Supplier<Dictionary<K, V>> newChain;