Newsgroup: it.comp.java
Titolo: [niubbo] dim. String; Array VS Liste (?)

Un saluto agli autorevoli membri dell' NG ;-)
Al solito, chiedo consiglio ai maestri di Java (...mmm... troppo
lecchinaggio? :-P)
Due domandine:
1. Il tipo String , ipoteticamente, puň memorizzare una "parola" lunga
quanti caratteri?
    Ad esempio, supponiamo di avere:
                     String a;
e nella variabile 'a' memorizzo una stringa presa da tastiera. Magari
l'utente si č addormentato su un tasto e, quando si sveglia, ha una parola
insensata lunga 10 miliardi di caratteri ....ma batte lo stesso invio.  :-o
Insomma, l'ho romanzata un pň troppo come al mio solito....ma spero abbiate
capito...  :-)
2. Tra un array di interi  con un miliardo di "celle"  , e, una lista con un
miliardo di nodi chi occupa piů memoria ? (la lista , vero??)
Scusate per le domande poste in maniera infantile, ma 'sto progetto per
l'univ. mi sta facendo male....
Ringrazio anticipamente per le risposte che mi avete sempre dato, e ,
sicuro, mi darete!
 - Simone -


--------------------------------
Inviato via 
http://arianna.libero.it/usenet/


Pero' l'array richiede uno spazio continuo di memoria di un miliardo di
celle mentre la lista (Intesa come LinkedList perche ArrayList e Vector mi
risulta si appoggino su array internamente) può essere (generalmente è)
frammentata.
Spero di non aver commesso gravi errori, se fosse imparero' qualcosa di
nuovo.
Ciao.
Paolo.

 Paolo.
La cosa mi inizia a preoccupare sempre piů.
 Non volevo ricorrere a tale "sfacciataggine" ma vi posto un pezzo delle
specifiche del progetto (ho visto che un altro mio "collega" frequenta l' Ng
e troverete una sua mail con l'intero testo del progetto qualche centinaio
di mail piů in alto... ma io vorrei consigli solo su quello che vi vado a
esporre.. ):
"Si richiede il progetto di un tipo astratto di dati NumeroIntero che
permetta di rappresentare e gestire numeri interi (con segno) costituiti di
un numero arbitrario di cifre"
* Dunque, che struttura utilizzereste ?
* Io pensavo di memorizzare, il numero da tastiera, dentro una variabile di
tipo String.... poi, vederne la lunghezza  e sfruttarla per creare un array
nel quale ogni cella contiene una cifra di tale numero. Riflettendo bene,
anche tutto ciň ha una limitazione:  tra le parentesi quadre del costruttore
dell'array ho le stesse limitazioni degli interi... ossia non posso creare
un array con piu di "int" celle di memoria (dunque non posso rappresentare
numeri con cifre che oltrepassano i 2alla32 byte). Giusto? ...dunque sono
"da capo a dodici" .
* Del resto utilizzando delle linked - list qualcuno mi stava facendo notare
che,idealmente, si riuscirebbe a implementare le specifiche del tipo
astratto di dati (intero con numero di cifre arbitrario) , ma ,che facendo
alcune prove, esse "crashano" molto prima dell' array....
Insomma che cribbio posso usare?! :-o
Per ora ho sentito parlare di:
Array (e Matrici);
Vector (ancora devo vedere che sono);
Liste linkate;
ArrayList (che ancora devo vedere);
Spero abbiate ora capito i miei dubbi......
Grazie per le risposte!
- Simone -

 anche tutto ciò ha una limitazione:
[CUT]
Ci sarà sempre una limitazione perché avrai sempre a disposizione un memoria
limitata.
Ma pensaci un attimo. Usi un array di interi ed ogni intero rappresenta 9
cifre del tuo numero. Un array da 2^31-1 (facciamo 2^31 dai, non essere
pignolo :) in cui ogni cella occupa 4 byte è grande 8GB.
Quale calcolatore ha 8GB a disposizione per memorizzare un intero (che
sarebbe di ben 2^31*9 cifre)? Io credo che sia un limite ragionevole ;)
Cmq si puo' teoricamente ancora estendere usando degli array di array ma è
follia pura. 
Per riassumere, l'idea di base te la regala la sun: un array di interi. Per
il segno io avrei usato un boolean, loro usano un int perché assegnano -1
ai negativi 1 ai positivi e 0 a zero.
Prendi la tua bella stringa, consideri i numeri a gruppi di 9 cifre. Ognuno
di questi gruppi diventa un int con Integer.parseInt e lo metti nell'array.
Loro usano big-endian (l'int piu' significativo per primo).
Io, se fossi in te, farei così: guardi se il primo carattere è un - (o un +
o un numero)  e sistemi il segno. In base alla lunghezza della stringa
allochi l'array. Prendi dei gruppi di 9 cifre a partire da destra (quelle
meno significative). Le fai diventare un int e riempi il tuo array (con le
9 cifre meno significative per prime, quindi little-endian).
Alla fine ti ritrovi con un array che rappresenta (in modulo) questo numero:
array[0] + array[1]*10^10 + array[2]*10^20 + ... + array[n]*10^(n*10).
Sapendo questo implementi le operazioni aritmetiche.
Proprio per essere prolisso scrivo faccio un esempio:
12 343938474 636193000 387465647 347210210
array[0] = 347210210
array[1] = 387465647
array[2] = 636193000
array[3] = 343938474
array[4] = 12
Ciao
Matteo
-- 
chi sono e soprattutto chi non sono:
http://www.ilnomedeldominio.it
un piccolo programma per studenti universitari:
http://inutility.ilnomedeldominio.it/imsv/

 
http://www.ilnomedeldominio.it
Un GrandE!!!!
Ci sentiamo presto e grazie per il mega aiuto.... mi vado ad implementare
costruttore e compagnia bella :-))
- Simone -

 dovere , e , magari risultano una stron...ehm "cavoleta" :-)
"Piazzare 9 cifre dentro una cella dell'array" mi sembra
proprio una "cavolata" (per essere gentili!).
Non ti incasinare (ti prego!) con questa storia delle 9 cifre in un 
intero: ne uscirai "pazzo" ben presto.
Un banale array di char (o di int) e' decisamente il tipo di dato da 
adottare!
Sono solo i miei 2 centesimi di EUR per un semplice progettino 
universitario in Java...
- Dario


A parte gli scherzi, ti sono grato per essere intervenuto. In verità, sto
valutando molte cose in questo momento.
- Simone -

 valutando molte cose in questo momento.
Ottimo: un buon design iniziale evita successivi problemi in fase di 
codifica!
- Dario

 adottare!
Con tutte e due le soluzioni dovrà implementare prestiti e riporti tra cifre
o gruppi di cifre. Solo che con dei gruppi ci sono meno operazioni da fare
e occupano meno spazio.
Non vedo il vantaggio di trattare una cifra per volta.
un array con una cifra per cella è una cosa tipo
array[k] *10^k + ...+ array[2] * 10^2 + array[1] *10 + array[0]
uno con un gruppo di cifre per cella del tipo:
array[k] * 10^(k*10) + ... +array[2] * 10^20 + array[1] *10^10 + array[0]
semplicemente piu' compatto. Ma concettualmente identico.
Ciao
Matteo
-- 
chi sono e soprattutto chi non sono:
http://www.ilnomedeldominio.it
un piccolo programma per studenti universitari:
http://inutility.ilnomedeldominio.it/imsv/

 Sono un po' curioso, lo ammetto.
E poi, alla fine, che strada hai scelto?
- Dario