Hateful Eight

arraz/src/main/java/Arraz.java

@@ -1,4 +1,4 @@
-public class Arraz {
+public class Arraz <T> {
 
     public static int sumValuesOfArray (int[] array){
 
@@ -11,15 +11,111 @@ public class Arraz {
         return sum;
     }
 
-//            sumDoublesOfArray
-//    averageOfArray
-//            doubleAverageOfArray
-//    containsValue
-//            reverseArray
-//    getOddEvensOfArray
-//            findIndexOf
-//    copyArrayByIterator
-//            copyArrayByLoop
+    public static double sumDoublesOfArray (double[] array){
+
+        double sum = 0;
+
+        for (double i : array)
+        {
+            sum += i;
+        }
+        return sum;
+
+    }
+
+    public static int averageOfArray (int[] array){
+
+        int average = 0;
+
+        for (int i : array)
+        {
+            average += i;
+        }
+
+        return average / array.length;
+    }
+
+    public static double doubleAverageOfArray(double[] array) {
+
+        double average = 0;
+
+        for (double i : array)
+        {
+            average += i;
+        }
+
+        return average / array.length;
+    }
+
+    public static boolean containsValue (int[] array, int value) {
+
+        boolean answer = false;
+
+        for (int i : array) {
+
+            if (i == value) {
+                answer = true;
+            }
+        }
+        return answer;
+    }
+
+    public static int[] reverseArray (int[] array){
+
+        //initialize
+        int end = array.length - 1;
+        int counter = 0;
+        int[] newArr = new int[array.length];
+
+        //reverse
+        for (int i = end; i >= 0; i--){
+            newArr[counter] = array[i];
+            counter++;
+        }
+        return newArr;
+    }
+
+    public static OddEven getOddEvensOfArray(int[] array) {
+
+        //initialize
+        int evens = 0;
+        int odds = 0;
+
+        //evaluate
+        for (int i : array) {
+            if (i % 2 == 0) {
+                evens++;
+            } else {
+                odds++;
+            }
+        }
+
+        return new OddEven(odds, evens);
+    }
+
+
+    public int findIndexOf (T[] array, T val) {
+
+        int index = -1;
+
+        for (int i = 0; i < array.length; i++) {
+            if (array[i].equals(val)){
+                index = i;
+            }
+        }
+
+        return index;
+    }
+
+    public static void copyArrayByIterator (){
+
+    }
+
+    public static void copyArrayByLoop(){
+
+
+    }
+
 //    removeElementFromArray
 //            insertIntoArrayAt
 //    findMaxMinOfArray

arraz/src/main/java/OddEven.java

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

arraz/src/test/java/ArrazTest.java

@@ -1,11 +1,17 @@
 import junit.framework.Assert;
 import org.junit.Test;
 
+import java.util.Arrays;
+
 import static org.junit.Assert.*;
 
 public class ArrazTest {
 
-    int[] spiffyHandyIntArray = new int[] {4,5,102,6,-7,12,-32,92,8};
+    private int[] spiffyHandyIntArray = new int[] {4,5,102,6,-7,12,-32,92,8};
+
+    private double[] spiffyHandyDoubleArray = new double[] {1.0, 0.5, 3.6, 38.4, 17.3, 62.0, 9.0, 3.375, 0, 3.14159};
+
+    Arraz whySoDifficult = new Arraz();
 
     @Test
     public void sumValuesOfArray() {
@@ -15,4 +21,84 @@ public class ArrazTest {
         Assert.assertEquals(sum, Arraz.sumValuesOfArray(spiffyHandyIntArray));
 
     }
+
+    @Test
+    public void sumDoublesOfArray() {
+
+        double sum = 138.31659000000002;
+
+        Assert.assertEquals(sum, Arraz.sumDoublesOfArray(spiffyHandyDoubleArray));
+
+    }
+
+    @Test
+    public void averageOfArray() {
+
+        int average = 21;
+
+        Assert.assertEquals(average, Arraz.averageOfArray(spiffyHandyIntArray));
+
+    }
+
+    @Test
+    public void doubleAverageOfArray() {
+
+        double average = 13.831659000000002;
+
+        Assert.assertEquals(average, Arraz.doubleAverageOfArray(spiffyHandyDoubleArray));
+
+    }
+
+    @Test
+    public void containsValue() {
+
+        Assert.assertTrue(Arraz.containsValue(spiffyHandyIntArray, 102));
+        Assert.assertFalse(Arraz.containsValue(spiffyHandyIntArray, 103));
+
+    }
+
+
+    @Test
+    public void reverseArray() {
+
+        int[] expected = new int[] {8, 92, -32, 12, -7, 6, 102, 5, 4};
+
+        Assert.assertEquals(Arrays.toString(expected), Arrays.toString(Arraz.reverseArray(spiffyHandyIntArray)));
+
+    }
+
+    @Test
+    public void getOddEvensOfArray() {
+
+        OddEven result = new OddEven(2, 7);
+
+        Assert.assertEquals(result.odds, Arraz.getOddEvensOfArray(spiffyHandyIntArray).odds);
+        Assert.assertEquals(result.evens, Arraz.getOddEvensOfArray(spiffyHandyIntArray).evens);
+
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void findIndexOf() {
+
+        //Given
+        int expected = 4;
+        int expectedtwo = -1;
+        int val = -7;
+        int valtwo = 123456789;
+        Integer[] damnedObjects = new Integer[] {4,5,102,6,-7,12,-32,92,8};
+
+        //Assert
+        Assert.assertEquals(expected, whySoDifficult.findIndexOf(damnedObjects, val));
+        Assert.assertEquals(expectedtwo, whySoDifficult.findIndexOf(damnedObjects, valtwo));
+
+    }
+
+    @Test
+    public void copyArrayByIterator() {
+    }
+
+    @Test
+    public void copyArrayByLoop() {
+    }
 }