What are the ways to iterate over list elements in Java?

There are several standard ways to iterate over elements of a List:

• for loop with index: The classic approach, allowing access to an element by its position.

// Example with index
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");

for (int i = 0; i < names.size(); i++) {
    String name = names.get(i);
    // Processing logic
}

• Enhanced for loop (for-each): More concise syntax for simple iteration without working with indices.

// Example with for-each
List<Integer> numbers = Arrays.asList(1, 2, 3);

for (Integer number : numbers) {
    // Processing logic
}

• Iterator (Iterator): Provides a way to iterate over collection elements, also allowing safe removal during iteration.

// Example with iterator
List<Double> grades = new LinkedList<>();
grades.add(4.5);
grades.add(5.0);

Iterator<Double> iterator = grades.iterator();
while (iterator.hasNext()) {
    Double grade = iterator.next();
    // Processing logic
    if (grade < 5.0) {
        iterator.remove(); // Safe removal during iteration
    }
}

• ListIterator: Extends Iterator, available for lists, allowing bidirectional traversal, getting current index, and modifying elements.

// Example with ListIterator
List<String> colors = new ArrayList<>(Arrays.asList("Red", "Green", "Blue"));
ListIterator<String> listIterator = colors.listIterator();

while (listIterator.hasNext()) {
    String color = listIterator.next();
    // Processing logic
    if (color.equals("Green")) {
        listIterator.set("Yellow"); // Modifying element
    }
}

while (listIterator.hasPrevious()) {
    String color = listIterator.previous();
    // Processing logic in reverse order
}

• Streams (Stream): Functional approach introduced in Java 8, allowing declarative operations on collection elements.

// Example with streams
List<String> fruits = Arrays.asList("Apple", "Banana", "Orange");

fruits.stream()
      .filter(fruit -> fruit.startsWith("A")) // Filtering
      .forEach(fruit -> { // Processing each element
          // Processing logic
      });

The choice of method depends on the specific task and preferences.