Java: il modo migliore per scorrere una raccolta (qui ArrayList)

Oggi stavo felicemente programmando quando sono arrivato a un pezzo di codice che ho già usato centinaia di volte:

Iterazione attraverso una raccolta (qui ArrayList)

Per qualche motivo, ho effettivamente esaminato le opzioni di completamento automatico di Eclipse e mi sono chiesto:

Quali sono i casi migliori da usare rispetto agli altri?

Il classico ciclo dell'indice dell'array:

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

L'iteratore haNext () / next ():

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

E il mio preferito perché è così semplice da scrivere:

for (iterable_type iterable_element : collection) {

}

Il primo è utile quando è necessario anche l'indice dell'elemento. Questo è fondamentalmente equivalente alle altre due varianti di ArrayLists, ma sarà molto lento se usi un file LinkedList.

Il secondo è utile quando non è necessario l'indice dell'elemento ma potrebbe essere necessario rimuovere gli elementi durante l'iterazione. Ma questo ha lo svantaggio di essere un po 'troppo prolisso IMO.

Anche la terza versione è la mia scelta preferita. È breve e funziona per tutti i casi in cui non è necessario alcun indice o l'iteratore sottostante (ovvero si accede solo agli elementi, non li si rimuove o si modifica Collectionin alcun modo - che è il caso più comune).

Tutti hanno usi propri:

1. Se hai un iterabile e devi attraversarli incondizionatamente verso tutti loro:

   per (iterable_type iterable_element: collection)

2. Se hai un iterabile ma devi attraversare in modo condizionale:

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

3. Se la struttura dati non implementa iterabile:

   for (int i = 0; i <collection.length; i ++)

C'è anche l'utility stream () di collections con Java 8

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

o

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

Ulteriori informazioni su Java 8 stream e raccolte per il collegamento Wonderers

Nessuno di loro è "migliore" degli altri. Il terzo è, per me, più leggibile, ma a qualcuno che non usa foreach potrebbe sembrare strano (potrebbero preferire il primo). Tutti e 3 sono abbastanza chiari per chiunque capisca Java, quindi scegli quello che ti fa sentire meglio con il codice.

Il primo è il più semplice, quindi è il modello più universale (funziona per gli array, tutti gli iterabili a cui riesco a pensare). Questa è l'unica differenza a cui riesco a pensare. In casi più complicati (es. Devi avere accesso all'indice corrente, o devi filtrare l'elenco), il primo e il secondo caso potrebbero avere più senso, rispettivamente. Per il caso semplice (oggetto iterabile, nessun requisito speciale), il terzo sembra il più pulito.

La prima opzione è migliore per quanto riguarda le prestazioni (poiché ArrayList implementa l'interfaccia RandomAccess). Secondo il documento java, un'implementazione di List dovrebbe implementare l'interfaccia RandomAccess se, per istanze tipiche della classe, questo ciclo:

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

funziona più velocemente di questo ciclo:

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

Spero possa essere d'aiuto. La prima opzione sarebbe lenta per gli elenchi di accesso sequenziale.

Ecco un esempio

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);

             }