complete

src/main/java/MyArrayList.java

@@ -4,7 +4,7 @@ import java.util.Collection;
 
 public class MyArrayList<T> implements Cloneable{
 
-    private T[] inputArray;
+    protected T[] inputArray;
     private int capacity;
     private Integer size;
 

src/main/java/MyMap.java

@@ -0,0 +1,133 @@
+import java.util.*;
+
+public class MyMap<K,V>  {
+    MySet<Node<K,V>>[] bucket = new MySet[15];
+
+    public MyMap(){
+        for (int i=0; i<bucket.length; i++)
+            bucket[i] = new MySet<>();
+    }
+
+    public int size() {
+        int size = 0;
+        for (MySet m:bucket){
+            size += m.size();
+        }
+        return size;
+    }
+
+    public boolean isEmpty() {
+        for (MySet m:bucket){
+            if (!m.isEmpty())
+                return false;
+        }
+        return true;
+    }
+
+    public boolean containsKey(K key) {
+        for (Node<K,V> n : bucket[bucketIndex(key)])
+            if (n.getKey().equals(key))
+                return true;
+        return false;
+    }
+
+    public boolean containsValue(V value) {
+        for (int i = 0; i < 15; i++) {
+            for (Node<K, V> n : bucket[i])
+                if (n.getValue().equals(value))
+                    return true;
+        }
+        return false;
+    }
+
+    public V get(K key) {
+        for (Node<K,V> n : bucket[bucketIndex(key)])
+            if (n.getKey().equals(key))
+                return n.getValue();
+        return null;
+    }
+
+    public V put(K key, V value) {
+        for (Node<K,V> n : bucket[bucketIndex(key)]){
+            if (n.getKey().equals(key))
+                return n.setValue(value);
+            else if(n.hash == key.hashCode() && !n.getKey().equals(key))
+                n.next = new Node<>(key.hashCode(),key,value,null);
+        }
+
+        bucket[bucketIndex(key)].add(new Node<>(key.hashCode(), key, value, null));
+        return value;
+    }
+
+    public V remove(K key) {
+        for (Node<K,V> n : bucket[bucketIndex(key)])
+            if (n.getKey().equals(key)) {
+                bucket[bucketIndex(key)].remove(n);
+                return n.getValue();
+            }
+        return null;
+    }
+
+    public void putAll(Map<? extends K, ? extends V> m) {
+        m.forEach(this::put);
+    }
+
+    public void clear() {
+        for (MySet m : bucket){
+            m.clear();
+        }
+    }
+
+    public MySet<K> keySet() {
+        MySet<K> ks = new MySet<>();
+        for (MySet<Node<K,V>> m : bucket)
+            m.forEach(e -> ks.add(e.getKey()));
+        return ks;
+    }
+
+    public Collection<V> values() {
+        List<V> l = new ArrayList<>();
+        for (MySet<Node<K,V>> m : bucket)
+            m.forEach(e -> l.add(e.getValue()));
+        return l;
+    }
+
+    public MySet<Map.Entry<K, V>> entrySet() {
+        MySet<Map.Entry<K,V>> set = new MySet<>();
+        for (MySet<Node<K,V>> m : bucket)
+            m.forEach(set::add);
+        return set;
+    }
+
+    protected static class Node<K,V> implements Map.Entry<K, V> {
+        final K key;
+        V value;
+        Node<K,V> next;
+        final int hash;
+
+        Node(int hash, K key, V value, Node<K,V> next){
+            this.key = key;
+            this.value = value;
+            this.next = next;
+            this.hash = hash;
+        }
+
+        public K getKey() {
+            return key;
+        }
+
+        public V getValue() {
+            return value;
+        }
+
+        public V setValue(V value) {
+            V oldValue = this.value;
+            this.value = value;
+            return oldValue;
+        }
+    }
+
+    private int bucketIndex(K key){
+        return Math.abs(key.hashCode()) % bucket.length;
+    }
+}

src/main/java/MySet.java

@@ -1,8 +1,9 @@
 import java.util.Collection;
+import java.util.ConcurrentModificationException;
 import java.util.Iterator;
-import java.util.function.Consumer;
+import java.util.NoSuchElementException;
 
-public class MySet<T> implements Cloneable{
+public class MySet<T> implements Cloneable, Iterable<T>{
     MyArrayList<T> mySet;
 
     public MySet(){
@@ -69,45 +70,39 @@ public class MySet<T> implements Cloneable{
     }
 
     public Iterator<T> iterator(){
-
-        return null;
+        return new Iterator<T>() {
+            int cursor;
+            int lastRet = -1;
+
+            @Override
+            public boolean hasNext() {
+                return cursor != size();
+            }
+
+            @Override
+            public T next() {
+                int i = cursor;
+                if (i >= size())
+                    throw new NoSuchElementException();
+                T[] inputArray = mySet.inputArray;
+                if (i >= inputArray.length)
+                    throw new ConcurrentModificationException();
+                cursor = i + 1;
+                return inputArray[lastRet = i];
+            }
+        };
     }
 
     public boolean removeAll(Collection<T> c){
-
-        return false;
+        c.forEach(this::remove);
+        return true;
     }
 
     public boolean retainAll(Collection<T> c){
-
-        return false;
-    }
-
-    private class Itr implements Iterator<T> {
-        int cursor;
-        int lastRet = -1;
-
-        Itr(){}
-
-        @Override
-        public boolean hasNext() {
-            return cursor!= size();
-        }
-
-        @Override
-        public T next() {
-            return null;
-        }
-
-        @Override
-        public void remove() {
-
-        }
-
-        @Override
-        public void forEachRemaining(Consumer<? super T> action) {
-
-        }
+        for (T t:mySet.inputArray)
+            if (!c.contains(t))
+                mySet.remove(t);
+        return true;
     }
 
 }

src/test/java/MyMapTest.java

@@ -0,0 +1,89 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MyMapTest {
+    MyMap<String, Integer> myMap = new MyMap<>();
+
+    @Test
+    public void testPut(){
+        myMap.put("One", 1);
+        Assert.assertNotNull(myMap);
+    }
+    @Test
+    public void testSize(){
+        myMap.put("One", 1);
+        int actual = myMap.size();
+        Assert.assertEquals(1, actual);
+    }
+
+    @Test
+    public void testIsEmpty(){
+        Assert.assertTrue(myMap.isEmpty());
+    }
+
+    @Test
+    public void testContainsKey(){
+        myMap.put("One",1);
+        Assert.assertTrue(myMap.containsKey("One"));
+    }
+
+    @Test
+    public void testContainsValue(){
+        myMap.put("One",1);
+        Assert.assertTrue(myMap.containsValue(1));
+    }
+
+    @Test
+    public void testGet(){
+        myMap.put("One",1);
+        Integer expected = 1;
+        Assert.assertEquals(expected, myMap.get("One"));
+    }
+
+    @Test
+    public void testRemove(){
+        myMap.put("One",1);
+        myMap.remove("One");
+        Assert.assertEquals(0, myMap.size());
+    }
+
+    @Test
+    public void testPutAll(){
+        Map<String, Integer> map = new HashMap<>();
+        map.put("Two", 2);
+        map.put("Three", 3);
+        myMap.putAll(map);
+        Assert.assertEquals(2, myMap.size());
+    }
+
+    @Test
+    public void testClear(){
+        myMap.put("One", 1);
+        myMap.clear();
+        Assert.assertEquals(0, myMap.size());
+    }
+
+    @Test
+    public void testKeySet(){
+        myMap.put("One", 1);
+        myMap.put("Two", 2);
+        Assert.assertEquals("Two", myMap.keySet().get(1));
+    }
+
+    @Test
+    public void testValues(){
+        myMap.put("One", 1);
+        myMap.put("Two", 2);
+        Assert.assertEquals(2, myMap.values().size());
+    }
+
+    @Test
+    public void testEntrySet(){
+        myMap.put("One", 1);
+        myMap.put("Two", 2);
+        Assert.assertEquals("Two", myMap.entrySet().get(1).getKey());
+    }
+}

src/test/java/MySetTest.java

@@ -141,12 +141,12 @@ public class MySetTest {
     }
 
     @Test
-    public void iterator() {
+    public void testIterator() {
         Assert.assertNotNull(ms.iterator());
     }
 
     @Test
-    public void iteratorHasNext() {
+    public void testIteratorHasNext() {
         ms.add(1);
         ms.add(3);
         ms.add(2);
@@ -158,4 +158,38 @@ public class MySetTest {
         Assert.assertEquals(three,it.next());
         Assert.assertEquals(two,it.next());
     }
+
+    @Test
+    public void testRemoveAll(){
+        ms.add(1);
+        ms.add(3);
+        ms.add(2);
+
+        List<Integer> l = new ArrayList<>();
+        l.add(3);
+        l.add(2);
+        l.add(5);
+
+        ms.removeAll(l);
+
+        Integer expected = 1;
+        Assert.assertEquals(expected,ms.size());
+    }
+
+    @Test
+    public void testRetainAll(){
+        ms.add(1);
+        ms.add(3);
+        ms.add(2);
+        ms.add(4);
+
+        List<Integer> l = new ArrayList<>();
+        l.add(3);
+        l.add(2);
+        l.add(5);
+
+        ms.retainAll(l);
+        Integer expected = 2;
+        Assert.assertEquals(expected, ms.size());
+    }
 }