Newsgroup: it.comp.java
Titolo: Aiuto nella scelta della struttura dati più adeguata

Ciao a tutti.
Dovrei memorizzare in una struttura dati il riferimento a "n" oggetti.
"n" é un numero indefinito che non conosco a priori, quindi già questo
mi fà intuire che la struttura dati non può essere statica (per
esempio un array non và bene).
Per ciascuno di questi "n" oggetti abbiamo una coppia di thread
(Worker e Server) che si sincronizzano tra loro usando come tramite
l'oggetto corrente.
Quindi abbiamo:
worker1---oggetto1---server1
.
.
.
workerN---oggettoN---serverN
Ogni oggetto dovrà essere creato e inserito nella struttura dati o dal
Worker o dal Server che ci lavorerà sopra.
L'inserimento dovrebbe essere fatto attraverso un indice nella
struttura dati per esempio:
Worker1 inserisce oggetto1 nella struttura dati in posizione1
Server5 inserisce oggetto5 nella struttura dati in posizione5
Per fare questo sto provando a usare un Vector ma ho due problemi che
si riconducono alla stessa
eccezione...ArrayIndexOutOfBoundException   :-(
1) Attualmente provo a verificare se un oggetto é presente nel vector
con:
if(vector.elementAt(indice) == null)
come posso verifificare la presenza del riferimento a un oggetto senza
generare la precedente eccezione?
2) Se provo a inserire nel vector dei riferimenti a oggetti evitando
di usare due indici consecutivi, (per esempio inserendo il primo
oggetto all'indice 0 e, il secondo all'indice 3) viene generata la
precedente eccezione.
Come potrei risolvere questi due problemi?
Grazie a tutte le persone che mi vorranno aiutare.
Ciao

 Ciao
Ciao 

 (Infatti, perchè usare vector?)
uhhhhmmmm
(This class is roughly equivalent to Vector, except that it is 
unsynchronized.)
E per lui forse e' meglio il Vector che l'ArrayList
Anche ad ArrayList se gli chiedi un indice che non e' sull'array
ti risponde
ArrayIndexOutOfBoundException
--
ac

 Come potrei risolvere questi due problemi?
Usando contenitori con chiavi associative?
(HashMap e LinkedHashMap)
--
ac

 ac
Ma si sono d'accordo con questa affermazione, anzi io userei una
TreeMap così nel frattempo che inserisce le coppie se le ritrova già
belle e ordinate (ammesso sempre che ad ogni numero corrisponda un
solo "oggetto" che lo accompagna).


Appunto, non basta un try-catch ?
O anche fare in modo di inserire gli indici in ordine... 

toto ha scritto:

Certo che basta.
Dall'esempio che fa lui, non e' che lo abbia guardato cosi' 
approfonditamente, sembra che voglia/possa inserire indici non contigui.
La questione e' che si dovrebbe, in questo caso, avere il modo di sapere
quali indici sono stati inseriti e comunque Vector ha il metodo per 
sapere se c'e'.
La mia annotazione voleva semplicemente far notare la stretta 
somiglianza fra ArrayList e Vector (per quel che leggo). E lui, da 
quanto mi sembra di capire, ha bisogno di un oggetto "sincronizzabile". 
Ed anche il fatto che un array, in qualsiasi linguaggio che ho 
incontrato (tranne assèmbler che se ne sbatte di tutto), in caso di 
"outofbound" ti dà "outofbound". Sarebbe un disastro se non lo facesse.
E tu la cosa la avevi messa sull' "oppure". i.e.
"Un try-catch che la gestisce?
Oppure puoi usare arraylist,"
Probabilmente avevo capito male.
--
ac

 "outofbound" ti dà "outofbound". Sarebbe un disastro se non lo facesse.
Quindi tu il C non l'hai mai incontrato?

Il fatto é che il codice che sto realizzando é in javaMe e all'interno
di "java.utils" mi é sembrato di non poter utilizzare le arrayList,
quindi Vector é stata una scelta obbligata.
La necessità di memorizzare l'oggetto(i) esattamente nell'indice (i)
della struttura dati é data dal fatto che un Worker(i) o un Server(i),
per come ho pensato io, andranno a ricercare il loro oggetto di
sincronizzazione nella posizione (i).
Non ho mai usato le hash table e non so come funzionano ma se sono
l'unica soluzione...BEN VENGANO.
Se mi consentono:
- la memorizzazione di riferimenti agli "n" oggetti usando come chiave
l'indice (i)
- la ricerca da parte dei Worker o dei Server del loro oggetto si
sincronizzazione fornendo come chiave l'indice (i)
dovrei essere apposto...
Certo che il mio problema 1) rimarrebbe sempre, però a questo punto
potrei forse effettivamente gestirlo con un try-catch in questo modo:
- Il worker o il server fornisce il proprio (i)
- cerco nella tabella se esiste un oggetto con chiave (i)
- se esiste restituisco al chiamante il suo riferimento
- se non esiste (forse) verrà generata una eccezione che catturerò
andando quindi a creare un nuovo oggetto con chiave (i)

 andando quindi a creare un nuovo oggetto con chiave (i)
map.get(<chiave non nulla>)
non genera alcuna eccezione, in nessun caso. E aggiungo anche "ci
mancherebbe altro".

 Come potrei risolvere questi due problemi?
Purtroppo vanno inseriti incrementalmente in un Vector. Puoi valutare le  
altre strutture dati consigliate dagli altri.

Sto provando a usare una HashTable usando l'indice passato dal Worker
o dal Server come chiave.
Siccome non ho mai usato questo tipo di struttura dati, se non vi
dispiace, avrei un altro paio di domandine...
Il metodo (creaObjSincronia) tramite cui i Server(i) e i Worker(i)
creano un nuovo oggetto di sincronizzazione e/o ne recuperano il
riferimento, é un metodo di un altro thread chiamato SuperServer.
Quando provavo a usare un Vector questo metodo aveva il modificatore
"synchronized" per garantire l'accesso eslusivo e evitare quindi che
una coppia (Server-Worker) creasse due volte il suo oggetto di
sincronizzazione.
Il metodo é il seguente:
1 synchronized public ObjSincronia creaObjSincronia(int id){
2
3    if(tableObjSincronia.get(new Integer(id)) == null){
4        tableObjSincronia.put(new Integer(id), new ObjSincronia() );
5    }
6
7    return (ObjSincronia) tableObjSincronia.get(new Integer(id) );
8    }
1) Ho letto nella documentazione che le HashTable sono già
sincronizzate, quindi secondo voi, mi conviene COMUNQUE mantenere il
modificatore synchronized?
2) Il metodo get su una HashTable ritorna un oggetto di tipo Object.
Secondo voi, visto che il metodo deve restituire un riferimento a un
oggetto di tipo "ObjSincronia", é meglio fare il casting come faccio a
riga 7, oppure, conviene modificare riga 1 facendo ritornare un tipo
"Object" senza fare il casting di riga 7 e modificando anche Server e
Worker?
Grazie per l'aiuto.

 Grazie per l'aiuto.
Prego

 tornare un Object.
in effetti l'oggetto di sincronia contiene due metodi synchronized
(leggi() usato dal Worker e scrivi() usato dal Server) quindi credo
che, come giustamenti mi suggerivi, farò il casting e restituirò un
oggetto di tipo ObjSincronia (come già faccio)
Grazie ancora