Perché passare {a, b, c} a un metodo non funziona?

Question

Ho provato a passare un elenco di inizializzazione {...} a un costruttore e non ha funzionato. Quando invece l'ho dichiarato in una variabile locale del metodo (int []) ha funzionato in modo impeccabile.

Perché è quello?

public class QuickSort { 
    int[] a; 

    public QuickSort(int[] a) { 
     this.a = a; 
    } 

    public static void main(String[] args) { 
     // ################### 
     // ### WORKS  ## 
     // ################### 
     int[] a = {8,12,79,12,50,44,8,0,7,289,1}; 
     QuickSort sort = new QuickSort(a); 

     // ################### 
     // ### DOESN'T WORK ## 
     // ################### 
     //QuickSort sort = new QuickSort({8,12,79,12,50,44,8,0,7,289,1}); 
    } 
} 

Answer 1

Quando si dichiara un numero int[] e si assegna il numero {1, 2, 3}, il compilatore sa che si desidera creare uno int[] così come è scritto proprio lì.

In quest'ultimo caso in cui ti infili la matrice direttamente nella chiamata di metodo si dovrebbe usare

QuickSort sort = new QuickSort(new int[] {8,12,79,12,50,44,8,0,7,289,1}); 

per dire al compilatore che cosa il vostro array è.

Answer 2

Hai provato a trasmettere l'elenco a int [] prima di passarlo al costruttore?

Answer 3

Ciò è probabilmente dovuto al fatto che l'elenco di inizializzazione non contiene informazioni di digitazione. Prova questo:

QuickSort sort = new QuickSort(new int[] {8,12,79,12,50,44,8,0,7,289,1}); 

Answer 4

Java in realtà non hanno inferenza di tipo. Le dichiarazioni variabili di array sono special case nella specifica del linguaggio Java, una che non si applica ai parametri del metodo. Fare ciò sarebbe possibile, ma aggiungerebbe molta complessità alle specifiche, dal momento che dovrebbe gestire domande come se "{" a "," b "} crea una stringa [] o un oggetto [] - sembra ovvio qui, ma cosa succede se si tratta di oggetti in una gerarchia di tipi complessi? E se il metodo è sovraccarico ed esistono entrambe le versioni?

Answer 5

Si può anche fare in questo modo:

public class QuickSort { 
    int[] a; 

    public QuickSort(int ... a) { 
     this.a = a; 
    } 

    public static void main(String[] args) { 

     QuickSort sort = new QuickSort(8,12,79,12,50,44,8,0,7,289,1); 
    } 
} 

Answer 6

Il {} costrutto è chiamato un inizializzatore array, ed è usato per inizializzare un array in Java. (Riferimento: Section 10.6: Array Initializers da The Java Language Specification, Third Edition.)

Il motivo per cui il passaggio dello {1, 2, 3} non è valido è perché non vi sono informazioni sul tipo associate all'inizializzatore.

Pertanto, è necessario consentire al compilatore di conoscere il tipo di matrice scrivendo new Type[], dove Type è il tipo per il quale è fatto l'array.

I seguenti sono tutti uso valido del inizializzatore dell'array:

• new String[] {"Hello, "World"}
• new Character[] {'A', 'B'}
• new Runnable[] {new Runnable() {public void run() {}}, new Runnable() {public void run() {}}

Come si vede, questa notazione può essere utilizzato per vari tipi di dati , quindi non è qualcosa che è specifico per i numeri interi.

quanto riguarda:

int[] a = {1, 2, 3}; 

Il motivo per cui sopra è valida perché l'informazione tipo viene fornita al compilatore nella dichiarazione del tipo variabile, che in questo caso è int[]. Quello che il sopra è implicando è la seguente:

int[] a = new int[] {1, 2, 3}; 

Ora, se abbiamo new int[] {1, 2, 3}, siamo in grado di creare un nuovo int[] array in posizione, in modo che possono essere gestiti come qualsiasi altro int[] serie sarebbe - è solo che non ha un nome di variabile associato ad esso.

Pertanto, la matrice creata da new int[] {1, 2, 3} può essere inviato in un metodo o costruttore che prende un int[] come argomento:

new Quicksort(new int[] {1, 2, 3}); // This will work. 

Answer 7

graffe (quando usato letterali di array) può essere utilizzato solo quando si dichiara la array :)