AHHH DONE??

arraz/src/main/java/Arraz.java

@@ -1,9 +1,5 @@
 import java.lang.reflect.Array;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
-import java.util.stream.Stream;
+import java.util.*;
 
 public class Arraz<T> {
 
@@ -177,51 +173,196 @@ public class Arraz<T> {
         return maxMin;
     }
 
-    //////////    //////////    //////////      CONTINUE HERE     //////////    //////////    //////////
+    public Integer[] removeDupesFromArray(Integer[] array) {
+        List<Integer> noDupes = new ArrayList<>();
 
-    public int countDupes(Integer[] array) {
-        int count = 0;
+        for (Integer integer : array) {
+            if (!noDupes.contains(integer)) {
+                noDupes.add(integer);
+            }
+        }
+
+        Integer[] newArray = new Integer[noDupes.size()];
+        int index = 0;
+
+        for (Integer integer : noDupes) {
+            newArray[index] = integer;
+            index++;
+        }
 
-        return count;
+        return newArray;
     }
 
-    public Integer[] removeDupesFromArray(Integer[] array){
-        int dupeCount = 0;
+    public Double findLargest(Double[] array) {
+        Double largest = array[0];
 
-        Integer[] newArray = new Integer[array.length - dupeCount];
+        for (int i = 0; i < array.length; i++) {
+            for (int j = i + 1; j < array.length; j++) {
+                if (largest < array[j]) {
+                    largest = array[j];
+                }
+            }
+        }
 
-        return newArray;
+        return largest;
     }
 
-    public Double find2ndLargestValueFromArray(Double[] array){
-        Double secondLargest = 0.0;
+    public int findIndexOfLargest(Double[] array) {
+        Double largest = findLargest(array);
+        int indexOfLargest = 0;
 
-        return secondLargest;
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] == largest) {
+                indexOfLargest = i;
+            }
+        }
+
+        return indexOfLargest;
     }
 
-    public ArrayList<T> makeMeAnArrayListFromArray(T[] array){
+    public Double find2ndLargestValueFromArray(Double[] array) {
+        int indexOfLargest = findIndexOfLargest(array);
+        array[indexOfLargest] = 0.0;
+
+        return findLargest(array);
+    }
+
+    public ArrayList<T> makeMeAnArrayListFromArray(T[] array) {
         ArrayList<T> arrayList = new ArrayList<T>();
 
+        for (T element : array) {
+            arrayList.add(element);
+        }
+
         return arrayList;
     }
 
-    public T[] makeMeAnArrayFromArrayList(ArrayList<T> arrayList) {
-        // ???? not really sure what i'm doing here
+    public T[] makeMeAnArrayFromArrayList(ArrayList<T> arrayList, T[] targetClass) {
+        T[] newArray = createEmptyGenericArray((targetClass), arrayList.size());
+        int index = 0;
+
+        for (Object object : arrayList) {
+            newArray[index] = (T) object;
+            index++;
+        }
+
+        return newArray;
+    }
+
+    public boolean check2ArraysForEquals(T[] array1, T[] array2){
+        if (Arrays.equals(array1, array2)) {
+            return true;
+        }
+        return false;
+    }
 
-        T[] array;
+    public double averageArrayWithoutMaxMin(int[] array){
+        double sum = 0;
+        int dupes = 0;
 
-        Class cl = arrayList.getClass();
-        if (!cl.isArray()) {
-            return null;
-        } else {
-            array = (T[]) Array.newInstance(cl.getComponentType(), arrayList.size());
+        for (int integer : array) {
+            if (integer != findMax(array) && integer != findMin(array)) {
+                sum += integer;
+            } else {
+                dupes++;
+            }
+        }
+
+        return sum / (array.length - dupes);
+    }
+
+    public boolean arrayHas65And77(int[] array){
+        if (containsValue(array, 65) && containsValue(array, 77)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public boolean theTotalofTensIs30(int[] array){
+        int sum = 0;
+
+        for (int integer : array) {
+            if (integer == 10) {
+                sum += integer;
+            }
+        }
+
+        if (sum == 30) {
+            return true;
+        }
+
+        return false;
+    }
+
+
+    public int findSmallestOfArray(int[] array){
+        return findMin(array);
+    }
+
+    public int findSecondSmallestOfArray(int[] array){
+        int indexOfSmallest = findIndexOf(array, findSmallestOfArray(array));
+        array[indexOfSmallest] = findMax(array);
+
+        return findMin(array);
+    }
+
+    public int[] makeMeACopyPlease(int[] array){
+       return reverseArray(array);
+    }
+
+    public T[] removeFromIndex(T[] array, int index) {
+        T[] newArray = createEmptyGenericArray(array, array.length - 1);
+        int j = 0;
+
+        for (int i = 0; i < array.length; i++) {
+            if (i != index) {
+                newArray[j] = array[i];
+                j++;
+            }
         }
+        return newArray;
+    }
 
-        return array;
+    public T[] removeLastItemAndCopy(T[] array) {
+        T[] newArray = removeFromIndex(array, array.length - 1);
+
+        return newArray;
     }
 
+    public T[] removeFirstItemAndCopy(T[] array) {
+        T[] newArray = removeFromIndex(array, 0);
 
+        return newArray;
+    }
 
+    public T[] insertAtStartAndCopy(T[] array, T element) {
+        T[] newArray = insertIntoArrayAt(array, element, 0);
 
+        return newArray;
+    }
+
+    public T[] insertAtEndAndCopy(T[] array, T element) {
+        T[] newArray = insertIntoArrayAt(array, element, array.length);
+
+        return newArray;
+    }
+
+    public List[] sortArrayIntoEvensThenOdds(int[] array){
+        List[] evensThenOdds = new ArrayList[2];
+        List<Integer> evens = new ArrayList<>();
+        List<Integer> odds = new ArrayList<>();
+
+        for (int integer : array) {
+            if (integer % 2 == 0) {
+                evens.add(integer);
+            } else {
+                odds.add(integer);
+            }
+        }
+
+        evensThenOdds[0] = evens; evensThenOdds[1] = odds;
+        return evensThenOdds;
+    }
 
 }

arraz/src/test/java/ArrazTest.java

@@ -2,7 +2,8 @@ import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import java.util.ArrayList;
+import java.util.List;
 
 public class ArrazTest {
 
@@ -277,16 +278,20 @@ public class ArrazTest {
 
     @Test
     public void findMax() {
-        int expected = 5;
-        int actual = arraz.findMax(intArray);
+        int[] spiffyHandyIntArray = new int[]{4, 5, 102, 6, -7, 12, -32, 92, 8};
+
+        int expected = 102;
+        int actual = arraz.findMax(spiffyHandyIntArray);
 
         Assert.assertEquals(expected, actual);
     }
 
     @Test
     public void findMin() {
-        int expected = 1;
-        int actual = arraz.findMin(intArray);
+        int[] spiffyHandyIntArray = new int[]{4, 5, 102, 6, -7, 12, -32, 92, 8};
+
+        int expected = -32;
+        int actual = arraz.findMin(spiffyHandyIntArray);
 
         Assert.assertEquals(expected, actual);
     }
@@ -313,45 +318,361 @@ public class ArrazTest {
 
     //////////    //////////    //////////
 
+
     @Test
     public void removeDupesFromArray1() {
+        Integer[] original = new Integer[]{2, 2, 1, 3, 4, 5, 5, 6, 2, 1, 8};
 
+        Integer[] expected = new Integer[]{2, 1, 3, 4, 5, 6, 8};
+        Integer[] actual = arraz.removeDupesFromArray(original);
 
-
+        Assert.assertEquals(expected, actual);
     }
 
     @Test
     public void removeDupesFromArray2() {
+        Integer[] original = new Integer[]{10, 6, 20, 22, 28, 5, 999, 5};
+
+        Integer[] expected = new Integer[]{10, 6, 20, 22, 28, 5, 999};
+        Integer[] actual = arraz.removeDupesFromArray(original);
+
+        Assert.assertEquals(expected, actual);
     }
 
     //////////    //////////    //////////
 
     @Test
     public void find2ndLargestValueFromArray1() {
+        Double[] original = new Double[]{2.4, 3.0, 6.5, 7.1, 2.8, 1.1, 0.5};
+
+        Double expected = 6.5;
+        Double actual = arraz.find2ndLargestValueFromArray(original);
+
+        Assert.assertEquals(expected, actual, 1e-15);
     }
 
 
     @Test
     public void find2ndLargestValueFromArray2() {
+        Double[] original = new Double[]{1.5, 1.3, 1.4, 1.2, 1.1};
+
+        Double expected = 1.4;
+        Double actual = arraz.find2ndLargestValueFromArray(original);
+
+        Assert.assertEquals(expected, actual, 1e-15);
     }
 
     //////////    //////////    //////////
 
     @Test
     public void makeMeAnArrayListFromArray1() {
+        Integer[] original = new Integer[]{1, 2, 3};
+
+        ArrayList<Integer> expected = new ArrayList<>();
+        expected.add(1);
+        expected.add(2);
+        expected.add(3);
+
+        ArrayList<Integer> actual = arraz.makeMeAnArrayListFromArray(original);
+
+        Assert.assertEquals(expected, actual);
     }
 
     @Test
     public void makeMeAnArrayListFromArray2() {
+        String[] original = new String[]{"I", "am", "very", "hungry", "!"};
+
+        ArrayList<String> expected = new ArrayList<>();
+        expected.add("I");
+        expected.add("am");
+        expected.add("very");
+        expected.add("hungry");
+        expected.add("!");
+
+        ArrayList<String> actual = arraz.makeMeAnArrayListFromArray(original);
+
+        Assert.assertEquals(expected, actual);
     }
 
     //////////    //////////    //////////
 
     @Test
     public void makeMeAnArrayFromArrayList1() {
+        ArrayList<Integer> original = new ArrayList<>();
+        original.add(6);
+        original.add(20);
+        original.add(92);
+
+        Integer[] expected = new Integer[]{6, 20, 92};
+        Integer[] actual = (Integer[]) arraz.makeMeAnArrayFromArrayList(original, new Integer[0]);
+
+        Assert.assertEquals(expected, actual);
     }
 
     @Test
     public void makeMeAnArrayFromArrayList2() {
+        ArrayList<String> original = new ArrayList<>();
+        original.add("hello");
+        original.add("goodbye");
+
+        String[] expected = new String[]{"hello", "goodbye"};
+        String[] actual = (String[]) arraz.makeMeAnArrayFromArrayList(original, new String[0]);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void check2ArraysForEquals1() {
+        String[] string1 = "I am starting to hate arrays".split(" ");
+        String[] string2 = new String[]{"I", "am", "starting", "to", "hate", "arrays"};
+
+        Assert.assertTrue(arraz.check2ArraysForEquals(string1, string2));
+    }
+
+    @Test
+    public void check2ArraysForEquals2() {
+        Double[] double1 = new Double[]{1.0, 0.5, 3.6, 38.4, 17.3, 62.0, 9.0, 3.375, 0.0, 3.14159};
+        Double[] double2 = new Double[]{1.0, 0.5, 3.6, 38.4, 17.3, 62.1, 9.0, 3.375, 0.0, 3.14159};
+
+        Assert.assertFalse(arraz.check2ArraysForEquals(double1, double2));
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void averageArrayWithoutMaxMin1() {
+        String expected = "3.00";
+        String actual = String.format("%.2f", arraz.averageArrayWithoutMaxMin(intArray));
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void averageArrayWithoutMaxMin2() {
+        int[] original = new int[]{9, 9, 2, 5, -18, 5, 2, 35, 291, 291, 291, -18};
+
+        String expected = "9.57";
+        String actual = String.format("%.2f", arraz.averageArrayWithoutMaxMin(original));
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void arrayHas65And77_1() {
+        int[] original = new int[]{1, 1, 2, 65, 64, 98, 78};
+
+        Assert.assertFalse(arraz.arrayHas65And77(original));
+    }
+
+    @Test
+    public void arrayHas65And77_2() {
+        int[] original = new int[]{1, 1, 2, 65, 64, 98, 77};
+
+        Assert.assertTrue(arraz.arrayHas65And77(original));
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void theTotalofTensIs30_1() {
+        int[] original = new int[]{10, 1, 2, 65, 10, 64, 10, 98, 77};
+
+        Assert.assertTrue(arraz.theTotalofTensIs30(original));
+    }
+
+    @Test
+    public void theTotalofTensIs30_2() {
+        int[] original = new int[]{10, 1, 2, 10, 65, 10, 64, 10, 98, 77};
+
+        Assert.assertFalse(arraz.theTotalofTensIs30(original));
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void findSmallestOfArray1() {
+        int expected = 1;
+        int actual = arraz.findSmallestOfArray(intArray);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void findSmallestOfArray2() {
+        int[] spiffyHandyIntArray = new int[]{4, 5, 102, 6, -7, 12, -32, 92, 8};
+
+        int expected = -32;
+        int actual = arraz.findSmallestOfArray(spiffyHandyIntArray);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void findSecondSmallestOfArray1() {
+        int expected = 2;
+        int actual = arraz.findSecondSmallestOfArray(intArray);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void findSecondSmallestOfArray2() {
+        int[] spiffyHandyIntArray = new int[]{4, 5, 102, 6, -7, 12, -32, 92, 8};
+
+        int expected = -7;
+        int actual = arraz.findSecondSmallestOfArray(spiffyHandyIntArray);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    //////////    //////////    //////////
+
+    @Test
+    public void makeMeACopyPlease1() {
+        int[] expected = new int[]{5, 4, 3, 2, 1};
+        int[] actual = arraz.makeMeACopyPlease(intArray);
+
+        for (int i = 0; i < expected.length; i++) {
+            Assert.assertEquals(expected[i], actual[i]);
+        }
+    }
+
+    @Test
+    public void makeMeACopyPlease2() {
+        int[] spiffyHandyIntArray = new int[]{4, 5, 102, 6, -7, 12, -32, 92, 8};
+
+        int[] expected = new int[]{8, 92, -32, 12, -7, 6, 102, 5, 4};
+        int[] actual = arraz.makeMeACopyPlease(spiffyHandyIntArray);
+
+        for (int i = 0; i < expected.length; i++) {
+            Assert.assertEquals(expected[i], actual[i]);
+        }
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void removeLastItemAndCopy1() {
+        Integer[] original = new Integer[]{10, 6, 20, 22, 28, 5, 999, 5};
+
+        Integer[] expected = new Integer[]{10, 6, 20, 22, 28, 5, 999};
+        Integer[] actual = (Integer[]) arraz.removeLastItemAndCopy(original);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void removeLastItemAndCopy2() {
+        String[] original = new String[]{"My", "name", "is", "Jenn", "Chao"};
+
+        String[] expected = new String[]{"My", "name", "is", "Jenn"};
+        String[] actual = (String[]) arraz.removeLastItemAndCopy(original);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void removeFirstItemAndCopy1() {
+        Integer[] original = new Integer[]{10, 6, 20, 22, 28, 5, 999, 5};
+
+        Integer[] expected = new Integer[]{6, 20, 22, 28, 5, 999, 5};
+        Integer[] actual = (Integer[]) arraz.removeFirstItemAndCopy(original);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void removeFirstItemAndCopy2() {
+        String[] original = new String[]{"My", "name", "is", "Jenn", "Chao"};
+
+        String[] expected = new String[]{"name", "is", "Jenn", "Chao"};
+        String[] actual = (String[]) arraz.removeFirstItemAndCopy(original);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void insertAtStartAndCopy1() {
+        Integer[] original = new Integer[]{1, 2, 3, 4, 5};
+
+        Integer[] expected = new Integer[]{99, 1, 2, 3, 4, 5};
+        Integer[] actual = (Integer[]) arraz.insertAtStartAndCopy(original, 99);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void insertAtStartAndCopy2() {
+        String[] original = new String[]{"I", "want", "fruit", "snacks"};
+
+        String[] expected = new String[]{"Seriously", "I", "want", "fruit", "snacks"};
+        String[] actual = (String[]) arraz.insertAtStartAndCopy(original, "Seriously");
+
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void insertAtEndAndCopy1() {
+        Integer[] original = new Integer[]{1, 2, 3, 4, 5};
+
+        Integer[] expected = new Integer[]{1, 2, 3, 4, 5, 99};
+        Integer[] actual = (Integer[]) arraz.insertAtEndAndCopy(original, 99);
+
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void insertAtEndAndCopy2() {
+        String[] original = new String[]{"I", "want", "fruit", "snacks"};
+
+        String[] expected = new String[]{"I", "want", "fruit", "snacks", "!"};
+        String[] actual = (String[]) arraz.insertAtEndAndCopy(original, "!");
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void sortArrayIntoEvensThenOdds1() {
+        int[] spiffyHandyIntArray = new int[] {4, 5, 102, 6, -7, 12, -32, 92, 8};
+
+        List<Integer> evens = new ArrayList<>();
+        evens.add(4); evens.add(102); evens.add(6); evens.add(12); evens.add(-32); evens.add(92); evens.add(8);
+        List<Integer> odds = new ArrayList<>();
+        odds.add(5); odds.add(-7);
+
+        List[] expected = new List[] {evens, odds};
+        List[] actual = arraz.sortArrayIntoEvensThenOdds(spiffyHandyIntArray);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void sortArrayIntoEvensThenOdds2() {
+        List<Integer> evens = new ArrayList<>();
+        evens.add(2); evens.add(4);
+        List<Integer> odds = new ArrayList<>();
+        odds.add(1); odds.add(3); odds.add(5);
+
+        List[] expected = new List[] {evens, odds};
+        List[] actual = arraz.sortArrayIntoEvensThenOdds(intArray);
+
+        Assert.assertEquals(expected, actual);
     }
 }