Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

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.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW