Array Manipulator

package com.scaleFocus;

import java.util.*;
import java.util.function.Predicate;

public class ArrayManipulator {

    static int[] numbers;
    static Predicate<Integer> oddOrEvenTester;

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

        numbers = Arrays.stream(scanner.nextLine().split("\\s+"))
                .mapToInt(s -> Integer.parseInt(s))
                .toArray();

        String commands = scanner.nextLine();

        while (!commands.equals("end")) {
            String [] commandArgs = commands.split("\\s+");
            String command = commandArgs[0];

            switch (command){
                case "exchange":
                    int index= Integer.parseInt(commandArgs[1]);

                    if(isInRange(index)){
                        if (index != numbers.length - 1){
                            numbers = exchange(index);
                        }
                    }else{
                        System.out.println("Invalid index");
                    }
                    break;
                case "max":
                    String oddEven = commandArgs[1];
                    int indexOfMaxOddEven = -1;

                    oddOrEvenTester = createOddOrEvenTester(oddEven);
                    indexOfMaxOddEven = findMaxOddOrEvenIndex(oddOrEvenTester);

                    printIndex(indexOfMaxOddEven);
                    break;
                case "min":
                    String oddOrEven = commandArgs[1];
                    int indexOfMinOddOrEven = -1;

                    oddOrEvenTester = createOddOrEvenTester(oddOrEven);
                    indexOfMinOddOrEven = findMinOddOrEvenIndex(oddOrEvenTester);

                    printIndex(indexOfMinOddOrEven);
                    break;
                case "first":
                    int count= Integer.parseInt(commandArgs[1]);

                    if (count > numbers.length){
                        System.out.println("Invalid count");
                    }else{
                        String evenOdd= commandArgs[2];
                        oddOrEvenTester = createOddOrEvenTester(evenOdd);
                        List<Integer> firstOddEven = findFirstOddEven(count, oddOrEvenTester);
                        System.out.println(firstOddEven.toString());
                    }
                    break;
                case "last":
                    int countOfOddEven= Integer.parseInt(commandArgs[1]);

                    if (countOfOddEven > numbers.length){
                        System.out.println("Invalid count");
                    }else{
                        String evenOrOdd= commandArgs[2];
                        oddOrEvenTester = createOddOrEvenTester(evenOrOdd);
                        Deque<Integer> lastOddEven = findLastOddEven(countOfOddEven, oddOrEvenTester);
                        System.out.println(lastOddEven);
                    }
                    break;
            }

            commands = scanner.nextLine();
        }

        System.out.println(Arrays.toString(numbers));
    }

    private static void printIndex(int indexOfMinOddOrEven) {
        if (indexOfMinOddOrEven == -1) {
            System.out.println("No matches");
        } else {
            System.out.println(indexOfMinOddOrEven);
        }
    }

    private static int findMinOddOrEvenIndex(Predicate<Integer> oddOrEvenTester) {
        int index = -1;
        int minOddNumber = Integer.MAX_VALUE;

        for (int i = numbers.length - 1; i >= 0 ; i--) {
            int number = numbers[i];

            if (oddOrEvenTester.test(number)){
                if (number < minOddNumber){
                    index = i;
                    minOddNumber = number;
                }
            }
        }

        return index;
    }

    private static boolean isInRange(int index) {
        return index>= 0 && index < numbers.length;
    }

    private static Deque<Integer> findLastOddEven(int count, Predicate<Integer> oddOrEvenTester) {
        Deque<Integer> result = new LinkedList<>();

        int resultIndex = 0;

        for (int i = numbers.length - 1; i >= 0 ; i--) {
            int number = numbers[i];

            if (oddOrEvenTester.test(number)){
                result.addFirst(number);
                resultIndex++;
            }

            if (resultIndex >= count){
                break;
            }
        }

        return result;
    }

    private static List<Integer> findFirstOddEven(int count, Predicate<Integer> oddOrEvenTester) {
        List<Integer> result =  new ArrayList<>();
        int resultIndex = 0;

        for (int i = 0; i < numbers.length; i++) {
            int number = numbers[i];

            if (oddOrEvenTester.test(number)){
                result.add(number);
                resultIndex++;
            }

            if (resultIndex >= count){
                break;
            }
        }

        return result;
    }

    private static int findMaxOddOrEvenIndex(Predicate<Integer>oddOrEvenTester) {
        int index = -1;
        int maxNumber = Integer.MIN_VALUE;

        for (int i = numbers.length - 1; i >= 0 ; i--) {
            int number = numbers[i];

            if (oddOrEvenTester.test(number)){
                if (number > maxNumber){
                    index = i;
                    maxNumber = number;
                }
            }
        }

        return index;
    }

    private static int[] exchange(int index) {
        int[] result =  new int[numbers.length];
        int resultIndex = 0;

        for (int i = index + 1; i < numbers.length; i++) {
            result[resultIndex] = numbers[i];
            resultIndex++;
        }

        for (int i = 0; i <= index; i++) {
            result[resultIndex] = numbers[i];
            resultIndex++;
        }

        return result;
    }

    private static Predicate<Integer> createOddOrEvenTester(String oddOrEven) {
        Predicate<Integer> tester = null;

        switch (oddOrEven) {
            case "odd":
                tester = x -> x % 2 != 0;
                break;
            case "even":
                tester = x -> x % 2 == 0;
                break;
        }

        return tester;
    }
}