ArrayManipulator

package FundamentalsModule.MethodsMoreExcercises;


import java.util.Arrays;
import java.util.Scanner;


public class ArrayManipulator {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int[] intArray = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

        String command = scanner.nextLine();
        while (!command.equals("end")) {
            String[] inputArr = command.split(" ");

            switch (inputArr[0]) {
                case "exchange":
                    int index = Integer.parseInt(inputArr[1]);
                    if (index >= 0 && index < intArray.length) {
                        intArray = rotateArray(intArray, index);
                    } else {
                        System.out.println("Invalid index");
                    }
                    break;
                case "max":
                    printMaxOddOrEven(inputArr[1], intArray);
                    break;
                case "min":
                    printMinOddEven(inputArr[1], intArray);
                    break;

                case "first":
                case "last":
                    int count = Integer.parseInt(inputArr[1]);
                    print1stOrLast(intArray, inputArr[0], count, inputArr[2]);
            }

            command = scanner.nextLine();
        }
        System.out.println(Arrays.toString(intArray));
    }

    private static void print1stOrLast(int[] array, String firstOrLast, int count, String evenOrOdd) {

        if (count > array.length) {
            System.out.println("Invalid count");
        } else {

            int[] outputArray = new int[0];
            int tempIndex = 1;
            switch (firstOrLast) {
                case "first":
                    for (int i = 0; i < array.length; i++) {
                        if (array[i] % 2 == 0 && evenOrOdd.equals("even")) {
                            if (tempIndex <= count) {
                                outputArray = Arrays.copyOf(outputArray, tempIndex);
                                outputArray[tempIndex-1] = array[i];
                                tempIndex++;
                            } else {
                                break;
                            }
                        } else if (array[i] % 2 != 0 && evenOrOdd.equals("odd")) {
                            if (tempIndex <= count) {
                                outputArray = Arrays.copyOf(outputArray, tempIndex);
                                outputArray[tempIndex-1] = array[i];
                                tempIndex++;
                            } else {
                                break;
                            }
                        }
                    }
                    System.out.println(Arrays.toString(outputArray));
                    break;
                case "last":

                    for (int i = array.length - 1; i >= 0; i--) {

                        if (array[i] % 2 == 0 && evenOrOdd.equals("even")) {
                            if (count > 0) {
                                count--;
                                outputArray = Arrays.copyOf(outputArray, tempIndex);
                                outputArray[tempIndex - 1] = array[i];
                                tempIndex++;
                            } else {
                                break;
                            }
                        } else if (array[i] % 2 != 0 && evenOrOdd.equals("odd")) {
                            if (count > 0) {
                                count--;
                                outputArray = Arrays.copyOf(outputArray, tempIndex);
                                outputArray[tempIndex - 1] = array[i];
                                tempIndex++;
                            } else {
                                break;
                            }
                        }
                    }
                    System.out.println(Arrays.toString(reveriseArray(outputArray)));
            }
        }
    }

    private static int[] reveriseArray(int[] outputArray) {

        int[] reverseArray = new int[outputArray.length];
        for (int i = outputArray.length - 1; i >= 0; i--) {
            reverseArray[i] = outputArray[i];
        }
        return reverseArray;
    }
    private static int[] rotateArray(int[] array, int rotateIndex) {

        int[] leftArr = new int[rotateIndex + 1];
        int[] rightArr = new int[array.length - leftArr.length];

        for (int i = 0; i < leftArr.length; i++) {
            leftArr[i] = array[i];
        }
        int tempIndex = 0;
        for (int i = rotateIndex + 1; i < array.length; i++) {
            rightArr[tempIndex] = array[i];
            tempIndex++;
        }

        int[] newArray = new int[array.length];

        for (int i = 0; i < rightArr.length; i++) {
            newArray[i] = rightArr[i];
        }

        for (int i = rightArr.length; i < array.length; i++) {
            newArray[i] = array[i - rightArr.length];
        }
        return newArray;
    }

    private static void printMinOddEven(String oddOrEven, int[] array) {
        int minEven = Integer.MAX_VALUE;
        int minOdd = Integer.MAX_VALUE;
        int minEvenIndex = 0;
        int minOddIndex = 0;
        boolean evenFound = false;
        boolean oddFound = false;

        for (int i = 0; i < array.length; i++) {
            if (array[i] % 2 == 0 && array[i] <= minEven) {
                minEven = array[i];
                minEvenIndex = i;
                evenFound = true;
            } else if (array[i] % 2 != 0 && array[i] <= minOdd) {
                minOdd = array[i];
                minOddIndex = i;
                oddFound = true;
            }
        }
        if (oddOrEven.equals("even") && evenFound) {
            System.out.println(minEvenIndex);
        } else if (oddOrEven.equals("odd") && oddFound) {
            System.out.println(minOddIndex);
        } else {
            System.out.println("No matches");
        }
    }


    private static void printMaxOddOrEven(String oddOrEven, int[] array) {

        int maxEven = Integer.MIN_VALUE;
        int maxOdd = Integer.MIN_VALUE;
        int mmaxEvenIndex = 0;
        int mmaxOddIndex = 0;
        boolean evenFound = false;
        boolean oddFound = false;
        for (int i = 0; i < array.length; i++) {
            if (array[i] % 2 != 0 && array[i] >= maxOdd) {
                maxOdd = array[i];
                mmaxOddIndex = i;
                oddFound = true;
            } else if (array[i] % 2 == 0 && array[i] >= maxEven) {
                maxEven = array[i];
                mmaxEvenIndex = i;
                evenFound = true;
            }
        }
        if (oddOrEven.equals("even") && evenFound) {
            System.out.println(mmaxEvenIndex);
        } else if (oddOrEven.equals("odd") && oddFound) {
            System.out.println(mmaxOddIndex);
        } else {
            System.out.println("No matches");
        }
    }

}