Adding Elements to a Collection During Iteration

1. Introduction

Iterating over a List is a common operation in Java, but adding elements to it while iterating requires careful consideration to avoid exceptions and ensure the correctness of the code.

In this tutorial, we’ll discuss several methods for adding elements to a collection during iteration.

2. Utilizing the ListIterator Class

One common approach is a ListIterator, which provides bidirectional traversal and modification capabilities for lists.

2.1. String Scenario

Consider the following example, where we add the element JavaScript to the list of programming languages after encountering Python:

List<String> programmingLanguages = new ArrayList<>(List.of("Java", "Python", "C++"));

@Test
public void givenList_whenAddElementWithListIterator_thenModifiedList() {
    ListIterator<String> listIterator = programmingLanguages.listIterator();
    while (listIterator.hasNext()) {
        String language = listIterator.next();
        if (language.equals("Python")) {
            listIterator.add("JavaScript");
        }
    }
    assertIterableEquals(Arrays.asList("Java", "Python", "JavaScript", "C++"), programmingLanguages);
}

In the provided code, we initialize a List named programmingLanguages containing the strings (Java, Python, and C++). In addition, we iterate through the elements of the list using the listIterator.next() method.

When we encounter the element Python we dynamically insert the string JavaScript immediately after it, using listIterator.add(“JavaScript”).

Finally, the test asserts that the modified list matches the expected result, ensuring the successful addition of JavaScript after Python in the list.

2.2. Numeric Scenario

Let’s apply the ListIterator approach to a list of integers, adding double the value when encountering the number 2:

List<Integer> numbers = new ArrayList<>(List.of(1, 2, 3));
@Test
public void givenNumericalList_whenMultiplyElementWithListIterator_thenModifiedList() {
    ListIterator<Integer> listIterator = numbers.listIterator();
    while (listIterator.hasNext()) {
        int num = listIterator.next();
        if (num == 2) {
            listIterator.add(num * 10);
        }
    }
    assertIterableEquals(Arrays.asList(1, 2, 20, 3), numbers);
}

In this numeric scenario, we use the ListIterator to iterate through a list of integers. When the number 2 is encountered, the value is multiplied by 10 and dynamically added to the list.

3. Enhanced for Loop With a Copy

Another strategy involves creating a copy of the original list and iterating over it while modifying the original list.

3.1. String Scenario

Consider the following example, where we add the uppercase version of each word in the original list to the list itself:

@Test
public void givenStringList_whenAddElementWithEnhancedForLoopAndCopy_thenModifiedList() {
    List<String> copyOfWords = new ArrayList<>(programmingLanguages);
    for (String word : copyOfWords) {
        programmingLanguages.add(word.toUpperCase());
    }
    assertIterableEquals(Arrays.asList("Java", "Python", "C++", "JAVA", "PYTHON", "C++"), programmingLanguages);
}

Within the enhanced for loop, we iterate over each element of the copyOfWords list, convert the corresponding value to uppercase, and add it to the original list programmingLanguages.

Notably, this insertion process ensures that the original list is expanded with the uppercase versions of the existing words while maintaining the sequence integrity. In other words, the programmingLanguages list will contain the original elements followed by the newly added uppercase versions.

3.2. Numeric Scenario

Now, let’s apply the enhanced for-loop approach to a list of integers, adding each number multiplied by 2:

List<Integer> numbers = new ArrayList<>(List.of(1, 2, 3));

@Test
public void givenList_whenAddElementWithEnhancedForLoopAndCopy_thenModifiedList() {
    List<Integer> copyOfNumbers = new ArrayList<>(numbers);
    for (int num : copyOfNumbers) {
        numbers.add(num * 2);
    }
    assertIterableEquals(Arrays.asList(1, 2, 3, 2, 4, 6), numbers);
}

Here, we iterate, multiply each element multiplied by 2, and add it to the original list. Same as the string approach,

4. Utilizing the Java 8 Stream Approach

Java 8 Streams provide a concise way to add elements to a list during iteration.

4.1. String Scenario

Consider the following example, where we use Java 8 Streams to add the string JavaScript to the list of programmingLanguages:

@Test
public void givenStringList_whenConvertToUpperCaseWithJava8Stream_thenModifiedList() {
    programmingLanguages = programmingLanguages.stream().map(String::toUpperCase).collect(Collectors.toList());
    assertIterableEquals(Arrays.asList("JAVA", "PYTHON", "C++"), programmingLanguages);
}

In this code snippet, we utilize the map operation to transform each string element in the list to its uppercase equivalent using the toUpperCase method. Then, we collect the transformed elements into a new list using Collectors.toList().

However, it’s essential to note that while the transformation operation appears to directly alter the corresponding original elements in the list in place, it replaces the original list with a new one. This replacement ensures the integrity of the list’s contents, although it effectively removes the original list from memory.

Therefore, while the transformation is performed seamlessly, it’s important to consider the implications, especially if the original list reference is still needed elsewhere in the code.

4.2. Numeric Scenario

Let’s apply the Java 8 Stream approach to a list of integers, multiplying each number by 3:

@Test
public void givenNumericalList_whenMultiplyByThreeWithJava8Stream_thenModifiedList() {
    numbers = numbers.stream().map(num -> num * 3).collect(Collectors.toList());
    assertIterableEquals(Arrays.asList(3, 6, 9), numbers);
}

In this test method, we utilize the map operation, each numeric element in the list undergoes a transformation where it is multiplied by 3. In addition, the resulting stream is collected into a new list through Collectors.toList().

5. Conclusion

In conclusion, we explored diverse methods, including ListIterator, enhanced for loop with a copy, and Java 8 Streams, for adding elements to a list during iteration in Java.