half of the tests, working through the methods

arraz/src/main/java/Arraz.java

@@ -1,2 +1,227 @@
-public class Arraz {
+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;
+
+public class Arraz<T> {
+
+    public int sumValuesOfArray(int[] array) {
+        int sum = 0;
+
+        for (int intValue : array) {
+            sum += intValue;
+        }
+
+        return sum;
+    }
+
+    public double sumDoubleOfArray(double[] array) {
+        double sum = 0;
+
+        for (double doubleValue : array) {
+            sum += doubleValue;
+        }
+
+        return sum;
+    }
+
+    public int averageOfArray(int[] array) {
+        return sumValuesOfArray(array) / array.length;
+    }
+
+    public double doubleAverageOfArray(double[] array) {
+        return sumDoubleOfArray(array) / array.length;
+    }
+
+    public boolean containsValue(int[] array, int value) {
+        for (int intValue : array) {
+            if (intValue == value) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int[] reverseArray(int[] array) {
+        int[] reverse = new int[array.length];
+        int reverseIndex = array.length - 1;
+
+        for (int intValue : array) {
+            reverse[reverseIndex] = intValue;
+            reverseIndex -= 1;
+        }
+
+        return reverse;
+    }
+
+    public OddEven getOddEvensOfArray(int[] array) {
+        OddEven oddeven = new OddEven();
+
+        for (int intValue : array) {
+            if (intValue % 2 == 0) {
+                oddeven.evens++;
+            } else {
+                oddeven.odds++;
+            }
+        }
+
+        return oddeven;
+    }
+
+    public int findIndexOf(int[] array, int value) {
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] == value) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public T[] createEmptyGenericArray(T[] array, int length) {
+        Class cl = array.getClass();
+        if (!cl.isArray()) {
+            return null;
+        } else {
+            T[] copy = (T[]) Array.newInstance(cl.getComponentType(), length);
+            return copy;
+        }
+    }
+
+    public T[] copyArrayByIterator(T[] array) {
+        T[] copy = createEmptyGenericArray(array, array.length);
+        int index = 0;
+
+        List<T> copyList = Arrays.asList(array);
+        Iterator iterator = copyList.iterator();
+
+        while (iterator.hasNext()) {
+            copy[index] = (T) iterator.next();
+            index++;
+        }
+
+        return copy;
+    }
+
+    public T[] copyArrayByLoop(T[] array) {
+        T[] copy = createEmptyGenericArray(array, array.length);
+
+        for (int i = 0; i < array.length; i++) {
+            copy[i] = array[i];
+        }
+
+        return copy;
+    }
+
+    public T[] removeElementFromArray(T[] array, T element) {
+        T[] newArray = createEmptyGenericArray(array, array.length - 1);
+        int j = 0;
+
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] != element) {
+                newArray[j] = array[i];
+                j++;
+            }
+        }
+
+        return newArray;
+    }
+
+    public T[] insertIntoArrayAt(T[] array, T element, int index) {
+        T[] newArray = createEmptyGenericArray(array, array.length + 1);
+        int j = 0;
+
+        for (int i = 0; i < newArray.length; i++) {
+            if (i != index) {
+                newArray[i] = array[j];
+                j++;
+            } else if (i == index) {
+                newArray[index] = element;
+            }
+        }
+
+        return newArray;
+    }
+
+    public int findMax(int[] array) {
+        int max = array[0];
+
+        for (int intValue : array) {
+            if (intValue > max) {
+                max = intValue;
+            }
+        }
+
+        return max;
+    }
+
+    public int findMin(int[] array) {
+        int min = array[0];
+
+        for (int intValue : array) {
+            if (intValue < min) {
+                min = intValue;
+            }
+        }
+
+        return min;
+    }
+
+    public MaxMin findMaxMinOfArray(int[] array) {
+        MaxMin maxMin = new MaxMin();
+        maxMin.max = findMax(array);
+        maxMin.min = findMin(array);
+
+        return maxMin;
+    }
+
+    //////////    //////////    //////////      CONTINUE HERE     //////////    //////////    //////////
+
+    public int countDupes(Integer[] array) {
+        int count = 0;
+
+        return count;
+    }
+
+    public Integer[] removeDupesFromArray(Integer[] array){
+        int dupeCount = 0;
+
+        Integer[] newArray = new Integer[array.length - dupeCount];
+
+        return newArray;
+    }
+
+    public Double find2ndLargestValueFromArray(Double[] array){
+        Double secondLargest = 0.0;
+
+        return secondLargest;
+    }
+
+    public ArrayList<T> makeMeAnArrayListFromArray(T[] array){
+        ArrayList<T> arrayList = new ArrayList<T>();
+
+        return arrayList;
+    }
+
+    public T[] makeMeAnArrayFromArrayList(ArrayList<T> arrayList) {
+        // ???? not really sure what i'm doing here
+
+        T[] array;
+
+        Class cl = arrayList.getClass();
+        if (!cl.isArray()) {
+            return null;
+        } else {
+            array = (T[]) Array.newInstance(cl.getComponentType(), arrayList.size());
+        }
+
+        return array;
+    }
+
+
+
+
+
 }

arraz/src/main/java/MaxMin.java

@@ -0,0 +1,15 @@
+public class MaxMin {
+
+    public int max;
+    public int min;
+
+    public MaxMin(){
+        this.max = 0;
+        this.min = 0;
+    }
+
+    public MaxMin(int max, int min){
+        this.max = max;
+        this.min = min;
+    }
+}

arraz/src/main/java/OddEven.java

@@ -0,0 +1,16 @@
+public class OddEven {
+
+    public int odds;
+    public int evens;
+
+    public OddEven() {
+        this.odds = 0;
+        this.evens = 0;
+    }
+
+    public OddEven(int odds, int evens) {
+        this.odds = odds;
+        this.evens = evens;
+    }
+
+}

arraz/src/test/java/ArrazTest.java

@@ -1,5 +1,357 @@
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
 import static org.junit.Assert.*;
 
 public class ArrazTest {
 
+    private Arraz arraz;
+    private int[] intArray;
+    private int[] intArray2;
+    private double[] doubleArray;
+    private double[] doubleArray2;
+
+    @Before
+    public void setUp() {
+        arraz = new Arraz();
+        intArray = new int[]{1, 2, 3, 4, 5};
+        intArray2 = new int[]{5, 6, 7, 8, 9, 10};
+        doubleArray = new double[]{11, 12, 13, 14, 15};
+        doubleArray2 = new double[]{15, 16, 17, 18, 19, 20};
+    }
+
+    @Test
+    public void sumValuesOfArray1() {
+        int expected = 15;
+        int actual = arraz.sumValuesOfArray(intArray);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void sumValuesOfArray2() {
+        int expected = 45;
+        int actual = arraz.sumValuesOfArray(intArray2);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void sumDoubleOfArray1() {
+        double expected = 65;
+        double actual = arraz.sumDoubleOfArray(doubleArray);
+
+        Assert.assertEquals(expected, actual, 1e-15);
+    }
+
+    @Test
+    public void sumDoubleOfArray2() {
+        double expected = 105;
+        double actual = arraz.sumDoubleOfArray(doubleArray2);
+
+        Assert.assertEquals(expected, actual, 1e-15);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void averageOfArray1() {
+        int expected = 3;
+        int actual = arraz.averageOfArray(intArray);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void averageOfArray2() {
+        int expected = 7;
+        int actual = arraz.averageOfArray(intArray2);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void doubleAverageOfArray1() {
+        double expected = 13;
+        double actual = arraz.doubleAverageOfArray(doubleArray);
+
+        Assert.assertEquals(expected, actual, 1e-15);
+    }
+
+    @Test
+    public void doubleAverageOfArray2() {
+        double expected = 17.5;
+        double actual = arraz.doubleAverageOfArray(doubleArray2);
+
+        Assert.assertEquals(expected, actual, 1e-15);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void containsValue1() {
+        Assert.assertTrue(arraz.containsValue(intArray, 5));
+        Assert.assertTrue(arraz.containsValue(intArray2, 5));
+    }
+
+    @Test
+    public void containsValue2() {
+        Assert.assertFalse(arraz.containsValue(intArray, 6));
+        Assert.assertFalse(arraz.containsValue(intArray2, 4));
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void reverseArray1() {
+        int[] expected = {5, 4, 3, 2, 1};
+        int[] actual = arraz.reverseArray(intArray);
+
+        for (int i = 0; i < expected.length; i++) {
+            Assert.assertEquals(expected[i], actual[i]);
+        }
+    }
+
+    @Test
+    public void reverseArray2() {
+        int[] expected = {10, 9, 8, 7, 6, 5};
+        int[] actual = arraz.reverseArray(intArray2);
+
+        for (int i = 0; i < expected.length; i++) {
+            Assert.assertEquals(expected[i], actual[i]);
+        }
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void getOddEvensOfArray1() {
+        OddEven expected = new OddEven(3, 2);
+        OddEven actual = arraz.getOddEvensOfArray(intArray);
+
+        Assert.assertEquals(expected.odds, actual.odds);
+        Assert.assertEquals(expected.evens, actual.evens);
+    }
+
+    @Test
+    public void getOddEvensOfArray2() {
+        OddEven expected = new OddEven(3, 3);
+        OddEven actual = arraz.getOddEvensOfArray(intArray2);
+
+        Assert.assertEquals(expected.odds, actual.odds);
+        Assert.assertEquals(expected.evens, actual.evens);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void findIndexOf1() {
+        int expected = 3;
+        int actual = arraz.findIndexOf(intArray, 4);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void findIndexOf2() {
+        int expected = -1;
+        int actual = arraz.findIndexOf(intArray2, 1);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void createEmptyGenericArray() {
+        String[] expected = new String[]{"this", "is", "a", "good", "test"};
+        String[] actual = (String[]) arraz.createEmptyGenericArray(expected, expected.length);
+        actual[0] = expected[0];
+
+        Assert.assertEquals(expected.getClass(), actual.getClass());
+        Assert.assertEquals(expected[0].getClass(), actual[0].getClass());
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void copyArrayByIterator1() {
+        String[] expected = new String[]{"this", "is", "a", "good", "test"};
+        String[] actual = (String[]) arraz.copyArrayByIterator(expected);
+
+        for (int i = 0; i < expected.length; i++) {
+            Assert.assertEquals(expected[i], actual[i]);
+        }
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void copyArrayByIterator2() {
+        Integer[] expected = new Integer[]{1, 2, 3, 4, 5};
+        Integer[] actual = (Integer[]) arraz.copyArrayByIterator(expected);
+
+        for (int i = 0; i < expected.length; i++) {
+            Assert.assertEquals(expected[i], actual[i]);
+        }
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void copyArrayByLoop1() {
+        String[] expected = new String[]{"this", "is", "a", "good", "test"};
+        String[] actual = (String[]) arraz.copyArrayByLoop(expected);
+
+        for (int i = 0; i < expected.length; i++) {
+            Assert.assertEquals(expected[i], actual[i]);
+        }
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void copyArrayByLoop2() {
+        Integer[] expected = new Integer[]{1, 2, 3, 4, 5};
+        Integer[] actual = (Integer[]) arraz.copyArrayByLoop(expected);
+
+        for (int i = 0; i < expected.length; i++) {
+            Assert.assertEquals(expected[i], actual[i]);
+        }
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void removeElementFromArray1() {
+        String[] original = new String[]{"this", "is", "a", "good", "test"};
+
+        String[] expected = new String[]{"this", "is", "a", "test"};
+        String[] actual = (String[]) arraz.removeElementFromArray(original, "good");
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void removeElementFromArray2() {
+        Integer[] original = new Integer[]{1, 2, 3, 4, 5};
+
+        Integer[] expected = new Integer[]{1, 2, 4, 5};
+        Integer[] actual = (Integer[]) arraz.removeElementFromArray(original, 3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void insertIntoArrayAt1() {
+        String[] original = new String[]{"this", "is", "a", "good", "test"};
+
+        String[] expected = new String[]{"this", "is", "a", "good", "test", "!"};
+        String[] actual = (String[]) arraz.insertIntoArrayAt(original, "!", 5);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void insertIntoArrayAt2() {
+        Integer[] original = new Integer[]{1, 2, 3, 4, 5};
+
+        Integer[] expected = new Integer[]{1, 2, 3, 100, 4, 5};
+        Integer[] actual = (Integer[]) arraz.insertIntoArrayAt(original, 100, 3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void findMax() {
+        int expected = 5;
+        int actual = arraz.findMax(intArray);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void findMin() {
+        int expected = 1;
+        int actual = arraz.findMin(intArray);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void findMaxMinOfArray1() {
+        MaxMin expected = new MaxMin(5, 1);
+        MaxMin actual = arraz.findMaxMinOfArray(intArray);
+
+        Assert.assertEquals(expected.max, actual.max);
+        Assert.assertEquals(expected.min, actual.min);
+    }
+
+    @Test
+    public void findMaxMinOfArray2() {
+        MaxMin expected = new MaxMin(10, 5);
+        MaxMin actual = arraz.findMaxMinOfArray(intArray2);
+
+        Assert.assertEquals(expected.max, actual.max);
+        Assert.assertEquals(expected.min, actual.min);
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void removeDupesFromArray1() {
+
+
+
+    }
+
+    @Test
+    public void removeDupesFromArray2() {
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void find2ndLargestValueFromArray1() {
+    }
+
+
+    @Test
+    public void find2ndLargestValueFromArray2() {
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void makeMeAnArrayListFromArray1() {
+    }
+
+    @Test
+    public void makeMeAnArrayListFromArray2() {
+    }
+
+    //////////    //////////    //////////
+
+    @Test
+    public void makeMeAnArrayFromArrayList1() {
+    }
+
+    @Test
+    public void makeMeAnArrayFromArrayList2() {
+    }
 }