Jaké jsou způsoby iterace přes kolekce v Java?

Existuje několik způsobů iterace přes kolekce v jazyce Java:

• Cyklus for s použitím indexu (pro kolekce podporující přístup podle indexu, například ArrayList, LinkedList):
  Vhodné pro kolekce, kde je přístup k prvkům podle indexu efektivní.

  // Příklad iterace přes 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);
  }
  

• Rozšířený cyklus for (Enhanced for loop / for-each loop):
  Nejčastější a nejpohodlnější způsob. Vhodné pro jakékoli kolekce implementující rozhraní Iterable.

  // Příklad iterace přes ArrayList s použitím for-each
  ArrayList<String> list = new ArrayList<>();
  list.add("A");
  list.add("B");
  list.add("C");
  
  for (String element : list) {
      System.out.println(element);
  }
  

• Použití Iterator:
  Flexibilnější způsob, umožňuje odstraňování prvků během iterace. Vhodné pro všechny kolekce.

  // Příklad iterace s použitím `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);
      // Bezpečné odstraňování prvků
      // if (element.equals("B")) {
      //     iterator.remove();
      // }
  }
  

• Použití ListIterator (pro seznamy):
  Specializovaný iterator pro kolekce implementující rozhraní List. Umožňuje pohyb dopředu i dozadu, přidávání a měnění prvků.

  // Příklad iterace s použitím `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);
  }
  // Příklad iterace zpět
  while (listIterator.hasPrevious()) {
      String element = listIterator.previous();
      System.out.println(element);
  }
  

• Streams API (od Java 8):
  Funkcionální přístup s použitím lambda výrazů. Umožňuje provádět operace nad prvky kolekce (filtrace, transformace atd.) deklarativním stylem. Iterace probíhá "vnitřně" v rámci proudu.

  // Příklad iterace s použitím Streams API
  ArrayList<String> list = new ArrayList<>();
  list.add("A");
  list.add("B");
  list.add("C");
  
  list.stream()
      .forEach(element -> System.out.println(element));
  
  // Příklad s filtrováním a transformací
  // list.stream()
  //     .filter(element -> element.startsWith("A"))
  //     .map(String::toLowerCase)
  //     .forEach(System.out::println);
  

Volba vhodného způsobu závisí na konkrétním úkolu, typu kolekce a požadovaném výkonu. U většiny případů je nejpohodlnější rozšířený for cyklus. Pokud je potřeba odstraňovat prvky během iterace, je vhodnější použít Iterator. Pro seznamy, kde je potřeba obousměrná iterace, je vhodný ListIterator. Streams API nabízí mocné možnosti pro zpracování dat deklarativním stylem.