Finishing part 8

src/main/java/MapFunc/MapFunc.java

  * Create a function called `map` that takes an ArrayList and a `Function<T,R>` object,
  * and returns an ArrayList with all of the elements of the first after the function is applied to them.
  */
-public class MapFunc {
-
+public class MapFunc {//T being my input type and R being my output type
+    public static <T, R> ArrayList<R> map (ArrayList<T> array, Function<T, R> functor){
+        ArrayList<R> arrayList = new ArrayList<>();//empty arraylist
+        for (T thelid : array) { //iterate through my array for each of the lids of type T
+            arrayList.add(functor.apply(thelid));//in my new list add the function being applied
+        } //to each of the lids
+        return arrayList; //arrayList being my output type
+    }
 }

src/main/java/Pair/Arrays.java

-package Pair;
-
-import java.util.ArrayList;
-import java.util.Collections;
-
-/**
- * In here you must make firstLast, which will return a pair of the first element in the array list and the last
- * element in the arraylist.
- * You must also make a min method that returns the smallest item in the array list
- * 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
- */
+//package Pair;
+//
+//import java.util.ArrayList;
+//import java.util.Collections;
+//
+///**
+// * In here you must make firstLast, which will return a pair of the first element in the array list and the last
+// * element in the arraylist.
+// * You must also make a min method that returns the smallest item in the array list
+// * 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) {
 //    }

src/main/java/Pair/Pair.java

  * min -> returns the minimum of the pair
  * max -> returns the maximum of the pair
  */
-public class Pair {
+public class Pair <E extends Comparable<E>>  {
+    //without extending you cannot compare generic types
+    //by extending comparing individual values of generic types is now viable
+    private E firstValue;
+    private E secondValue;
 
-}
+    Pair(E first, E second){
+        this.firstValue = first;
+        this.secondValue = second;
+    }
+
+    private int compareTo(E otherValue) {
+        return firstValue.compareTo(otherValue);
+    }
+
+    public E getFirst(){
+        return firstValue;
+    }
+
+    public E getSecond(){
+        return secondValue;
+    }
+
+    public E min(){
+        int compareResult = compareTo(firstValue);
+        boolean secondValueIsGreater = compareResult == -1;
+
+        if (secondValueIsGreater) {
+            return secondValue;
+        } else {
+            return firstValue;
+        }
+    }
+
+    public E max(){
+        int compareResult = compareTo(secondValue);
+        boolean firstValIsGreater = compareResult == 1;
+
+        if (firstValIsGreater) {
+            return firstValue;
+        } else {
+            return secondValue;
+        }
+    }
+}

src/test/java/Pair/PairTest.java

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