Inizializzazione di array in java

Ho notato che si potrebbe scrivere un codice come questo, che è perfettamente normale, tra l’altro:

int arrays[] = {1, 2, 3}; for (int n : arrays) System.out.println(n); 

Ma non vedo come questo sia illegale:

 for (int n : {1, 2, 3}) System.out.println(n); 

Dal punto di vista del compilatore, questo non introduce alcuna ambiguità, vero? Ci si può aspettare che il tipo dell’array sia dello stesso tipo dell’elemento dichiarato in precedenza. In altre parole, n è dichiarato come int , quindi l’array deve essere int[]

Hai bisogno di questa syntax:

 for(int n : new int[]{1, 2, 3}) System.out.println(n); 

Da Java Language Specification, §10.6 – Inizializzatori di array :

Un inizializzatore di array viene scritto come un elenco di espressioni separate da virgola, racchiuso tra parentesi graffe {e}.

Una virgola finale può apparire dopo l’ultima espressione in un inizializzatore di array e viene ignorata.

Ogni inizializzatore di variabili deve essere compatibile con l’assegnazione (§5.2) con il tipo di componente dell’array, oppure si verifica un errore di compilazione.

È un errore in fase di compilazione se il tipo di componente dell’array in fase di inizializzazione non è reifiable (§4.7).

Un inizializzatore di array fa parte di un’espressione di creazione dell’array , che definisce che è necessario uno di questi quattro moduli per inizializzare correttamente un array:

 ArrayCreationExpression: new PrimitiveType DimExprs Dimsopt new ClassOrInterfaceType DimExprs Dimsopt new PrimitiveType Dims ArrayInitializer new ClassOrInterfaceType Dims ArrayInitializer 

Di nuovo, dalle specifiche:

È un errore in fase di compilazione se ClassOrInterfaceType non denota un tipo reifiable (§4.7). In caso contrario, ClassOrInterfaceType può denominare qualsiasi tipo di riferimento denominato, anche un tipo di class astratta (§8.1.1.1) o un tipo di interfaccia (§9).

Questo è il motivo per cui è necessaria la syntax new int[] {1, 2, 3} .

EDIT : per ottenere di più nelle sfumature della tua domanda:

Dal punto di vista del compilatore, questo non introduce alcuna ambiguità, vero? Ci si può aspettare che il tipo dell’array sia dello stesso tipo dell’elemento dichiarato in precedenza. In altre parole, n è dichiarato come int, quindi l’array deve essere int []

No. C’è un’ambiguità. Come esempio, qual è la differenza tra le seguenti due affermazioni?

 int[] arr1 = new int[] {1, 2, 3}; short[] arr2 = new short[] {1, 2, 3}; 

La principale differenza è la compilazione in bytecode. Uno è ovviamente un int, l’altro è ovviamente un corto. Tuttavia, senza la capacità di stabilire quale tipo di dati è quale (senza i valori nell’array che superano Short.MAX_VALUE ), sarebbe imansible affermare che, questa matrice, al di là di un’ombra di dubbio, è un int . Ricorda che un short cade nel range di un int , quindi puoi facilmente entrare in alcuni scenari complicati / bizzarri quando lo usi.

Diventa più divertente: questo è un codice valido.

 for(int i : arr2) { System.out.println(i); } 

Ancora una volta, finché gli elementi di arr2 non superano Short.MAX_VALUE , puoi farla Short.MAX_VALUE con questo riferimento ambiguo tra short e int .

Questo è un altro motivo per cui il compilatore non può solo dedurre che intendi int . Potresti dire short . *

*: Non che molte persone lo farebbero mai, ma è nel caso in cui ci sia.

Perché gli array sono oggetti e devono essere istanziati. Java non riconosce {} di per sé come array. Tuttavia, consente di utilizzare un blocco di codice (ad es. Codice in {..}) per definire gli elementi iniziali dell’array.

Il modo in cui lo realizzi è descritto dalla risposta sopra.

Penso che ogni volta che creiamo una variabile, il compilatore assegna automaticamente la memoria ad essa. La quantità di memoria creata dipende dal tipo di compilatore che stai usando. Nella prima dichiarazione dichiari un array con gli input, il compilatore crea automaticamente spazio per il elemento dell’array presente nell’array ma quando si dichiara l’array in ciclo for si crea solo 2 byte di ogni corsa.

Per es.

 int x; // create 2 bytes of memory 

Questo spazio è assegnato in modo permanente a int x se si inserisce o meno un valore in questo spazio.

 int x = "123"; // This code also take 2 bytes of memory and contain value = 123 

Allo stesso modo,

 int a[] ={1,2,3} // create 6 byte of space in memory, 2 byte for each integer variable. 

D’altra parte quando dichiari la matrice in loop for senza usare il nuovo identificatore, il compilatore assume che sia una variabile int e crei solo 2 byte di spazio di memoria e il programma dia errore.

 for (int n : {1, 2, 3}) // create only 2 bytes of memory 

Quindi, utilizzando il nuovo identificatore, allociamo un nuovo spazio di memoria e inseriamo i valori che sono indicati nelle parentesi graffe.

Ad essere onesti, l’unico errore che vedo nella tua spiegazione è come puoi dire a un computer di passare attraverso un object / memoria che non esiste?

Devi creare qualcosa per lasciarlo passare prima, qui, non hai creato nulla e l’errore logico esiste nella tua testa perché hai pensato più in profondità delle regole di creazione di Java stesso.

Non ti preoccupare, mi trovo in situazioni come te ma la cosa più importante è imparare come è stato programmato Java prima!