Java è un ordine di iterazione foreach su primitive definito con precisione?

Question

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?

Answer 1

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.

Answer 2

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.

Answer 3

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
}

Answer 4

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.