Menu

Java Generic Array - Come simulare array generici in Java?

  • Principale
  • Altro
  • Java Generic Array - Come simulare array generici in Java?

java generic array how simulate generic arrays java

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiega come simulare la funzionalità di Generic Array in Java utilizzando Object Array e anche utilizzando Reflection Class con un semplice esempio:

Ne abbiamo già discusso Generici Java in uno dei nostri tutorial precedenti. Java consente classi, metodi, ecc. Generici che possono essere dichiarati indipendentemente dai tipi. Tuttavia, Java non consente all'array di essere generico.

La ragione di ciò è che in Java, gli array contengono informazioni relative ai loro componenti e queste informazioni vengono utilizzate per allocare memoria in fase di runtime. Quando vengono utilizzati generici, a causa della cancellazione del tipo, il codice byte non contiene alcuna informazione sui generici.

=> Visita qui per imparare Java da zero.

Java Generic Array

Cosa imparerai:

Array generico in Java

Se è stato definito un array generico, il tipo di componente non sarà noto in fase di esecuzione. Quindi non è consigliabile definire gli array come generici in Java.

Una definizione di array generico è come mostrato di seguito:

E () newArray = new E(length);

Il compilatore non conosce il tipo esatto di cui creare un'istanza poiché le informazioni sul tipo non sono disponibili in fase di esecuzione.

Quindi, invece di array, ogni volta che sono richiesti generics, dovresti preferire il componente list del framework Java Collections. Tuttavia, è possibile creare strutture generiche simili ad array utilizzando l'array di oggetti e la funzione di riflessione di Java.

Questi due approcci che ci consentono di definire array di diversi tipi di dati sono spiegati di seguito in dettaglio.

siti Web per scaricare i video di YouTube in mp3

Crea e inizializza l'array generico

In questa sezione, creiamo una struttura simile a un array di natura generica. Utilizzando queste strutture, sarai in grado di creare array fornendo il tipo di dati come argomento.

Utilizzo di Object Array

Questo approccio utilizza la matrice di tipo Oggetti come membro della classe matrice principale. Usiamo anche metodi get / set per leggere e impostare gli elementi dell'array. Quindi, istanziamo la classe dell'array principale che ci consente di fornire il tipo di dati come richiesto.

Questo simula l'array generico.

Il seguente programma dimostra l'uso di un array di oggetti per creare una struttura generica simile a un array.

import java.util.Arrays; class Array { private final Object() obj_array; //object array public final int length; // class constructor public Array(int length) { // instantiate a new Object array of specified length obj_array = new Object (length); this.length = length; } // get obj_array(i) E get(int i) { @SuppressWarnings('unchecked') final E e = (E)obj_array(i); return e; } // set e at obj_array(i) void set(int i, E e) { obj_array(i) = e; } @Override public String toString() { return Arrays.toString(obj_array); } } class Main { public static void main(String() args){ final int length = 5; // creating integer array Arrayint_Array = new Array(length); System.out.print('Generic Array :' + ' '); for (int i = 0; i

Produzione:

Utilizzo dell

Nel programma sopra, abbiamo definito una classe Array che è generica. La matrice di oggetti è un membro della classe di cui viene creata un'istanza utilizzando un costruttore e una lunghezza. Usiamo anche i metodi generici get e set che vengono usati per leggere e impostare un elemento di array di un tipo particolare.

Quindi creiamo istanze di questa classe di array. Durante la creazione delle istanze, possiamo specificare il tipo desiderato. Nel programma sopra, abbiamo creato due array di tipo Integer e String e quindi popoliamo questi array con valori appropriati (usando il metodo set).

Infine, utilizzando il metodo 'toString' sovrascritto, mostriamo il contenuto di ciascuna di queste istanze.

Utilizzando la riflessione

In questo approccio, utilizziamo una classe di riflessione per creare un array generico il cui tipo sarà noto solo in fase di esecuzione.

L'approccio è simile al precedente con una sola differenza, ovvero usiamo la classe di riflessione nel costruttore stesso per istanziare un array di oggetti passando esplicitamente le informazioni sul tipo di dati al costruttore della classe.

Questo tipo di informazioni viene passato al metodo di riflessione Array.newInstance.

Il seguente programma mostra l'utilizzo della riflessione per creare un array generico . Si noti che l'intera struttura del programma è simile all'approccio precedente con solo la differenza nell'utilizzo delle funzionalità di riflessione.

importjava.util.Arrays; class Array { private final E() objArray; public final int length; // class constructor public Array(ClassdataType, int length){ // create a new array with the specified data type and length at runtime using reflection this.objArray = (E()) java.lang.reflect.Array.newInstance(dataType, length); this.length = length; } // get element at objArray(i) Eget(int i) { returnobjArray(i); } // assign e to objArray(i) void set(int i, E e) { objArray(i) = e; } @Override public String toString() { return Arrays.toString(objArray); } } class Main { public static void main(String() args){ final int length = 5; // create array with Integer as data type Arrayint_Array = new Array(Integer.class, length); System.out.print('Generic Array:' + ' '); for (int i = 0; i

Produzione:

Utilizzo della riflessione per creare un array generico

Il programma sopra mostra array di due tipi, ovvero Integer e String, creati dalla classe generica Arrays.

Errore di creazione di array generico

Abbiamo già discusso le implicazioni della creazione di array generici in Java e perché non è possibile avere array generici in Java. Un'altra spiegazione è che gli array in Java sono covarianti mentre i generici non lo sono. I generici sono invarianti.

Per covarianza, intendiamo che un array del sottotipo può essere assegnato al suo riferimento al supertipo.

Ciò significa che la seguente dichiarazione funzionerà correttamente.

Number numArray() = new Integer(10);

Poiché Integer è un sottotipo di Number, l'istruzione sopra viene compilata correttamente.

Ma se usiamo lo stesso concetto con i generici, non funzionerà, cioè con i generici, non possiamo assegnare un sottotipo generico a un supertipo generico.

L'istruzione ListobjList = new ArrayList (); darà un errore di compilazione poiché i generici non sono covarianti come gli array.

Tenendo presente il motivo di cui sopra, non possiamo avere qualcosa di simile anche sotto:

come iniziare un nuovo progetto in eclipse
public static ArrayList() myarray = new ArrayList(2);

Questa istruzione non verrà compilata con l'errore, 'Creazione di array generici' poiché non possiamo dichiarare un array di riferimenti a un tipo generico specifico.

Possiamo, tuttavia, creare una matrice di riferimenti a un tipo generico specifico utilizzando caratteri jolly. La dichiarazione di cui sopra può essere compilata con successo con una leggera modifica dell'utilizzo di un carattere jolly come mostrato di seguito.

public static ArrayListmyarray = new ArrayList(5);

La dichiarazione precedente verrà compilata correttamente.

Il seguente programma mostra una dimostrazione dell'utilizzo dei caratteri jolly.

qual è la differenza tra garanzia di qualità e controllo di qualità?
import java.util.*; //generic array class classArr { T tarray(); Arr(T myarray()) { tarray = myarray; } @Override public String toString() { return Arrays.toString(tarray); } } public class Main { public static void main(String() args) { // Arrtarray() = new Arr(5); //error: generic array creation //initialize new array objects Arr arr1 = new Arr(new Integer(){2,4,6,8,10}); System.out.print('Array with Integer type:' + ' '); System.out.println(arr1); Arr arr2 = new Arr(new String(){'aa', 'bb', 'cc', 'dd'}); System.out.print('Array with String type:' + ' '); System.out.println(arr2); //define array objects using wildcard Arrarr3() = new Arr(5); arr3(0) = new Arr(new Integer(){10, 20, 30, 40, 50}); System.out.println('Integer array: ' + arr3(0)); arr3(1) = new Arr(new Float(){1.1f, 2.2f, 3.3f, 4.4f, 5.5f}); System.out.println('Float array: ' + arr3(1)); } }

Produzione:

dimostrazione dell

Nel programma sopra, abbiamo la prima affermazione nel metodo principale che indica l'invarianza dei generici. Questa istruzione farà lampeggiare l'errore di compilazione (mostrato nei commenti). La successiva creazione di array è secondo le regole dei generici e quindi si compilano correttamente.

Domande frequenti

D # 1) Che cos'è un array generico?

Risposta: Gli array che sono indipendenti dal tipo di dati e il cui tipo di informazioni viene valutato in fase di esecuzione sono array generici. I generici sono simili ai modelli in C ++.

D # 2) Potete creare un array generico in Java?

Risposta: Gli array sono covarianti in Java, ovvero qualsiasi array di sottoclassi può essere assegnato a un array di supertipo. I generici, tuttavia, sono invarianti, ovvero non è possibile assegnare un tipo di sottoclasse array al tipo di superclasse.

In secondo luogo, le informazioni generiche vengono rimosse dalla JVM e quindi l'array la cui allocazione di memoria viene eseguita in fase di esecuzione non sa quale tipo deve essere assegnato all'array. Pertanto, array e generici non vanno bene insieme in Java.

D # 3) Cos'è il tipo E in Java?

Risposta: funge da segnaposto per i generici e rappresenta qualsiasi tipo di elemento.

D # 4) Che cos'è la cancellazione del tipo in Java?

Risposta: Un processo eseguito dal compilatore Java mediante il quale i tipi parametrizzati utilizzati nei generics vengono rimossi e mappati ai tipi grezzi nel codice byte. In quanto tale, il codice byte non contiene alcuna informazione sui generici.

D # 5) Cos'è un tipo Raw in Java?

Risposta: I tipi non elaborati sono tipi generici senza utilizzare il parametro type. Per esempio. List è un tipo grezzo; mentre List è un tipo parametrizzato.

Conclusione

In Java, l'array generico non può essere definito direttamente, ovvero non è possibile assegnare un tipo parametrizzato a un riferimento di array. Tuttavia, utilizzando array di oggetti e funzioni di riflessione, è possibile simulare la creazione di array generici.

Abbiamo visto questi due approcci in questo tutorial insieme ai dettagli dell'errore di creazione di array generico e alle possibilità di prevenire tale errore. In poche parole, in Java, si può dire che array e generici non vanno di pari passo poiché gli array sono covarianti mentre i generici sono invarianti.

=> Dai un'occhiata alla guida di formazione Java perfetta qui.

Lettura consigliata

^