Newsgroup: it.comp.java
Titolo: toArray() di Vector

Salve a tutti
ho tentato invano di capire a fondo la differenza tra toArray() e
toArray(Object[]) della classe java.util.Vector
ma non ci sono riuscito. C'è qualcuno che può chiarirmi? E soprattutto
quanto conta la dimensione dell'array passato? (a me sembra niente ecco
perchè chiedo spiegazion in generale)
Ciao



Ciao,
le differenze sono 2:
1. Se l'array passat come parametro e' sufficientemente grande per
contenere gli elementi del Vector, allora non viene creato un nuovo
array, ma viene riempito quello (ponendo a null gli eventuali elementi in
eccesso). In caso contrario viene creato un nuovo array e restituito
quello.
2. L'array che viene creato e' del tipo di quello passato, mentre il
metodo senza parametro produce sempre un array del tipo Object[].
Ovviamente il tipo del reference sara' sempre Object[]: e' il tipo
dell'oggetto che cambia. Questo permette di eseguire dei downcast
altrimenti impossibili, che costringerebbero in alcuni casi a copiare gli
elementi dell'array uno alla volta.
Ad esempio:
Ho un Vector v che contiene degli oggetti di tipo Persona.
Object[] ao = v.toArray();
Non e' possibile scrivere:
Persona[] ap = (Persona[])ao;
o direttamente:
Persona[] ap = (Persona[])v.toArray();
Invece, passando l'array e' possibile:
Persona[] ap = new Persona[10]; // o altra dimensione
ap = (Persona[])v.toArray(ap);
-- 
Lucio Benfante
Brainbench MVP for Java 1
http://www.brainbench.com
MyTranscript: 
http://www.brainbench.com/transcript.jsp?pid=167064

 ap = (Persona[])v.toArray(ap);
Non capisco perchè non possa castare nel primo caso (ma lo so bene che non
posso, visto che dà errore). In fondo gli oggetti contenuti nel Vector sono
istanze di quello che io ho messo dentro, ovvero in questo esempio sono già
oggetti Persona. E inoltre, nel caso che gli passi un'array del tipo Persona
ma di dimensioni inferiori, come fa Vector a restituirimi un array castabile
visto che ne deve ugualmente creare uno nuovo? Dedue il tipo attraverso
refelction?
Grazie.
Ciao
-------------------------------------------------------------------------
Fatti non pugnette! (Palmiro Cangini - Assess. Attività Varie ed Eventuali)
-------------------------------------------------------------------------

 
Il problema non e' il tipo degli oggetti contenuti, ma il tipo dell'array
(sono due cose diverse). Gli array sono oggetti di tipo "implicito",
cioe' non esiste una dichiarazione di classe, ma il loro tipo viene
creato implicitamente dal compilatore quando vengono dichiarati.
L'ereditarieta' funziona nella solita maniera.
Vediamo un esempio, che si capisce meglio:
Supponiamo di avere una classe Padre e una sua sottoclasse Figlio.
Se scrivo:
Padre[] ap = new Padre[10];
Ho un oggetto di tipo "array di Padre", che contiene tutti reference a
Padre. Che tipo di reference posso utilizzare per tale oggetto (cioe'
quali sono i suoi tipi compatibili)? Sono Object (dopotutto tutte le
classi, e quindi anche gli array, discendono da questa), Object[] (dato
che Padre discende da Object) e, ovviamente, Padre[].
Quindi potro' scrivere:
Object o = ap;
Object[] ao = ap;
Padre[] ap2 = ap;
Non potro' invece scrivere:
Figlio[] af = ap;
Invece creando un oggetto di tipo Figlio[] (array di Figlio):
Padre[] ap = new Figlio[10];
Object o = ap;
Object[] ao = ap;
Padre[] ap2 = ap;
Figlio[] af = (Figlio[])ap;
In sintesi, data la seguente struttura di ereditarieta':
Object<--Padre<--Figlio
la struttura di ereditarieta' dei corrispondenti array e':
Object<--Object[]<--Padre[]<--Figlio[]
