Conversione di matrici con farmaci generici

Question

Qual è la differenza tra le seguenti affermazioni:

List<E>[] x = (List<E>[]) new List[100]; 

e

List<E>[] x = new List[100]; 

Nel mio script è notato che il primo sarebbe un modo corretto per creare un array di farmaci generici (anche se porta a un avvertimento del compilatore). Ma non riesco a capire quale sia l'uso della dichiarazione (List<E>[]). List<E>[] non è nemmeno un proprio tipo, e il compilatore semplicemente sostituirlo con (List[]), così si otterrebbe

List<E>[] x = (List[]) new List[100]; 

una conversione List[]-List[], che è inutile. Quindi, perché inserire un (List<E>[]) in primo luogo?

Answer 1

I generici aggiungono stabilità al codice rendendo più rilevabili i bug in fase di compilazione.

Questa è una parte dal link che ho dato, pensato che come importante, così mi distacco che qui

Questo è un piccolo estratto dalle definizioni delle interfacce Lista e Iterator nel pacchetto java.util:

public interface List <E> { 
    void add(E x); 
    Iterator<E> iterator(); 
} 

public interface Iterator<E> { 
    E next(); 
    boolean hasNext(); 
} 

questo codice dovrebbe essere tutti familiare, fatta eccezione per la roba in angolo di brack ets. Queste sono le dichiarazioni dello formal type parameters delle interfacce List e Iterator.

I parametri di tipo possono essere utilizzati in tutta la dichiarazione generica, piuttosto in cui si utilizzano i tipi ordinari.

Conosciamo le invocazioni del tipo Lista dichiarazione generica, come List. Nell'invocazione (solito chiamato con parametri tipo), tutte le occorrenze del parametro di tipo convenzionale (E in questo caso) sono sostituiti dall'argomento tipo effettivo (in questo caso, intero).

Si potrebbe immaginare che all'elenco Stand per una versione di List dove E è stata uniformemente sostituito da Integer:

public interface IntegerList { 
     void add(Integer x); 
     Iterator<Integer> iterator(); 
    } 

Questa intuizione può essere utile, ma è anche fuorviante.

È utile, perché il tipo di elenco parametrizzato fa sì che abbia metodi simili a questa espansione.

È fuorviante, perché la dichiarazione di un generico non è mai effettivamente espansa in questo modo. Non ci sono più copie del codice - non in origine, non in binario, non su disco e non in memoria.

una dichiarazione di tipo generico è compilato una volta per tutte, e trasformato in un unico file di classe, proprio come una classe ordinaria o interfaccia dichiarazione.

I parametri di tipo sono analoghi ai parametri ordinari utilizzati nei metodi o nei costruttori . Proprio come un metodo ha un valore formale con i parametri che descrivono i tipi di valori su cui opera, una dichiarazione generica di ha parametri di tipo formale. Quando viene invocato un metodo, gli argomenti effettivi vengono sostituiti per i parametri formali e viene valutato il corpo del metodo .

Quando una dichiarazione generica viene richiamato, gli argomenti di tipo reali sono sostituiti per i parametri di tipo formale. E questa è l'importanza di Generics.

si può guardare Qui per more information about Generics

Answer 2

questo:

List<E>[] x = new List[100]; 

dice che x è un tipo di matrice. Gli elementi di tale matrice sono elenchi che possono contenere oggetti di tipo E. E gli stai assegnando una serie di liste che possono contenere qualsiasi oggetto.

L'istruzione successiva:

List<E>[] x = (List<E>[]) new List[100]; 

non è migliore. Il casting non aiuta. Il difetto è ancora lo stesso.

In definitiva, tutto questo è una scusa per fare questo:

List<E>[] x = new List<E>[100]; 

E generici array non sono ammessi in Java. Perché gli array mantengono il loro tipo di elemento in fase di esecuzione, mentre i costrutti generici no. Non ci devono essere array il cui tipo di elemento non sia strettamente definito.

problema è dovuto a definire un tipo di riferimento List<E>[] che, per definizione, non è permesso di essere istanziata in Java. Quindi, evitare di usare tali tipi.

si potrebbe andare con una lista di liste come alternativa.

Answer 3

Come in oggetto generici tipo che viene memorizzato in qualsiasi raccolta sarà di tipo controllato nel punto vengono aggiunti alla raccolta. Principalmente attraverso farmaci generici, codici possono essere comprensibile da altri quelli che non hanno bisogno di sapere su farmaci generici. Quindi inserendo il controllo in fase di compilazione e cancellando in fase di runtime abilita questo comportamento.

si può vedere: http://docs.oracle.com/javase/tutorial/java/generics/