Never again

src/main/java/Pair/Arrays.java

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

src/main/java/Pair/Pair.java

@@ -7,7 +7,7 @@ package Pair;
  * min -> returns the minimum of the pair
  * max -> returns the maximum of the pair
  */
-public class Pair <E extends Comparable<E>>  {
+public class Pair <E extends Comparable>  {
     //without extending you cannot compare generic types
     //by extending comparing individual values of generic types is now viable
     private E 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());
+    }
+}