refactored arraylistcombiner to meet requirements and completed mapfunc

src/main/java/ArrayListCombiner/ArrayListCombiner.java

@@ -14,7 +14,7 @@ public class ArrayListCombiner {
         first.addAll(second);
     }
 
-    public static <E> void superCombiner (ArrayList<E> first, ArrayList<? extends E> second){
+    public static <E> void superCombiner (ArrayList<? super E> first, ArrayList<E> second){
         first.addAll(second);
     }
 }
@@ -24,4 +24,7 @@ public class ArrayListCombiner {
 //        append all of the items from the second to the first. superCombiner should use ? super E and extendCombiner
 //        should use ? extends E.
 
+//All the tests pass with this as the superCombiner but it's not done as asked
+//public static <E> void superCombiner (ArrayList<E> first, ArrayList<? extends E> second){
+//        first.addAll(second);
 

src/main/java/MapFunc/MapFunc.java

@@ -9,4 +9,17 @@ import java.util.function.Function;
  */
 public class MapFunc {
 
+    public static <T, R> ArrayList<R> map(ArrayList<T> arr, Function<T, R> mapfunc) {
+        ArrayList outputArray = new ArrayList<>();
+        for (T val : arr) {
+            R applyFuncVal = mapfunc.apply(val);
+            outputArray.add(applyFuncVal);
+        }
+        return outputArray;
+    }
+
 }
+
+//MapFunc -- Make a map method that takes an ArrayList and a Function<T,R> object and returns an arraylist
+////        containing all of the elements of the first with the function applied to them.
+

src/test/java/MapFunc/MapFuncTest.java

@@ -1,36 +1,36 @@
-//package MapFunc;
-//
-//import MapFunc.MapFunc;
-//import org.junit.Test;
-//
-//import java.util.ArrayList;
-//import org.junit.Assert;
-//
-//public class MapFuncTest {
-//    @Test
-//    public void testSingleTypeMap() throws Exception {
-//        // Given an integer array list
-//        ArrayList<Integer> intList = new ArrayList<>();
-//        intList.add(1);
-//        intList.add(2);
-//        // When it's mapped with a function to double the value
-//        ArrayList<Integer> mappedList = MapFunc.map(intList, num -> num*2);
-//        // Then all the values are doubled
-//        Assert.assertEquals(new Integer(2), mappedList.get(0));
-//        Assert.assertEquals(new Integer(4), mappedList.get(1));
-//    }
-//
-//    @Test
-//    public void testMultipleTypeMap() throws Exception {
-//        // Given an integer array list
-//        ArrayList<Integer> intList = new ArrayList<>();
-//        intList.add(1);
-//        intList.add(2);
-//        // When it's mapped with to string
-//        ArrayList<String> mappedList = MapFunc.map(intList, num -> num.toString());
-//        // Then all the values are doubled
-//        Assert.assertEquals("1", mappedList.get(0));
-//        Assert.assertEquals("2", mappedList.get(1));
-//    }
-//
-//}
+package MapFunc;
+
+import MapFunc.MapFunc;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import org.junit.Assert;
+
+public class MapFuncTest {
+    @Test
+    public void testSingleTypeMap() throws Exception {
+        // Given an integer array list
+        ArrayList<Integer> intList = new ArrayList<>();
+        intList.add(1);
+        intList.add(2);
+        // When it's mapped with a function to double the value
+        ArrayList<Integer> mappedList = MapFunc.map(intList, num -> num*2);
+        // Then all the values are doubled
+        Assert.assertEquals(new Integer(2), mappedList.get(0));
+        Assert.assertEquals(new Integer(4), mappedList.get(1));
+    }
+
+    @Test
+    public void testMultipleTypeMap() throws Exception {
+        // Given an integer array list
+        ArrayList<Integer> intList = new ArrayList<>();
+        intList.add(1);
+        intList.add(2);
+        // When it's mapped with to string
+        ArrayList<String> mappedList = MapFunc.map(intList, num -> num.toString());
+        // Then all the values are doubled
+        Assert.assertEquals("1", mappedList.get(0));
+        Assert.assertEquals("2", mappedList.get(1));
+    }
+
+}