Added the last lab.

README.md

@@ -19,5 +19,14 @@ tests, not the code.
 6. ArrayListCombiner -- Write two methods, `superCombiner` and `extendCombiner`, which each take two arraylists and append
 all of the items from the second to the first.  `superCombiner` should use `? super E` and `extendCombiner` should use 
 `? extends E`.
-7. 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.
+7. 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.
+8. Pair -- This is a multi-step one:
+    1. Create a Pair<E> that stores a pair of elements of type `E`.
+    2. Create two methods, `min` and `max`, that return the largest and smallest of the `Pair`.
+    3. Create a utility class called `Arrays` and, in that, create a method
+    <br>`public static <___> Pair<E> firstLast(ArrayList<___> a)`<br>
+    That returns a Pair containing the first and last element of the array.  <br>NOTE: The `<___>` is there because you
+    need to fill in the blank.
+    4. In `Arrays` make two methods, `min` and `max` that returns the smallest and largest elements in the ArrayList.
+    5. In `Arrays` make a `minMax` function that returns a `Pair` with the minimum and maximum values of the ArrayList.

src/main/java/Pair/Arrays.java

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,12 @@
+package Pair;
+
+/**
+ * You need to store two values of type `E`, set them in a constructor, and have the following methods,
+ * getFirst
+ * getSecond
+ * min -> returns the minimum of the pair
+ * max -> returns the maximum of the pair
+ */
+public class Pair {
+
+}

src/test/java/Pair/ArraysTest.java

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

src/test/java/Pair/PairTest.java

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