MaxMin

arraz/src/main/java/Arraz.java

+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.stream.Stream;
+
 public class Arraz {
 
     public int sumValuesOfArray(int[] intArr){
 
         return retArr;
     }
+
+    public OddEven getOddEvensOfArray(int[] intsArr){
+        OddEven oddEven = new OddEven();
+        oddEven.evens = 0;
+        oddEven.odds = 0;
+
+        for (int i:intsArr) {
+            if(i % 2 == 0){
+                oddEven.evens++;
+            } else {
+                oddEven.odds++;
+            }
+        }
+        return oddEven;
+    }
+
+    public int findIndexOf(int[] intsArr, int index){
+        return intsArr[index];
+    }
+
+
+//    public Integer[] copyArrayByIterator(Integer[] intInput) {
+//        Integer[] retArr = new Integer[intInput.length];
+//
+//        Iterator<Integer> iterator = new Iterator<Integer>() {
+//            public boolean hasNext(int intValue) {
+//                return intValue == null ? true : false;
+//            }
+//
+//            public Integer next() {
+//                return null;
+//            }
+//
+//            public void remove() {
+//
+//            }
+//        }
+//        return retArr;
+//    }
+
+    public int[] copyArrayByLoop(int[] ints){
+        int[] retArr = new int[ints.length];
+        for (int i = 0; i < ints.length; i++) {
+            retArr[i] = ints[i];
+        }
+        return retArr;
+    }
+
+    public int[] removeElementFromArray(int[] ints, int removeInt){
+        int[] retArr = new int[ints.length - 1];
+
+        int index = 0;
+        for (int i:ints) {
+            if (i != removeInt){
+                retArr[index] = i;
+                index++;
+            }
+        }
+        return retArr;
+    }
+
+    public int[] insertIntoArrayAt(int[] ints, int index, int intToInsert){
+        int[] retArr = new int[ints.length + 1];
+
+        int intsIndex = 0;
+        for (int i = 0; i < retArr.length; i++){
+            if (i == index){
+                retArr[i] = intToInsert;
+            }
+            else {
+                retArr[i] = ints[intsIndex];
+                intsIndex++;
+            }
+        }
+        return retArr;
+    }
+
+    public MaxMin findMaxMinOfArray(int[] ints){
+        MaxMin maxMin = new MaxMin();
+        int minVal = Integer.MAX_VALUE;
+        int maxVal = Integer.MIN_VALUE;
+
+        for (int i:ints) {
+            if (i < minVal){
+                minVal = i;
+            }
+            if (i > maxVal){
+                maxVal = i;
+            }
+        }
+
+        maxMin.min = minVal;
+        maxMin.max = maxVal;
+        return maxMin;
+    }
 }

arraz/src/main/java/MaxMin.java

+public class MaxMin {
+    public int max;
+    public int min;
+}

arraz/src/main/java/OddEven.java

 public class OddEven {
-        private int odds;
-        private int evens;
+        public int odds;
+        public int evens;
 
     public OddEven() {
     }

arraz/src/test/java/ArrazTest.java

         //THEN
         Assert.assertEquals(arr[0], actual[3]);
     }
+
+    @Test
+    public void test1getOddEvensOfArray(){
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+
+        //WHEN
+        int expected = 2;
+        int actual = arraz.getOddEvensOfArray(arr).evens;
+
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2getOddEvensOfArray(){
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+
+        //WHEN
+        int expected = 3;
+        int actual = arraz.getOddEvensOfArray(arr).odds;
+
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test1findIndexOf() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+        int index = 4;
+        //WHEN
+        int expected = 5;
+        int actual = arraz.findIndexOf(arr, index);
+
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2findIndexOf() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+        int index = 1;
+        //WHEN
+        int expected = 2;
+        int actual = arraz.findIndexOf(arr, index);
+
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+//    @Test
+//    public void test1copyArrayByIterator() {
+//        //GIVEN
+//        Object[] arr = {1, 2, 3, 4, 5};
+//        //WHEN
+//        Object[] retObject = arraz.copyArrayByIterator(arr);
+//        int expected = 3;
+//
+//        //THEN
+//        int actual = retObject.;
+//        Assert.assertEquals(expected, actual);
+//    }
+//
+//    @Test
+//    public void test2copyArrayByIterator() {
+//
+//    }
+
+    @Test
+    public void test1copyArrayByLoop() {
+        //GIVEN
+        int[] expected = {1, 2, 3, 4, 5};
+        //WHEN
+        int[] actual = arraz.copyArrayByLoop(expected);
+
+        //THEN
+        Assert.assertEquals(expected[0], actual[0]);
+    }
+
+    @Test
+    public void test2copyArrayByLoop() {
+        //GIVEN
+        int[] expected = {1, 2, 3, 4, 5};
+        //WHEN
+        int[] actual = arraz.copyArrayByLoop(expected);
+
+        //THEN
+        Assert.assertEquals(expected[expected.length - 1], actual[expected.length - 1]);
+    }
+
+    @Test
+    public void test1removeElementFromArray() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+        int removeInt = 5;
+        //WHEN
+        int expected = 4;
+        int actual = arraz.removeElementFromArray(arr, removeInt).length;
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2removeElementFromArray() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+        int removeInt = 1;
+        //WHEN
+        int expected = 2;
+        int[] actual = arraz.removeElementFromArray(arr, removeInt);
+        //THEN
+        Assert.assertEquals(expected, actual[0]);
+    }
+
+    @Test
+    public void test1insertIntoArrayAt() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+        int addInt = 6;
+        int atIndex = 3;
+        //WHEN
+        int expected = 6;
+        int[] retArr = arraz.insertIntoArrayAt(arr, atIndex, addInt);
+        int actual = retArr[atIndex];
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2insertIntoArrayAt() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+        int addInt = 6;
+        int atIndex = 5;
+        //WHEN
+        int expected = 6;
+        int[] retArr = arraz.insertIntoArrayAt(arr, atIndex, addInt);
+        int actual = retArr[atIndex];
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test1findMaxMinOfArray() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+        //WHEN
+        int expectedMax = 5;
+        int expectedMin = 1;
+        MaxMin maxMin = arraz.findMaxMinOfArray(arr);
+
+        int actualMax = maxMin.max;
+        int actualMin = maxMin.min;
+        //THEN
+        Assert.assertEquals(expectedMax, actualMax);
+        Assert.assertEquals(expectedMin, actualMin);
+    }
+
+    @Test
+    public void test2findMaxMinOfArray() {
+        //GIVEN
+        int[] arr = {1, -2, 300, 4, 5};
+        //WHEN
+        int expectedMax = 300;
+        int expectedMin = -2;
+        MaxMin maxMin = arraz.findMaxMinOfArray(arr);
+
+        int actualMax = maxMin.max;
+        int actualMin = maxMin.min;
+        //THEN
+        Assert.assertEquals(expectedMax, actualMax);
+        Assert.assertEquals(expectedMin, actualMin);
+    }
 }