Se si dispone di un array di tipo di riferimento, il modo più semplice è trasformarlo in un elenco. Niente di nuovo qui:
MyObject array = ... ;Iterator<MyObject> iterator = Arrays.asList(array).iterator();
Le difficoltà sorgono se si dispone di una serie di primitive. Se si dispone di un array int, passandolo a Arrays.asList() non si ottiene un List<Integer>. Invece, ottieni un List<int>, che probabilmente non è quello che vuoi!
Il problema con Iterator in questo caso è che può iterare solo su elementi di tipo di riferimento, non primitive. È possibile creare un iteratore di primitive in scatola da un array primitivo (almeno dal nostro solito trio di int, long e double) avvolgendo prima l’array in un flusso e quindi ottenendo un Iteratore da quello:
int array = ... ;Iterator<Integer> iterator = Arrays.stream(array).iterator();
Puoi usare questo Iteratore nel solito modo. Si noti tuttavia che ogni chiamata a next() finirà per inscatolare il valore primitivo, che comporta un sovraccarico. Se si desidera utilizzare costrutti in stile iteratore ma evitare l’overhead di boxe, è possibile utilizzare i nuovi iteratori primitivi introdotti in Java 8. Si scopre che l’iteratore restituito da un flusso primitivo come IntStream è sia un Iterator<Integer> che il nuovo PrimitiveIterator.OfInt. Questo nuovo iteratore ha un metodo nextInt() che restituisce il valore int dall’iteratore senza boxarlo. Può essere usato come segue:
PrimitiveIterator.OfInt intIterator = Arrays.stream(array).iterator();while (intIterator.hasNext()) { methodTakingInt(intIterator.nextInt());}
Lo stesso vale per gli iteratori long e double, che hanno metodi analoghi nextLong() e nextDouble().
La conversione di array primitivi in flussi primitivi probabilmente soddisfa la maggior parte dei casi d’uso. Tuttavia, esistono questi meccanismi alternativi che consentono di creare costrutti in stile Iteratore di lunga data se necessari.
