finished

src/main/java/MapFunc/MapFunc.java

@@ -4,9 +4,21 @@ import java.util.ArrayList;
 import java.util.function.Function;
 
 /**
- * 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.
+ * 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 {
-
+// type R bc it could return a different type but could be the same
+    public static <T, R> ArrayList map(ArrayList<T> input, Function<T, R> myFunction) {
+        //create new arraylist
+        ArrayList<R> mappedArrayList = new ArrayList<>();
+        for (int i = 0; i < input.size(); i++) {
+            R element = myFunction.apply(input.get(i));
+            mappedArrayList.add(element);
+        }
+        return mappedArrayList;
+    }
 }
+

src/main/java/Pair/Arrays.java

@@ -1,16 +1,35 @@
-//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) {
-//    }
-//}
+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 <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> arrayList){
+        Collections.sort(arrayList);
+        return arrayList.get(0);
+    }
+
+    public static <E extends Comparable> E max(ArrayList<E> arrayList){
+        Collections.sort(arrayList);
+        return arrayList.get(arrayList.size() - 1);
+    }
+
+    public static <E extends Comparable> Pair<E> minMax (ArrayList<E> arrayList){
+        Collections.sort(arrayList);
+        //return new Pair<E>(arrayList.get(0), arrayList.get(arrayList.size() - 1));
+        return firstLast(arrayList);
+    }
+}

src/main/java/Pair/Pair.java

@@ -1,12 +1,43 @@
 package Pair;
 
 /**
- * You need to store two values of type `E`, set them in a constructor, and have the following methods,
+ * 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 {
+public class Pair<E extends Comparable> {
+
+    private E firstValue;
+    private E secondValue;
+
+    public Pair(E first, E second){
+        this.firstValue = first;
+        this.secondValue = second;
+    }
+
+    public E getFirst(){
+        return this.firstValue;
+    }
+
+    public E getSecond(){
+        return this.secondValue;
+    }
+    public E min(){
+        if (firstValue.compareTo(secondValue) == 1){
+            return secondValue;
+        }
+        return firstValue;
+    }
+
+    public E max(){
+        if (firstValue.compareTo(secondValue) == -1){
+            return secondValue;
+        }
+        return firstValue;
+    }
+
 
 }

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