updated commit

src/main/java/MapFunc/MapFunc.java

@@ -1,5 +1,6 @@
 package MapFunc;
 
+import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.function.Function;
 
@@ -9,13 +10,13 @@ import java.util.function.Function;
  */
 public class MapFunc {
 
-    @FunctionalInterface
-    public interface Function<T, R> {
-        
-    }
-
 
-    public static <E implements Function<T, R>> void map(ArrayList<E>, Function<T, R>) {
 
+    public static <T, R> ArrayList<R> map(ArrayList<T> arr, Function<T, R> function) {
+        ArrayList<R> mapArr = new ArrayList<>();
+        for(int i = 0; i < arr.size(); i++) {
+            mapArr.add(function.apply(arr.get(i)));
+        }
+        return mapArr;
     }
 }

src/main/java/Pair/Arrays.java

@@ -10,7 +10,41 @@ 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<E> {
+
+
+
+    public static <E extends Comparable> Pair<E> firstLast(ArrayList<E> a) {
+        E first = a.get(0);
+        E last = a.get(a.size() - 1);
+        return new Pair<>(first, last);
+    }
+
+    public static <E extends Comparable>E min(ArrayList<E> a) {
+        E min = a.get(0);
+        for(int i = 1; i < a.size(); i++)
+            if(min.compareTo(a.get(i)) > 0) min = a.get(i);
+        return min;
+    }
+
+    public static <E extends Comparable>E max(ArrayList<E> a) {
+        E max = a.get(0);
+        for(int i = 1; i < a.size(); i++)
+            if(max.compareTo(a.get(i)) < 0) max = a.get(i);
+        return max;
+    }
+
+    public static <E extends Comparable> Pair<E> minMax(ArrayList<E> a) {
+        if (a == null || a.size() == 0) return null;
+        E min = a.get(0);
+        E max = a.get(0);
+        for(int i = 0; i < a.size(); i++) {
+            if (min.compareTo(a.get(i)) > 0) min = a.get(i);
+            if (max.compareTo(a.get(i)) < 0) max = a.get(i);
+        }
+        return new Pair<>(min, max);
+    }
+
+
+}
+

src/main/java/Pair/Pair.java

@@ -7,6 +7,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;
 
+    public Pair() {
+        first = null;
+        second = null;
+    }
+
+    public Pair(E first, E second) {
+        this.first = first;
+        this.second = second;
+    }
+
+    public E getFirst() { return first; }
+    public E getSecond() { return second; }
+
+    public void setFirst(E newValue) { this.first = newValue; }
+    public void setSecond(E newValue) { this.second = newValue; }
+
+    public <E> E min() {
+        first = getFirst();
+        second = getSecond();
+        if(first.compareTo(second) < second.compareTo(first)) {
+            return (E)first;
+        }
+        return (E)second;
+    }
+
+    public <E> E max() {
+        first = getFirst();
+        second = getSecond();
+        if(first.compareTo(second) > second.compareTo(first)) {
+            return (E) first;
+        }
+        return (E)second;
+    }
 }

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