Newsgroup: it.comp.java
Titolo: Le collezioni

Devo creare una classe che contiene un insieme di oggetti di cui non so il
numero a priori. Questi oggetti vengono richiesti dalle altre classi alla
classe contenitore attraverso un nome che li identifica. Quale è nella
vostra esperienza l'implementazione migliore?
E in caso contrario, cioè se non vengono richiesti per nome, ma usati sempre
tutti ciclicamente?
Grazie!

 tutti ciclicamente?
java.util.Vector oppure utilizzi comunque la HashMap (magari perchè ti 
serve l'accesso per chiave) e scorri il contenuto attraverso 
values().iterator().

 values().iterator().
Vorrei solo aggiungere che se non hai bisogno di avere un oggetto 
thread-safe e' piu' efficiente la classe ArrayList
Stesso discorso per HashTable e HashMap. La differenza sta nel fatto che 
HashMap non e' sincronizzata (non e' thread-safe) e consente di 
utilizzare null sia come chiave che come valore.
in pratica:
Map hashtable = new HashTable();
Map hashmap = new HashMap();
hashmap.put(null, "valore");  // OK
hashmap.put("chiave", null);  // OK
hashmap.put(null, null);      // OK
hashtable.put(null, "valore"); // NullPointerException
hashtable.put("chiave", null); // NullPointerException
hashtable.put(null, null);     // NullPointerException
Andrea Polci

 thread-safe e' piu' efficiente la classe ArrayList
Significa che con HashMap e HashTable posso accedere allo stesso oggetto da
due thread separati senza preoccuparni della concorrenza, mentre con
ArrayList no?

 values().iterator().
Nel caso non si conosca il numero a priori un Vector non è molto indicato,
in quanto per ogni elemento in più rialloca tutto il vettore, capisci anche
te che se hai un numero elevato di elementi questa contuinua riallocazione è
molto dispendiosa. Una soluzione, secondo me migliore, in questo caso, è una
LinkedList, che non si rialloca in continuazione, ma aggiunge semplicemente
il nuovo elemento, in coda alla lista.
Ciao.

 ha scritto:

No nn funziona cosi il Vector.
Infatti ogni volta che si supera la dimensione totale del vettore un
Vector di solito raddoppia la capacitai in modo cosi da permettere
l'inserimento di nuovi elementi senza dover allocare nuovo spazio
Di default una istanza di vector ha una capacita iniziale di 10
elementi (se nn è errato). Quindi quando a questo vettore si cerca di
inserire un undicesimo elemento la capacita del vettore raddoppia
(quindi 20 elementi).
La riallocazione del vettore occupa effettivamente risorse quindi
proprio per questo la classe Vector funziona in questo modo.
Si puo comunque specificare la capacita iniziale di un vector e anche
il suo ridomensionamento.... Ad esempio fare in modo che quando un
vector ha superato la sua capacita venga allocato spazio per altri 10
elementi....Simile comportamento è impostabile tramite i costruttori
messi a disposizione dalla stessa classe.
Vector ha i vantaggi dell'utilizzo di un vettore normale e i vantaggi
di una lista di elementi.  La sua dimensione è dinamica e l'accesso
agli elementi avviene usando un semplice indice intero... il
"problema" è appunto nel thread-safe che puo rallentarne un po la
gestione.... e anche nel consumo di memoria maggiore rispetto agli
array e alle liste concatenate

 per ogni elemento in più rialloca tutto il vettore
Non mi pare che sia proprio così. Se non sbaglio parte con una dimensione >
1 e quando viene superata raddoppia l'array.
Quindi le riallocazioni non sono così tante. Al contrario LinkedList deve
allocare un nuovo nodo ogni volta.
Ciao
Matteo
-- 
chi sono e soprattutto chi non sono:
http://www.ilnomedeldominio.it
un piccolo programma per studenti universitari:
http://inutility.ilnomedeldominio.it/imsv/

 l'inserimento di nuovi elementi senza dover allocare nuovo spazio
Per quanto riguarda il numero di riallocazioni necessarie, avete ragione voi
ho sbagliato a leggere in Vector.java, come lavora la ensureCapacityHelper.
Per quanto riguarda l'uso di un Vector per allocare un array di dimensioni
sconosciute continuo a sconsigliarlo, in quanto, su array di grosse
dimensioni, per ridurre il numero di riallocazioni devi usare un valore di
incremento abbastanza alto, il che ti porta, nel momento in cui hai finito
di riempire il vettore, ad avere una grossa quantità di memoria allocata e
non utilizzata, che ti obbliga ad una riallocazione dell'array supplementare
con le dimensioni giuste per poter liberare la memoria che non serve.
(Mettetevi nel momento in cui l'ultimo elemento aggiunto obbliga il vettore
ad aumentare la quantità di memoria a sua disposizione: Aggiunge un blocco
considerevole di memoria per un solo elemento!!!! + una copia integrale del
vecchio vettore nel nuovo). Inoltre, tenete presente che man mano che ci si
avvicina alla dimensione finale dell'array, la copia del vecchio array nel
nuovo tende ad essere più gravosa in termini di tempo.
Ciao.

 wrote in message
news:pNRCc.527042$
rM4.22...@news4.tin.it

No, scusa non sono stato chiaro.
Vector e HashTable sono sincronizzati. Possono essere utilizzati 
contemporaneamente da due thread senza che diano problemi "strani".
HashMap e ArrayList invece non sono sincronizzati, non possono 
essere usati contemporaneamente da due thread diversi, a meno di 
sincronizzarli esternamente.
Detto questo, si ha che:
Vector e ArrayList servono per gestire un elenco di elementi a cui 
si accede tramite un indice o in modo sequenziale.
HashMap e HashTable servono per gestire una mappa che associa ad 
una chiave (esempio una stringa) un valore.
Andrea
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 una chiave (esempio una stringa) un valore.
Considerando che, anche se adesso non č cosě, in fututo volevo implementare
la cosa con un certo numero di threads, pernso che userň HashTable.
Siccome Vector non mi soddisfa molto per prestazioni, č meglio usare
HashTable sia per accesso tramite chiave che sequenziale (con iterator)?
Oppure esiste un altra collezione sincronizzata e piů prestante? (male che
vada sincronizzo dall'estreno)