Done, yay collections

src/main/java/ArrayListCombiner/ArrayListCombiner.java

@@ -1,7 +1,9 @@
 package ArrayListCombiner;
 
+
 import java.util.ArrayList;
 
+
 /**
  * Create two generic methods that take two arraylists.  The methods should both append the second ArrayList's items,
  * to the first.  Use a wildcard for one of the type arguments in each method.
@@ -11,12 +13,11 @@ import java.util.ArrayList;
 public class ArrayListCombiner {
 
 
-
-    public void superCombiner(){
-
+    public static <T> void superCombiner(ArrayList<? super T> first, ArrayList<T> second){
+        first.addAll(second);
     }
-    public void extendCombiner(){
-
+    public static <T> void extendCombiner(ArrayList<T> first, ArrayList<? extends T> second){
+        first.addAll(second);
     }
 
 }

src/main/java/MapFunc/MapFunc.java

@@ -9,4 +9,13 @@ import java.util.function.Function;
  */
 public class MapFunc {
 
+
+    public static <T,R> ArrayList map(ArrayList<T> list, Function<T, R> object){
+        ArrayList<R> newList = new ArrayList<>();
+        for(T t : list){
+        newList.add(object.apply(t));
+        }
+        return newList;
+    }
+
 }

src/main/java/Pair/Arrays.java

@@ -1,5 +1,7 @@
 package Pair;
 
+import org.omg.CORBA.CODESET_INCOMPATIBLE;
+
 import java.util.ArrayList;
 import java.util.Collections;
 
@@ -10,7 +12,24 @@ import java.util.Collections;
  * A max method that returns the largest item in the arraylist
  * And a minmax method that returns a pair containing the largest and smallest items from the array list
  */
-public class Arrays {
-//    public static <___> Pair<E> firstLast(ArrayList<___> a) {
-//    }
+public class Arrays{
+
+    public static <E extends Comparable> Pair<E> firstLast(ArrayList<E> a) {
+        return new Pair<E>(a.get(0), a.get(a.size()-1));
+    }
+
+    public static <E extends Comparable> E min(ArrayList<E> a){
+        Collections.sort(a);
+        return a.get(0);
+    }
+    public static <E extends Comparable> E max(ArrayList<E> a){
+        Collections.sort(a);
+        return a.get(a.size()-1);
+    }
+    public static <E extends Comparable> Pair<E> minMax(ArrayList<E> a){
+        Collections.sort(a);
+        return new Pair<E>(a.get(0), a.get(a.size()-1));
+    }
+
 }
+

src/main/java/Pair/Pair.java

@@ -1,5 +1,6 @@
 package Pair;
 
+
 /**
  * You need to store two values of type `E`, set them in a constructor, and have the following methods,
  * getFirst
@@ -7,6 +8,41 @@ package Pair;
  * min -> returns the minimum of the pair
  * max -> returns the maximum of the pair
  */
-public class Pair {
+public class Pair<E extends Comparable>{
+
+    private E first;
+    private E second;
+    Pair<E> p;
+
+    public Pair(E first, E second) {
+
+        this.first = first;
+        this.second = second;
+    }
+
+    public E getFirst() {
+        return first;
+    }
+
+    public E getSecond() {
+        return second;
+    }
+    public E min(){
+        int result = compareTo(first);
+        boolean secondIsGreater = result == -1;
+        if(secondIsGreater){
+            return second;
+        }else return first;
+    }
 
+    public E max(){
+        int result = compareTo(first);
+        boolean secondIsGreater = result == 1;
+        if(secondIsGreater){
+            return first;
+        }else return second;
+    }
+    public int compareTo(E e){
+        return this.first.compareTo(e);
+    }
 }

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));
+    }
+
+}

src/test/java/Pair/ArraysTest.java

@@ -1,74 +1,74 @@
-//package Pair;
-//
-//import org.junit.Assert;
-//import org.junit.Test;
-//
-//import java.util.ArrayList;
-//
-//public class ArraysTest {
-//    @Test
-//    public void firstLast() throws Exception {
-//        // Given an ArrayList of Integers
-//        ArrayList<Integer> al = new ArrayList<>();
-//        al.add(1);
-//        al.add(5);
-//        al.add(3);
-//        al.add(4);
-//        al.add(2);
-//        al.add(0);
-//        al.add(1000);
-//        // When firstLast is called
-//        Pair<Integer> result = Arrays.firstLast(al);
-//        // Then it should return the first and last items
-//        Assert.assertEquals(new Integer(1), result.getFirst());
-//        Assert.assertEquals(new Integer(1000), result.getSecond());
-//    }
-//
-//    @Test
-//    public void testMin() throws Exception {
-//        // Given an ArrayList of Integers
-//        ArrayList<Integer> al = new ArrayList<>();
-//        al.add(1);
-//        al.add(5);
-//        al.add(3);
-//        al.add(4);
-//        al.add(2);
-//        al.add(0);
-//        al.add(1000);
-//        // When min is called assert that it gets the smallest item
-//        Assert.assertEquals(new Integer(0), Arrays.min(al));
-//    }
-//
-//    @Test
-//    public void testMax() throws Exception {
-//        // Given an ArrayList of Integers
-//        ArrayList<Integer> al = new ArrayList<>();
-//        al.add(1);
-//        al.add(5);
-//        al.add(3);
-//        al.add(4);
-//        al.add(2);
-//        al.add(0);
-//        al.add(1000);
-//        // When min is called assert that it gets the largest item
-//        Assert.assertEquals(new Integer(1000), Arrays.max(al));
-//    }
-//
-//    @Test
-//    public void testMinMax() throws Exception {
-//        // Given an ArrayList of Integers
-//        ArrayList<Integer> al = new ArrayList<>();
-//        al.add(1);
-//        al.add(5);
-//        al.add(3);
-//        al.add(4);
-//        al.add(2);
-//        al.add(0);
-//        al.add(1000);
-//        // When minMax is called
-//        Pair<Integer> result = Arrays.minMax(al);
-//        // Then it should return the first and last items
-//        Assert.assertEquals(new Integer(0), result.min());
-//        Assert.assertEquals(new Integer(1000), result.max());
-//    }
-//}
+package Pair;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class ArraysTest {
+    @Test
+    public void firstLast() throws Exception {
+        // Given an ArrayList of Integers
+        ArrayList<Integer> al = new ArrayList<>();
+        al.add(1);
+        al.add(5);
+        al.add(3);
+        al.add(4);
+        al.add(2);
+        al.add(0);
+        al.add(1000);
+        // When firstLast is called
+        Pair<Integer> result = Arrays.firstLast(al);
+        // Then it should return the first and last items
+        Assert.assertEquals(new Integer(1), result.getFirst());
+        Assert.assertEquals(new Integer(1000), result.getSecond());
+    }
+
+    @Test
+    public void testMin() throws Exception {
+        // Given an ArrayList of Integers
+        ArrayList<Integer> al = new ArrayList<>();
+        al.add(1);
+        al.add(5);
+        al.add(3);
+        al.add(4);
+        al.add(2);
+        al.add(0);
+        al.add(1000);
+        // When min is called assert that it gets the smallest item
+        Assert.assertEquals(new Integer(0), Arrays.min(al));
+    }
+
+    @Test
+    public void testMax() throws Exception {
+        // Given an ArrayList of Integers
+        ArrayList<Integer> al = new ArrayList<>();
+        al.add(1);
+        al.add(5);
+        al.add(3);
+        al.add(4);
+        al.add(2);
+        al.add(0);
+        al.add(1000);
+        // When min is called assert that it gets the largest item
+        Assert.assertEquals(new Integer(1000), Arrays.max(al));
+    }
+
+    @Test
+    public void testMinMax() throws Exception {
+        // Given an ArrayList of Integers
+        ArrayList<Integer> al = new ArrayList<>();
+        al.add(1);
+        al.add(5);
+        al.add(3);
+        al.add(4);
+        al.add(2);
+        al.add(0);
+        al.add(1000);
+        // When minMax is called
+        Pair<Integer> result = Arrays.minMax(al);
+        // Then it should return the first and last items
+        Assert.assertEquals(new Integer(0), result.min());
+        Assert.assertEquals(new Integer(1000), result.max());
+    }
+}

src/test/java/Pair/PairTest.java

@@ -1,32 +1,32 @@
-//package Pair;
-//
-//import org.junit.Test;
-//import org.junit.Assert;
-//
-//public class PairTest {
-//
-//    @Test
-//    public void testGetters() throws Exception {
-//        // Given a pair with "Foo" and "Bar"
-//        Pair<String> p = new Pair<String>("Foo", "Bar");
-//        // When getFirst and getSecond are called, they should be returned.
-//        Assert.assertEquals("Foo", p.getFirst());
-//        Assert.assertEquals("Bar",  p.getSecond());
-//    }
-//
-//    @Test
-//    public void testMin() throws Exception {
-//        // Given a pair with two values
-//        Pair<Double> p = new Pair<Double>(1.23, 2.34);
-//        // When p.min() is called, the smallest should be returned.
-//        Assert.assertEquals(new Double(1.23), p.min());
-//    }
-//
-//    @Test
-//    public void testMax() throws Exception {
-//        // Given a pair with two values
-//        Pair<Double> p = new Pair<Double>(1.23, 2.34);
-//        // When p.max() is called, the largest should be returned.
-//        Assert.assertEquals(new Double(2.34), p.max());
-//    }
-//}
+package Pair;
+
+import org.junit.Test;
+import org.junit.Assert;
+
+public class PairTest {
+
+    @Test
+    public void testGetters() throws Exception {
+        // Given a pair with "Foo" and "Bar"
+        Pair<String> p = new Pair<String>("Foo", "Bar");
+        // When getFirst and getSecond are called, they should be returned.
+        Assert.assertEquals("Foo", p.getFirst());
+        Assert.assertEquals("Bar",  p.getSecond());
+    }
+
+    @Test
+    public void testMin() throws Exception {
+        // Given a pair with two values
+        Pair<Double> p = new Pair<Double>(1.23, 2.34);
+        // When p.min() is called, the smallest should be returned.
+        Assert.assertEquals(new Double(1.23), p.min());
+    }
+
+    @Test
+    public void testMax() throws Exception {
+        // Given a pair with two values
+        Pair<Double> p = new Pair<Double>(1.23, 2.34);
+        // When p.max() is called, the largest should be returned.
+        Assert.assertEquals(new Double(2.34), p.max());
+    }
+}