输入一个数组的元素个数，将数组输入并显示数组的奇偶元素在其指定的arrays

Question

I have written the question I have to write the code for in the title but I am getting certain errors in my code.
The errors are:
line 7: numOfVal cannot be resolved or is not a field
line 23: numOfVal cannot be resolved to a variable
line 25: cannot invoke add(int) on the array type int[]
line 28: cannot invoke add(int) on the array type int[]
line 47: oddarray cannot be resolved to a variable
line 48: evenarray cannot be resolved to a variable
I would be very grateful if you could help me fix the errors in my code.
Thanks.

import java.util.Scanner;

public class CountEvenOddArray {
    int[] mainarray;
    void setInpLength(int numOfVal) {
        this.numOfVal = numOfVal;
    }
    void setVal(int index,
            int Val) {
        this.mainarray[index] = Val;
    }
    
    void MainArrays() {
        mainarray = new int[100];
    }
    
    
    void EvenOdds() {
        
        int evenarray[] = new int[100];
        int oddarray[] = new int[100];
        for (int i = 0; i <numOfVal ; i++ ) {
            if (mainarray[i]%2 == 0) {
                evenarray = evenarray.add(mainarray[i]);
            }
            else {
                oddarray = oddarray.add(mainarray[i]);
            }
        }
    }
    public static void main(String[] args) {
        CountEvenOddArray abc = new CountEvenOddArray();
        int numOfVal;
        int mainarray[]  = new int[100];
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter number of elements you want to store:");
        numOfVal = sc.nextInt();
        abc.setInpLength(numOfVal);
        
        System.out.println("Enter the elements of the array: ");
        for (int k = 0; k < numOfVal; k++ ) {
            abc.setVal(k, sc.nextInt());
        }
        abc.EvenOdds();
        sc.close();
        System.out.println("The array with the odd elements is:" + oddarray);
        System.out.println("The array with the even elements is:" + evenarray);
    }
}  ```

Answer 1

Here is a runnable example of how this task could be accomplished. You will notice that there are very few methods required. Having too many methods to carry out single simple tasks that can be accomplished with single lines of code just makes things harder to follow and bloats the application. Be sure to read the comments within the code:

import java.util.Scanner;

public class CountEvenOddArray {
    
    // Class member variables:
    private final String LS = System.lineSeparator();
    private int[] mainArray; 

    // Startup main() method (Application entry point):
    public static void main(String[] args) {
        // App started this way to avoid the need for statics:
        new CountEvenOddArray().startApp(args);
    }
    
    private void startApp(String[] args) {
        /* Open a keyboard input stream. You only ever need one 
           of these in any console application. Do not close this 
           stream unless you know for sure that you will never need 
           it again during your application session otherwise, you 
           will need to restart the application to use it again.
           The JVM will automatically close this resource when the 
           application ends.                       */
        Scanner sc = new Scanner(System.in);
        
        // Get the desired size of Main Array from User:
        String numOfElems = "";
        while(numOfElems.isEmpty()) {        
            System.out.println("Enter number of elements you want to store or");
            System.out.print(  "enter 'q' to quit: -> ");
            numOfElems = sc.nextLine().trim();
            // Is Quit desired?
            if (numOfElems.equalsIgnoreCase("q")) {
                // Yes....
                System.out.println("Quiting - Bye Bye");
                return; // Will force a return to main() and effectively end application.
            }
            // Entry Validation...
            /* If the entry does not match a string representation of a
               integer value. (See the isInteger() method below): */
            if (!isInteger(numOfElems)) {
                // Then inform the User and let him/her try again...
                System.out.println("Invalid Entry! (" + numOfElems + ") Try again..." + LS);
                numOfElems = ""; // Empty variable to ensure re-loop.
            }
        }
        
        // If we made it the far, then the entry is valid!
        // Convert the string input value to integer:
        int numOfElements = Integer.parseInt(numOfElems);
        
        // Initialize mainArray{}:
        mainArray = new int[numOfElements];
        
        // Have User enter the elements for the Array (with validation):
        System.out.println();
        System.out.println("Enter the elements of the array ('q' to quit):");
        for (int i = 0; i < numOfElements; i++ ) {
            // Prompt for each required mainArray[] Element:
            String elem = "";
            while (elem.isEmpty()) {
                System.out.print("Enter Element #" + (i+1) + ": -> ");
                elem = sc.nextLine().trim();
                // Is Quit desired?
                if (elem.equalsIgnoreCase("q")) {
                    // Yes....
                    System.out.println("Quiting - Bye Bye");
                    return; // Will force a return to main() and effectively end application.
                }
                // Entry Validation...
                /* If the entry does not match a string representation of a
                   integer value. (See the isInteger() method below): */
                if (!isInteger(elem)) {
                    // Then inform the User and let him/her try again...
                    System.out.println("Invalid Entry! (" + elem + ") Try again..." + LS);
                    elem = ""; // Empty variable to ensure re-loop.
                }
            }
            
            // If we made it the far, then the entry is valid!
            // Convert the string input value to integer element:
            int element = Integer.parseInt(elem);
            mainArray[i] = element;
        }
        
        /* mainArray[] is now initialized and filled. We will now create 
           the oddArray[] and evenArray[] from what is in the mainArray[]
           but, because we have no idea what the User may have entered 
           for element values, there is no real viable way to create exact
           fixed length int[] odd or even arrays unless we count them first. 
           This would require additional iterations basically meaning, we 
           are doing the job twice. We can get around this by placing our 
           odd/even results into a couple of List<Integer> Lists (which can 
           grow dynamically) then converting them to array later (if desired):  */
        java.util.List<Integer> odd = new java.util.ArrayList<>();
        java.util.List<Integer> even = new java.util.ArrayList<>();
        
        /* Determine Odd or Even value elements within the mainArray[]
           and place those values into the appropriate odd or even Lists.     */
        evenOdds(odd, even);
        
        // Convert Lists to int[] Arrays....
        // Convert List<Integer> odd to oddArray[]:
        int[] oddArray = odd.stream().mapToInt(d -> d).toArray();
        
        // Convert List<Integer> even to evenArray[]:
        int[] evenArray = even.stream().mapToInt(d -> d).toArray();
        
        // Display the oddArray[] and the evenArray[]...
        System.out.println();
        System.out.println(oddArray.length + " odd elements are in the oddArray[]:   -> " 
                            + java.util.Arrays.toString(oddArray));
        System.out.println(evenArray.length + " even elements are in the evenArray[]: -> " 
                            + java.util.Arrays.toString(evenArray));
    }
    
    /* Method to determine Odd or Even value elements within the mainArray[]
       and place those values into the appropriate odd or even Lists. The
       Lists are added to by way of reference to them therefore no returnable
       objects are required.   
    */
    private void evenOdds(java.util.List<Integer> odd, java.util.List<Integer> even ) {
        for (int i = 0; i < mainArray.length ; i++ ) {
            if (mainArray[i] % 2 == 0) {
                even.add(mainArray[i]);
            }
            else {
                odd.add(mainArray[i]);
            }
        }
    }
    
    public boolean isInteger(String value) {
        boolean result = true; // Assume true:
        // Is value null or empty?
        if (value == null || value.trim().isEmpty()) {
            result = false;
        }
        /* Is value a match to a string representation of 
           a integer value?        */
        else if (!value.matches("\\d+")) {
            result = false;
        }
        // Does value actually fall within the relm of an `int` data type?
        else {
            long lng = Long.parseLong(value);
            if (lng > Integer.MAX_VALUE || lng < Integer.MIN_VALUE) {
                result = false;
            }
        }
        return result;
    }
}

If run and your entries are like this within the Console Window:

Enter number of elements you want to store or
enter 'q' to quit: -> 5

Enter the elements of the array ('q' to quit):
Enter Element #1: -> 1
Enter Element #2: -> 3
Enter Element #3: -> 2
Enter Element #4: -> 5
Enter Element #5: -> 4

You should see something like this:

3 odd elements are in the oddArray[]:   -> [1, 3, 5]
2 even elements are in the evenArray[]: -> [2, 4]