Splitting a list into two sub-lists is a common task in programming, especially in Java. This process involves dividing a list into two separate lists based on a certain condition or criteria. This can be useful in various scenarios, such as filtering data, organizing information, or performing calculations on specific subsets of a list.
In this article, we will discuss how to split a list into two sub-lists in Java using different approaches and techniques. So, let's dive in!
Method 1: Using a for loop and if statement
The first method we will explore is using a for loop and if statement to split a list into two sub-lists. This approach involves iterating through the original list and adding elements to the appropriate sub-list based on a condition.
Let's take a look at an example. We have a list of numbers, and we want to split it into two sub-lists, one containing even numbers and the other containing odd numbers.
```
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> evenNumbers = new ArrayList<>();
List<Integer> oddNumbers = new ArrayList<>();
for (int num : numbers) {
if (num % 2 == 0) { // checking if the number is even
evenNumbers.add(num); // adding to the evenNumbers list
} else {
oddNumbers.add(num); // adding to the oddNumbers list
}
}
```
In this example, we use a for loop to iterate through the list of numbers. Inside the loop, we use an if statement to check if the current number is even or odd. If it is even, we add it to the evenNumbers list, and if it is odd, we add it to the oddNumbers list.
At the end of this process, we will have two separate lists, one containing even numbers and the other containing odd numbers. This method is simple and easy to implement, but it may not be efficient for large lists.
Method 2: Using the Stream API
The Stream API in Java provides a powerful and concise way to manipulate and process data. We can also use it to split a list into two sub-lists based on a condition. Let's see how we can achieve this using the filter() method in the Stream API.
```
List<Integer> evenNumbers = numbers.stream()
.filter(num -> num % 2 == 0) // filtering out even numbers
.collect(Collectors.toList()); // collecting the filtered elements into a new list
List<Integer> oddNumbers = numbers.stream()
.filter(num -> num % 2 != 0) // filtering out odd numbers
.collect(Collectors.toList()); // collecting the filtered elements into a new list
```
In this example, we use the filter() method to create two separate streams, one for even numbers and one for odd numbers. We then use the collect() method to collect the filtered elements into two new lists.
Using the Stream API can make our code more concise and readable, and it can also improve performance for large lists. However, it may not be suitable for beginners as it involves understanding how streams work.
Method 3: Using the partitioningBy() method
Java 8 introduced the partitioningBy() method in the Collectors class, which allows us to partition a list into two
