[Java] Array di Generics

[Dark Phoenix]

Domandona:

Qual'è il modo più elegante per creare un Array sfruttando il Generics?
ve lo chiedo perchè non viene accettato il codice scritto in questo modo:

public class Esempio<E> {

private E[] buffer;
public Esempio<E>(int dimensione){

this.buffer = new E[dimensione];

}

}

...ho visto che si può creare un array di "Data" per poi fare il cast ma non mi sembra bellissimo... Esiste un modo più elegante?

Spero che in un "Java 7" diano la possibilità di fare Array generici...

[isAlreadyInUse]

Mi sono appena sveglaito dal riposino pomeridiamo e non vorrei dire inesattezze ma se usi una collection? tipo List

[Dark Phoenix]

Non posso/voglio perchè è un fatto intrinseco del mio programma.
Cioè non voglio assolutamente che esista un modo per far crescere il buffer

[andbin]

Originariamente inviato da Dark Phoenix

Spero che in un "Java 7" diano la possibilità di fare Array generici...

Se un giorno cambieranno le cose ... non lo so (e non credo).
Al momento si possono creare array solo di tipi "reifiable". Un tipo è reifiable se è completamente rappresentato a run-time. Ma i generics sono implementati tramite "erasure" e questo porta al fatto che a runtime non ci sono informazioni sui tipi parametrici.

In Java il subtyping degli array è covariante. Integer[] è un sottotipo di Number[] che a sua volta è un sottotipo di Object[]. Questo viene permesso perché nell'oggetto che rappresenta l'array viene reificato (memorizzato) il tipo dell'array e ciò permette di controllare a runtime che non venga assegnato un oggetto di tipo incompatibile con l'array.

Integer[] arr = new Integer[10];
Object[] objs = arr;
objs[0] = "ciao"; // <-------- ArrayStoreException!!

Un controllo a runtime di questo tipo non è possibile con i generics. Infatti è stato deciso che ArrayList<Integer> NON è un sottotipo di ArrayList<Number> o ArrayList<Object>. Proprio perché a runtime l'oggetto è solo un ArrayList e basta, non ci sono informazioni sul tipo da nessuna parte.

Quindi array come ArrayList<Integer>[] o E[] (dove E una type variable) non sono istanziabili.

[Dark Phoenix]

Grazie mille della spiegazione

A questo punto.... il modo più elegante sarebbe incapsulare gli elementi in una nuova classe utilizzante generics e fare un array di questa classe...

mi spiego meglio:
faccio un array di "ArrayObject" dove è Array Object ad utilizzare i generics.

Oppure mi conviene fare un po come fanno le librerie standard che l'array se lo fanno passare? (e.g. ArrayList.toArray)

[andbin]

Originariamente inviato da Dark Phoenix

A questo punto.... il modo più elegante sarebbe incapsulare gli elementi in una nuova classe utilizzante generics e fare un array di questa classe...

mi spiego meglio:
faccio un array di "ArrayObject" dove è Array Object ad utilizzare i generics.

Non credo.
Le classi come java.util.ArrayList tengono internamente un array di Object e quando necessario, fanno un cast alla type variable. Una cosa del tipo:

....
private Object[] elements;

public T get (int index)
{
    return (T) elements[index];
}

Con l'unico svantaggio che in fase di compilazione viene emesso un "unchecked warning" (per via del cast a una type variable), che però si può sopprimere con una apposita annotazione nel codice.

Originariamente inviato da Dark Phoenix

Oppure mi conviene fare un po come fanno le librerie standard che l'array se lo fanno passare? (e.g. ArrayList.toArray)

Quello è per un altro motivo. Collection ha 2 metodi toArray:

Object[] toArray()
<T> T[] toArray(T[] a)

Il primo metodo restituisce un array in cui è reificato il tipo Object, indipendetemente dalla istanziazione della collezione. Non può fare altrimenti, visto che a runtime la collezione internamente non ha alcuna informazione sul tipo (per via della solita erasure).

Nel secondo metodo le cose possono andare diversamente e viene restituito un array in cui è reificato il tipo esatto della istanziazione della collezione. Viene usata la reflection per poter fare ciò.
Se tu hai un ArrayList<String> sei costretto (dal compilatore) a passare al secondo toArray un String[]. Tramite reflection, il metodo può sapere il tipo dell'array e sempre tramite reflection può creare un nuovo array con quel tipo.

Un esempio può chiarire meglio: un metodo generico per creare un nuovo array che contiene N ripetizioni dell'array passato come argomento.

import java.lang.reflect.*;

public class Prova
{
    public static void main (String[] args)
    {
        String[] arr1 = { "a", "b" };

        String[] arr2 = repeatArray (arr1, 3);
        
        for (String s : arr2)
            System.out.print (s + " ");
    }

    public static <T> T[] repeatArray (T[] a, int count)
    {
        T[] out = null;

        if (a != null)
        {
            out = (T[]) Array.newInstance (a.getClass().getComponentType(), a.length * count);

            for (int i = 0; i < count; i++)
                System.arraycopy (a, 0, out, i * a.length, a.length);
        }

        return out;
    }
}

[Dark Phoenix]

Ho capito!

Grazie andbin!

Permettimi di dire: "Ammazza quante ne sai!"