Java: melhor maneira de iterar por meio de uma coleção (aqui ArrayList)

Hoje eu estava felizmente programando quando cheguei a um trecho de código que já usei centenas de vezes:

Iterando por meio de uma coleção (aqui ArrayList)

Por algum motivo, eu realmente olhei para as opções de preenchimento automático do Eclipse e fiquei pensando:

Quais casos os seguintes loops são melhores para usar do que os outros?

O clássico loop de índice de matriz:

for (int i = 0; i < collection.length; i++) {
  type array_element = collection.get(index);
}

O Iterator hasNext () / next ():

for (Iterator iterator = collection.iterator(); iterator.hasNext();) {
  type type = (type) iterator.next();   
}

E meu favorito porque é tão simples de escrever:

for (iterable_type iterable_element : collection) {

}

O primeiro é útil quando você também precisa do índice do elemento. Isso é basicamente equivalente às outras duas variantes de ArrayLists, mas será muito lento se você usar a LinkedList.

O segundo é útil quando você não precisa do índice do elemento, mas pode precisar remover os elementos durante a iteração. Mas isso tem a desvantagem de ser um pouco prolixo demais.

A terceira versão também é minha escolha preferida. É curto e funciona para todos os casos em que você não precisa de nenhum índice ou do iterador subjacente (ou seja, você está apenas acessando elementos, não os removendo ou modificando de Collectionqualquer forma - que é o caso mais comum).

Todos eles têm seus próprios usos:

1. Se você tiver um iterável e precisar atravessar incondicionalmente para todos eles:

   para (iterable_type iterable_element: coleção)

2. Se você tiver um iterável, mas precisar percorrer condicionalmente:

   for (Iterator iterator = collection.iterator (); iterator.hasNext ();)

3. Se a estrutura de dados não implementar iterável:

   para (int i = 0; i <comprimento da coleção; i ++)

Além disso, há o utilitário stream () das coleções com Java 8

collection.forEach((temp) -> {
            System.out.println(temp);
});

ou

collection.forEach(System.out::println);

Mais informações sobre o Java 8 stream e coleções para link de Wonderers

Nenhum deles é "melhor" do que os outros. O terceiro é, para mim, mais legível, mas para alguém que não usa foreaches pode parecer estranho (eles podem preferir o primeiro). Todos os 3 são bastante claros para qualquer pessoa que entenda de Java, então escolha o que o faz se sentir melhor sobre o código.

O primeiro é o mais básico, portanto, é o padrão mais universal (funciona para arrays, todos os iteráveis ​​que consigo pensar). Essa é a única diferença que consigo pensar. Em casos mais complicados (por exemplo, você precisa ter acesso ao índice atual ou precisa filtrar a lista), o primeiro e o segundo casos podem fazer mais sentido, respectivamente. Para o caso simples (objeto iterável, sem requisitos especiais), o terceiro parece o mais limpo.

A primeira opção é melhor desempenho sábio (como ArrayList implementa interface RandomAccess). De acordo com o documento java, uma implementação de List deve implementar a interface RandomAccess se, para instâncias típicas da classe, este loop:

 for (int i=0, n=list.size(); i < n; i++)
     list.get(i);

corre mais rápido do que este loop:

 for (Iterator i=list.iterator(); i.hasNext(); )
     i.next();

Espero que ajude. A primeira opção seria lenta para listas de acesso sequenciais.

Aqui está um exemplo

Query query = em.createQuery("from Student");
             java.util.List list = query.getResultList();
             for (int i = 0; i < list.size(); i++) 
             {

                 student = (Student) list.get(i);
                 System.out.println(student.id  + "  " + student.age + " " + student.name + " " + student.prenom);

             }