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 perfettamente.

Perché?

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 int [] e si assegna {1, 2, 3} il compilatore sa che si desidera creare un int [] come è scritto proprio lì.

Nel secondo caso in cui si inserisce l'array direttamente nella chiamata del metodo, è necessario utilizzare

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

per dire al compilatore qual è il tuo array.

Answer 2

Il costrutto {} è chiamato inizializzatore di array e viene utilizzato per inizializzare un array in Java. (Riferimento: Sezione 10.6: Inizializzatori di array da The Java Language Specification, Third Edition .)

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

Pertanto, è necessario informare il compilatore del tipo di array scrivendo new Type [] , dove Type è il tipo per il quale viene creato l'array per.

Di seguito sono riportati tutti gli usi validi dell'inizializzatore di array:

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

Come si può vedere, questa notazione può essere utilizzata per molti tipi di dati, quindi non è qualcosa di specifico per numeri interi.

Per quanto riguarda:

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

Il motivo per cui quanto sopra è valido è perché le informazioni sul tipo sono fornite al compilatore nella dichiarazione del tipo variabile, che in questo caso è int [] . Ciò che implica quanto sopra è il seguente:

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

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

Pertanto, l'array creato da new int [] {1, 2, 3} può essere inviato in un metodo o costruttore che accetta un int [] come suo argomento:

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

Answer 3

Ciò è probabilmente dovuto al fatto che l'elenco di inizializzazioni 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

Puoi anche fare così:

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 5

Java non ha davvero inferenza di tipo. Le dichiarazioni delle variabili di matrice sono un caso speciale in la specifica del linguaggio Java, che non si applica ai parametri del metodo. In questo modo sarebbe possibile, ma aggiungerebbe molta complessità alle specifiche, poiché 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 fosse sovraccarico ed esistessero entrambe le versioni?

Answer 6

Le parentesi graffe (se utilizzate nei valori letterali dell'array) possono essere utilizzate solo quando si dichiara l'array :)

Answer 7

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