Introduction

In Java 8, a new feature called the Stream API was introduced. This feature is great for handling groups of data, such as lists or arrays. It allows us to work with data in a clear and efficient way. With the help of streams, we can easily sort, modify, and summarize data. This guide will specifically explain how to use Java 8 Streams to identify and print odd and even numbers from arrays and lists, making these tasks easier and more organized.

1. Printing Odd and Even Numbers from an Array

An array in Java is a fixed-size collection of elements of the same type. Let's see how we can process an integer array using the Stream API.

Example: Printing Odd and Even Numbers from an Integer Array

import java.util.Arrays;
import java.util.stream.IntStream;

public class OddEvenArray {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        // Printing Even Numbers
        System.out.println("Even Numbers:");
        Arrays.stream(numbers)
              .filter(n -> n % 2 == 0)
              .forEach(System.out::println);

        // Printing Odd Numbers
        System.out.println("Odd Numbers:");
        Arrays.stream(numbers)
              .filter(n -> n % 2 != 0)
              .forEach(System.out::println);
    }
}

Explanation

• Arrays.stream(numbers): Converts the integer array into an IntStream.
• .filter(n -> n % 2 == 0): Filters even numbers.
• .filter(n -> n % 2 != 0): Filters odd numbers.
• .forEach(System.out::println): Prints each filtered number.

2. Printing Odd and Even Numbers from a List

A List in Java is a dynamic collection of elements. We can use Java Streams to process a List<Integer> in a similar way.

Example: Printing Odd and Even Numbers from a List

import java.util.Arrays;
import java.util.List;

public class OddEvenList {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(11, 12, 13, 14, 15, 16, 17, 18, 19, 20);

        // Printing Even Numbers
        System.out.println("Even Numbers:");
        numbers.stream()
               .filter(n -> n % 2 == 0)
               .forEach(System.out::println);

        // Printing Odd Numbers
        System.out.println("Odd Numbers:");
        numbers.stream()
               .filter(n -> n % 2 != 0)
               .forEach(System.out::println);
    }
}

Explanation

• numbers.stream(): Converts the list into a Stream.
• .filter(n -> n % 2 == 0): Filters even numbers.
• .filter(n -> n % 2 != 0): Filters odd numbers.
• .forEach(System.out::println): Prints each filtered number.

3. Using Collectors to Separate Odd and Even Numbers

Instead of printing directly, we can collect odd and even numbers into separate lists.

Example: Storing Odd and Even Numbers in Separate Lists

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class OddEvenCollector {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(21, 22, 23, 24, 25, 26, 27, 28, 29, 30);

        // Collecting odd and even numbers into separate lists
        Map<Boolean, List<Integer>> partitionedNumbers = numbers.stream()
                .collect(Collectors.partitioningBy(n -> n % 2 == 0));

        List<Integer> evenNumbers = partitionedNumbers.get(true);
        List<Integer> oddNumbers = partitionedNumbers.get(false);

        System.out.println("Even Numbers: " + evenNumbers);
        System.out.println("Odd Numbers: " + oddNumbers);
    }
}

Explanation

• .collect(Collectors.partitioningBy(n -> n % 2 == 0)): Groups numbers into true (even) and false (odd).
• partitionedNumbers.get(true): Retrieves even numbers.
• partitionedNumbers.get(false): Retrieves odd numbers.

4. Using Parallel Streams for Performance Optimization

If you're dealing with large datasets, you can use parallel streams for better performance.

Example: Using Parallel Streams

import java.util.Arrays;
import java.util.List;

public class ParallelOddEven {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(31, 32, 33, 34, 35, 36, 37, 38, 39, 40);

        System.out.println("Even Numbers:");
        numbers.parallelStream()
               .filter(n -> n % 2 == 0)
               .forEach(System.out::println);

        System.out.println("Odd Numbers:");
        numbers.parallelStream()
               .filter(n -> n % 2 != 0)
               .forEach(System.out::println);
    }
}

Explanation

• .parallelStream(): Converts the list into a parallel stream for better performance on large datasets.
• Parallel execution can speed up filtering and processing.

Conclusion

Using Java 8 Streams, filtering odd and even numbers from arrays and lists becomes concise and efficient. The key techniques include:

1. Using .stream().filter() to print odd/even numbers.
2. Using .collect(Collectors.partitioningBy()) to store odd/even numbers separately.
3. Using .parallelStream() for handling large datasets efficiently.