Java è un ordine di iterazione foreach su primitive definito con precisione?
Domanda
Codice di esempio:
int a[] = new int[]{0, 1, 2, 3};
int result = 0;
for (int i : a)
result += i;
Il ciclo è garantito per scorrere tra a[0]
, a[1]
, a[2]
, a[3]
in quell'ordine? Credo fermamente che la risposta sia sì, ma questa pagina sembra non indicare in modo inequivocabile l'ordine.
Hai un solido riferimento?
Soluzione
Secondo il JLS, The for
migliorato istruzione , il for-loop equivale a
int[] array = a;
for (int index = 0; index < a.length; index++) {
int i = array[index];
result += i;
}
" dove array
e index
sono identificatori generati dal compilatore che sono distinti da qualsiasi altro identificatore (generato dal compilatore o altro) che rientra nell'ambito nel punto in cui si verifica l'istruzione <=> migliorata . " (parafrasando leggermente i nomi delle variabili qui).
Quindi sì: l'ordine è assolutamente garantito.
Altri suggerimenti
Vedi sezione 14.14.2 della specifica del linguaggio Java , 3a edizione .
Se il tipo di espressione è un sottotipo di Iterable, quindi lascia che sia il tipo di l'espressione Expression.iterator (). La dichiarazione avanzata per è equivalente a una base per la dichiarazione di il modulo:
for (I #i = Expression.iterator(); #i.hasNext(); ) { VariableModifiersopt Type Identifier = #i.next(); Statement }
Dove #i è generato da un compilatore identificatore distinto da qualsiasi altri identificatori (generati dal compilatore o altrimenti) che rientrano nell'ambito (& # 167; 6.3) nel punto in cui il potenziato per si verifica l'istruzione.
Indica JLS che:
for ( VariableModifiersopt Type Identifier: Expression) Statement
è equivalente a
T[] a = Expression;
L1: L2: ... Lm:
for (int i = 0; i < a.length; i++) {
VariableModifiersopt Type Identifier = a[i];
Statement
}
Non ho trovato nulla nella pagina a cui hai fatto riferimento che implichi un'iterazione non ordinata. Puoi pubblicare il preventivo specifico?
In ogni caso, trovo che questo codice:
public static void main( String args[] ) {
double a[] = new double[] { 0, 1, 2, 3 };
int result = 0;
for ( double i : a ) {
result += i;
}
si decompila in loop vecchio stile:
public static void main(String args[])
{
double a[] = {
0.0D, 1.0D, 2D, 3D
};
int result = 0;
double ad[];
int k = (ad = a).length;
for(int j = 0; j < k; j++)
{
double i = ad[j];
result = (int)((double)result + i);
}
}
Ovviamente, non è lo stesso di una garanzia, ma almeno un'iterazione fuori servizio su un array sarebbe molto strana e sembrerebbe andare contro un'evidente implementazione di buon senso.