Newsgroup: it.comp.java
Titolo: dichiarare variabili in maniera "dinamica"

ciao all,
si puň, all'interno di un ciclo, generare "dinamicamente" nomi di
variabili?
mi spiego: in un ciclo devo creare dei one2oneChannel ed ho bisogno
che questi abbiano nomi a questa maniera 
nomeCanale = "P"+i+j (dove i e j sono i contatori del doppio for)
l'ideale sarebbe
for (i=0, i<n, i++)
   for (j =0, j<n, j++)
	one2oneChannel "c"+i+j = new One2OneChannel;
endo for
cosě otterrei n canali i cui nomi sarebbero c00, c01, c02 etc etc
č possibile?
grazie,
bye
-- 
.:Alias:.
icq: 23592321

Perchč non usi una hashmap ?
import java.util.HashMap;
...
HashMap ch = new HashMap();
//Per inserire
ch.put( "c"+i+j, new One2OneChannel());
//Per leggere
One2OneChannel chij = (One2OneChannel)ch.get( "c" + i + j);
Ciao


 
Non č possibile.
E' cosě importante il nome delle variabili?
G.M.

One2OneChannel chij = (One2OneChannel)ch.get( "c" + i + j);
non so se posso usare librerie "non standard"... è per un progettino
per l'università.
cmq guardo lo stesso, grazie


E' così importante il nome delle variabili?
sì xè devo creare, in una matrice di processi, tanti canali di
comunicazione quanti sono i processi (a dire la verità un po' di più,
almeno 4 canali in ingresso e 4 in uscita per ogni processo,
distribuiti come i punti cardinali N-S-O-W)
e devo parametrizzare la cosa altrimenti non finisco più!
anche xè la matrice è parametrica e da essa dipendono strettamente il
numero di processi ... mi sono spiegato?
con il doppio ciclo di sopra sarei riuscito a creare tot canali
dandogli un nome che dipendesse da c=canale più i e j che sono gli
indici di ogni processo della matrice.
per creare le stringhe come sopra non ho problemi il fatto è che poi
non riesco a fare sì che le stringhe generate siano i nomi veri e
propri dei canali.
ciao


 propri dei canali.
Ricordati che stai usando un linguaggio orientato agli oggetti e non il 
GWBasic. La cosa che cerchi di fare non ha infatti nessun senso se pensi 
agli oggetti, basta che le stringhe in oggetto siano i nomi degli oggetti
ciao
uL

".:Alias:." <alias2k@NO_SPAM_libero.it> ha scritto nel messaggio
news:5dbkbvo8hjk7uqetm...@4ax.com...

Non penso proprio!
Ma un semplice array di array di oggetti one2oneChannel non ti dovrebbe
andare bene?
one2oneChannel c[][] = new one2oneChannel[4][4];
..
c[i][j] = new one2oneChannel();
generare variabili dinamicamente č l'ultima cosa che ti deve venire in mente
in programmazione! (non so se ci sono linguaggi che lo permettono e non so a
cosa possa servire).

in programmazione! 
ehm ... #^___^# lo so...
grazie intanto,
bye,


 creati (a livello nomilale almeno) correttamente?
for(int i = 0; i < ... ; i++) {
    for(int j = 0; j < ...; j++)
        c[i][j].stampa();
}
dove magari il metodo stampa manda a video i valori di alcuni campi.
Comunque non ho capito cosa tu intenda con valori nominali.

 cmq guardo lo stesso, grazie
Guarda che le Hashmap (come tutto ciè che sta nel pacchetto java.util.* 
e in java.* in generale) sono parte della libreria standard.
Andrea Polci


grazie, l'ho visto ma io intendevo "non standard" volutamente
virgolettato xè per questo progettino ho la "licenza" di usare solo un
certo numero di librerie usate durante il corso.
ciao e grazie


Bene fatti una classe che gestisca una Stringa e un Oggetto generico così:
class Elem {
    public String name;
    public Object value;
    public Elem( String name, Object value) {
 
this.name
 = name;
	this.value = value;
    }
}
poi (Se puoi gestire i "Vettori") e il vettore che contiene i dati lo 
chiami hash (che fantasia) ti costruisci due funzioni put e get dove la 
prima inserisce il valore
void put( String name, Object value) {
	hash.addElement( new Elem( name, value);
}
e il secondo cerca l'oggetto dato 'name'
Object get( String name) {
	for( int i = 0; i < hash.size(); i++) {
		Elem tmpObj = (Elem)hash.elementAt( i);
		if( tmpObj.name.equals( name)) {
			return tmpObj.value;
		}
	}
	return null;
}
E ti sei costruito l'array associativo
E se non puoi usare i vettori ti costruisci una lista aggiungendo alla 
classe Elem il puntatore all'oggetto precedente (il primo punta a null) 
e definisci una variabile che punta all'ultimo oggetto creato che ti 
serve per ricercare e aggiungere i dati insomma ti guardi come si fanno 
le liste dinamiche in c e fai la stessa cosa usando le classi al posto 
delle strutture. Ma questa è una GG di PM (Gran Galà della Pippa 
Mentale) visto che almeno i vettori dovrebbero essere ammessi :).
E in questo modo eviti pure i Vettori ma a questo punto credo che 
l'esercizio debba essere la lista dinamica e non quello che hai detto 
nel post!
Ciao


Un vettore bidimensionale di One2OneChannel?
Ciao
Franco

Mentale) visto che almeno i vettori dovrebbero essere ammessi :).
^___^
quando  e dove lo fanno!
scherz a part, avendo fornito solo una parte del progettino (ed
essendomi anche probabilmente spiegato male) forse è difficile trovare
la soluzione ideale al caso mio.
Provo a fare un esempio:
ho una matrice (n*n) di processi che devono partire in parallelo e
"riempita" da valori random
Matr_iniziale     con valori pseudocasuali
[1][3][2][5]
[2][4][5][6]
[2][3][4][5]
[4][3][2][1]
ogni processo crea una sottomatrice di dimensione k e il cui intorno è
r, per intorno si intende i valori a nord, sud, est e ovest
dell'elemento i,j della matrice.
ad es: 
prendo la sottomatrice di dimensione k= 2 con intorno r= 1 il cui
indice è 1,1 =>
subMatrice
[4] [5] 
[3] [4] 
subMatrice con intorno r=1
     [3][2]
[2][4][5][6]
[2][3][4][5]
     [3][2]
l'intorno mi serve per calcolare i valori di una nuova matrice che
avrà per ogni elemento i,j un nuovo valore ottenuto facendo la media
dell' i,j iniziale con i valori del suo intorno
quindi:
l'elemento 1,1 della matrice finale sarà dato da 
4 (i,j iniziale) + 3 (valore superiore) + 5 + 3 + 2 (i valori
dell'intorno est, sud, nord) il tutto diviso 5
e così via
il tutto implementato da processi in parallelo con canali one2one per
la comunicazione (più i vari thread che si occupano dei calcoli... ma
non è questo il problema)
quindi io mi devo creare dinamicamente (xè la matrice è parametrica)
dei canali One2One ognuno con il proprio nome che sia indicativo del
processo mittente e del processo destinazione così poi so dove andare
a "pescare" i valori dell'intorno.
naturalmente ogni processo ha un canale in ingresso ed uno in uscita
con i processi dell'intorno.
quindi 1,1 ha un canale input ed uno output con l'elemento 0,1 e anche
con l'elemento 2,1 e così via
ecco xè speravo di trovare un modo il + semplice possibile per creare
dei canali in maniera iterativa e affinchè i nomi di questi canali
avessero poi una logicità (c00c01 doveva rappresentarmi il canale di
uscita dall'elemento 00 al 01, c01c00 era il canale di ingresso di
tale elemento)
più o meno questo è il nocciolo della questione
grazie comunque,
ciao


Un vettore bidimensionale di One2OneChannel?
tipo una cosa cosě?
One2OneChannel[][] canale;
for (int i=0; i < n; i++)
	{
	canale[i] = One2OneChannel.create(2);
	}
non mi va
dove ho cannato?
(scusa il disturbo)
ciao e grazie,


 dove ho cannato?
Fidati che ti va!!
Se stai trattando matrici  o vettori mi spieghi che strutture dati vorresti
utilizzare??
Le viariabili con nomi dinamiche?? Guarda che gli array bidimensionali sono
meglio e sopratutto compilabili!
Le informazioni di certo non vanno associate ai nomi delle varibili, che
servono solamente come aiuto al programmatore. Quindi non ti resta che
utilizzare array.
Non sono per niente complicati anzi!

One2OneChannel[][] v = new One2OneChannel[n][n];
for (i=0, i<n, i++)
   for (j =0, j<n, j++)
     v[i][j] = new One2OneChannel();
Potrebbe andare?
Ciao
Franco

Non sono per niente complicati anzi!
a certe soluzioni sono arrivato dopo grazie al vostro aiuto. (avevo in
testa o cose troppo complicate o irrealizzabili)
procedo con questi suggerimenti e poi magari ti faccio sapere
grazie ancora
bye,
