Swap, Table, TableNested

src/main/java/Pair/Arrays.java

@@ -2,7 +2,6 @@ package Pair;
 
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.Comparator;
 
 /**
  * In here you must make firstLast, which will return a pair of the first element in the array list and the last

src/main/java/StackArray/ObjectStack.java

@@ -11,5 +11,6 @@ import StackArrayList.Stack;
 public class ObjectStack<E> extends Stack<E> {
     private Object[] elements;
 
-    public ObjectStack() {}
+    public ObjectStack() {
+    }
 }

src/main/java/StackArrayList/Stack.java

@@ -11,7 +11,7 @@ public class Stack<E> {
     private List<E> elements;
 
 
-    public Stack(){
+    public Stack() {
         elements = new ArrayList<>();
     }
 
@@ -20,7 +20,7 @@ public class Stack<E> {
     }
 
     public E pop() {
-        return elements.remove(elements.size()-1);
+        return elements.remove(elements.size() - 1);
     }
 
     public boolean isEmpty() {

src/main/java/Table/Table.java

@@ -1,6 +1,7 @@
 package Table;
 
-import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
 
 /**
  * This class needs to manage an ArrayList of Entry objects.  It needs a get method that takes a key and returns
@@ -10,8 +11,21 @@ import java.util.ArrayList;
  * Void return on `remove`.
  */
 public class Table<K, V> {
-    private ArrayList entries;
+    private Map<K, V> entries;
 
     public Table() {
+        entries = new HashMap<>();
+    }
+
+    public V get(K key) {
+        return entries.get(key);
+    }
+
+    public void put(K key, V value) {
+        entries.put(key, value);
+    }
+
+    public void remove(K key) {
+        entries.remove(key);
     }
 }

src/main/java/TableNested/TableNested.java

@@ -1,11 +1,28 @@
 package TableNested;
 
-import java.util.ArrayList;
+import Table.Table;
 
 /**
  * All you need to do for this microlab is take the Table and Entry from the last one and make Entry a nested class.
  * Think about how nested classes should work with generics.
  */
-public class TableNested<K, V> {
+public class TableNested<K, V> extends Table<K, V> {
+    private 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/test/java/Swap/SwapTest.java

@@ -1,16 +1,16 @@
 package Swap;
-//
-//import org.junit.Assert;
-//import org.junit.Test;
-//
-///**
-// * Get the tests passing.
-// */
-//public class SwapTest {
-//    @Test
-//    public void testSwap() throws Exception {
-//        Double[] result = Swap.swap(0,1, 1.5, 2,3);
-//        Double[] expected = {2.0, 1.5, 3.0};
-//        Assert.assertArrayEquals(expected, result);
-//    }
-//}
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Get the tests passing.
+ */
+public class SwapTest {
+    @Test
+    public void testSwap() throws Exception {
+        Double[] result = Swap.<Double>swap(0, 1, 1.5, 2.0, 3.0);
+        Double[] expected = {2.0, 1.5, 3.0};
+        Assert.assertArrayEquals(expected, result);
+    }
+}

src/test/java/Table/TableTest.java

@@ -1,50 +1,50 @@
-//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);
-//    }
-//}
+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<>();
+        // 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<>();
+        // 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<>();
+        // 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);
+    }
+}

src/test/java/TableNested/TableNestedTest.java

@@ -1,50 +1,50 @@
-//package TableNested;
-//
-//import org.junit.Assert;
-//import org.junit.Test;
-//
-//public class TableNestedTest {
-//    @Test
-//    public void testGetWithoutAnItemReturnsNull() throws Exception {
-//        // Given an empty table
-//        TableNested<String, Integer> table = new TableNested<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
-//        TableNested<String, Integer> table = new TableNested<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
-//        TableNested<String, Integer> table = new TableNested<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
-//        TableNested<String, Integer> table = new TableNested<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);
-//    }
-//}
+package TableNested;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TableNestedTest {
+    @Test
+    public void testGetWithoutAnItemReturnsNull() throws Exception {
+        // Given an empty table
+        TableNested<String, Integer> table = new TableNested<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
+        TableNested<String, Integer> table = new TableNested<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
+        TableNested<String, Integer> table = new TableNested<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
+        TableNested<String, Integer> table = new TableNested<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);
+    }
+}