Added the third assignment.

README.md

 `isEmpty` functions.
 2. StackArray -- Implement `Stack<E>` to use an array as a stack.  You'll need to potentially grow the array in the 
 `push` method.  Do this first with an `E[]` array, and then again with an `Object[]` array.  Both should compile
-without warnings and pass the tests.
+without warnings and pass the tests.
+3. Table -- Implemented for you is Entry<K, V>.  
+Implement Table<K,V> so that it manages an ArrayList of Entry<K,V>.  You must implement
+    * `get` which takes a key and returns either the entry from the ArrayList with that key, or null if none is found.
+    * `put` which takes a key and value and sets the value in the ArrayList to Entry(key, value);
+        * Remember, a key point to exactly one value
+    * `remove` which takes a key and removes it from the ArrayList if it's in there.  It's a void method; no return type.
+4.

src/main/java/Table/Entry.java

+package Table;
+
+public class Entry<K, V> {
+    private K key;
+    private V value;
+
+    public Entry(K key, V value) {
+        this.key = key;
+        this.value = value;
+    }
+
+    public K getKey() {
+        return key;
+    }
+
+    public V getValue() {
+        return value;
+    }
+
+}

src/main/java/Table/Table.java

+package Table;
+
+import java.util.ArrayList;
+
+/**
+ * This class needs to manage an ArrayList of Entry objects.  It needs a get method that takes a key and returns
+ * its corresponding value, or null of the key is not in the arraylist.  It needs a put method that takes a key and value
+ * and makes an entry with key, value.  NOTE: There cannot be two entries with the same key.
+ * It also needs a remove method which takes a key and, if that key exists in the arraylist, removes that item.
+ * Void return on `remove`.
+ */
+public class Table<K, V> {
+    private ArrayList entries;
+
+    public Table() {
+    }
+}

src/test/java/Table/TableTest.java

+//package Table;
+//
+//import org.junit.Assert;
+//import org.junit.Test;
+//
+//public class TableTest {
+//    @Test
+//    public void testGetWithoutAnItemReturnsNull() throws Exception {
+//        // Given an empty table
+//        Table<String, Integer> table = new Table<String, Integer>();
+//        // When we try and get an item then it returns null
+//        Assert.assertEquals(table.get("foo"), null);
+//    }
+//
+//    @Test
+//    public void testPutAnItemReturnsAndDoesNotDelete() throws Exception {
+//        //Given an empty table
+//        Table<String, Integer> table = new Table<String, Integer>();
+//        // When we put an item in it
+//        table.put("foo", 1);
+//        // Then we should be able to get it's value
+//        Assert.assertEquals(table.get("foo"), new Integer(1));
+//        // And then we should be able to get it again as it wasn't removed
+//        Assert.assertEquals(table.get("foo"), new Integer(1));
+//    }
+//
+//    @Test
+//    public void testOverwritingAnItem() throws Exception {
+//        //Given an empty table
+//        Table<String, Integer> table = new Table<String, Integer>();
+//        // When we put an item in it
+//        table.put("foo", 1);
+//        // And we put a new value with the same key
+//        table.put("foo", 2);
+//        // Then we should get back the new value
+//        Assert.assertEquals(table.get("foo"), new Integer(2));
+//    }
+//
+//    @Test
+//    public void testRemoveAnItem() throws Exception {
+//        //Given an empty table
+//        Table<String, Integer> table = new Table<String, Integer>();
+//        // When we put an item in it
+//        table.put("foo", 1);
+//        // And we remove that item
+//        table.remove("foo");
+//        // Then we should get back null for that balue
+//        Assert.assertEquals(table.get("foo"), null);
+//    }
+//}