What are the ways to iterate over collections in…

In Java, there are several ways to iterate over collections:

for loop with index (for collections that support index access, such as ArrayList, LinkedList):
Suitable for collections where access to elements by index is efficient.

// Example of iterating over an ArrayList
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

for (int i = 0; i < list.size(); i++) {
    String element = list.get(i);
    System.out.println(element);
}

Enhanced for loop (for-each loop):
The most common and convenient way for most cases. Suitable for any collection implementing Iterable.

// Example of iterating over an ArrayList with for-each
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

for (String element : list) {
    System.out.println(element);
}

Using an Iterator:
A more flexible way that allows removing elements during iteration. Suitable for all collections.

// Example of iteration using Iterator
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
    // You can safely remove elements
    // if (element.equals("B")) {
    //     iterator.remove();
    // }
}

Using ListIterator (for lists):
A specialized iterator for collections implementing List. Allows moving forward and backward, as well as adding and modifying elements.

// Example of iterating with ListIterator
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String element = listIterator.next();
    System.out.println(element);
}
// Example of iterating backwards
while (listIterator.hasPrevious()) {
    String element = listIterator.previous();
    System.out.println(element);
}

Streams API (since Java 8):
A functional approach using lambda expressions. Allows performing operations on collection elements (filtering, transforming, etc.) in a declarative style. Iteration occurs "internally" within the stream.

// Example of iteration using Streams API
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

list.stream()
    .forEach(element -> System.out.println(element));

// Example with filtering and transformation
// list.stream()
//     .filter(element -> element.startsWith("A"))
//     .map(String::toLowerCase)
//     .forEach(System.out::println);

The choice of method depends on the specific task, collection type, and performance requirements. For most cases, the enhanced for loop is the most convenient. If you need to remove elements during iteration, use Iterator. For lists requiring bidirectional iteration, ListIterator is suitable. Streams API offers powerful capabilities for data processing in a declarative style.

What are the ways to iterate over collections in Java?