How to Find the Odd and Even Numbers in an Array?

1. Overview

In Java programming, one frequently encountered task is distinguishing between odd and even numbers within an array. Mastering this technique can enhance the ability to handle data efficiently and implement more sophisticated algorithms.

In this tutorial, we’ll learn how to find the odd and even numbers in an Array using Java.

2. Odd and Even Numbers and the Modulus Operator

Understanding how to classify numbers as odd or even is fundamental before coding. In mathematical terms, even numbers are integers divisible by 2 without leaving a fraction, such as 10 or 22. Odd numbers, however, result in a remainder of 1 when divided by 2, with examples including 7 and 15.

In Java, the modulus operator (%) is commonly used to check whether a number is odd or even. For instance:

• number % 2 == 0 indicates the number is even.
• number % 2 != 0 indicates the number is odd.

3. Identifying Odd and Even Numbers Using Loops

To identify odd and even numbers in an array, we can use loops to iterate over each element and determine its parity. We’ll use in this approach two separate methods: findEvenNumbersWithLoop(int[] numbers) and findOddNumbersWithLoop(int[] numbers).

The findEvenNumbersWithLoop(int[] numbers) method iterates over the array and checks each number to see if it is even by using the modulus operator (%). If “number % 2 == 0″ evaluates to true, the number is added to a list of even numbers.

Conversely, the findOddNumbersWithLoop(int[] numbers) method performs a similar iteration but checks for odd numbers with the condition “number % 2 != 0“.

Let’s implement this approach:

public static List<Integer> findOddNumbersWithLoop(int[] numbers) {
    List<Integer> oddNumbers = new ArrayList<>();
    for (int number : numbers) {
        if (number % 2 != 0) {
            oddNumbers.add(number);
        }
    }
    return oddNumbers;
}

public static List<Integer> findEvenNumbersWithLoop(int[] numbers) {
    List<Integer> evenNumbers = new ArrayList<>();
    for (int number : numbers) {
        if (number % 2 == 0) {
            evenNumbers.add(number);
        }
    }
    return evenNumbers;
}

In this implementation, the findEvenNumbersWithLoop(int[] numbers) method initializes an ArrayList to store even numbers and iterates through the input array, adding each even number to this list. The findOddNumbersWithLoop(int[] numbers) method operates similarly but focuses on collecting odd numbers.

Both methods use a simple for loop to process the array elements, making the code easy to understand and maintain.

4. Identifying Odd and Even Numbers Using Streams

Building on the loop-based methods, we can use Java’s Stream API to achieve similar results in a more modern and efficient manner. The Stream API provides a more concise and readable way to process arrays and identify odd and even numbers.

To transition from the loop-based approach, we’ll create two new methods that leverage streams: findEvenNumbersWithStream(int[] numbers) and findOddNumbersWithStream(int[] numbers). These methods use the filtering capabilities of streams to simplify the code.

Let’s apply this technique to solve the problem of identifying odd and even numbers:

public static List<Integer> findEvenNumbersWithStream(int[] numbers) {
    return Arrays.stream(numbers)
      .filter(number -> number % 2 == 0)
      .boxed()
      .collect(Collectors.toList());
}

public static List<Integer> findOddNumbersWithStream(int[] numbers) {
    return Arrays.stream(numbers)
      .filter(number -> number % 2 != 0)
      .boxed()
      .collect(Collectors.toList());
}

In this above code, the findEvenNumbersWithStream(int[] numbers) and findOddNumbersWithStream(int[] numbers) methods leverage the Stream API to handle an array of primitive integers.

The findEvenNumbersWithStream(int[] numbers) method creates a stream from the array and applies a filter to select only the even numbers, where “number % 2 == 0“. It then collects these filtered results into a List<Integer> using the collect(Collectors.toList()) method.

Similarly, the findOddNumbersWithStream(int[] numbers) method filters the stream to include only odd numbers where “number % 2 != 0″. The results are then collected into a List<Integer> in the same manner.

5. Conclusion

Identifying odd and even numbers in an array is a straightforward task in Java, but it’s a fundamental operation with wide-ranging applications. By using the modulus operator along with simple loops or stream filtering, we can efficiently separate these numbers for various uses.

The concepts and code examples discussed in this article provide a solid foundation for handling similar tasks in your Java programming projects.

As always, the source code is available over on GitHub.