Newsgroup: it.comp.java
Titolo: Generare una stringa di dimensione a scelta in byte

Ciao ragazzi, chi mi indica un modo efficiente di generare una stringa, di 
tipo string, grossa quanto voglio io? Per esempio di 100byte o 1Kbyte ...
Grazie anticipatamente
Tore 


Potresti utilizzare uno StringBuilder che nel costruttore accetta un
parametro intero che indica il numero di caratteri iniziali da
allocare. A seconda di quando occupa un carattere (1 o 2 byte, ora non
ricordo) sai quando e' lunga la stringa.

 tipo string, grossa quanto voglio io? Per esempio di 100byte o 1Kbyte ...
Ma che intendi per generare una stringa grossa 100byte?
Quale dovrebbe essere il contenuto?
E per byte intendi proprio byte o caratteri?
Andrea

ReDDy ha scritto:

Veramente quello indica la dimensione iniziale del "buffer" e non della 
stringa.
Ad esempio se fai:
StringBuilder sb = new StringBuilder(100);
String s = sb.toString();
La stringa s sarà una stringa vuota (di lunghezza 0), anche se per 
costruirla hai allocato spazio per cento caratteri (che poi non hai 
utilizzato).
Il parametro del costruttore di StringBuilder serve esclusivamente per 
ottimizzare le prestazioni nel caso si conosca la dimensione massima che 
occuperà la stringa che si va a costruire.
Andrea

 ha scritto nel messaggio 
news:Cqeci.6238$y05...@tornado.fastwebnet.it...

Intendo una stringa di contenuto qualsiasi, anche tutti zeri, ma che sia di 
dimensione scelta da me in byte intesi proprio come byte e non caratteri...
Neanche io ricordo se un unico carattere misura 1 o 2 byte... 

Tore ha scritto:

A questo punto sorge spontanea un'altra domanda: visto che una stringa 
non è modificabile e non ti interessa il suo contenuto, che ci fai di 
una stringa di una certa lunghezza? Proprio non riesco ad immaginarlo.
In ogni caso dovresti poter utilizzare uno dei costruttori della classe 
String ma attenzione al fatto che anche quello che prende come argomento 
un array di byte, prima trasforma ogni byte in un char: partendo da un 
array di 100 byte non ottieni necessariamente una stringa che occupa 100 
byte.
Andrea

 ha scritto nel messaggio 
news:49rci.7065$y05....@tornado.fastwebnet.it...

Ciao Andrea, e grazie per la disponibilità...
devo dire che hai beccato in pieno il problema... infatti a me serve la 
sicurezza della dimensione della stringa... un sistema potrebbe essere la 
conversione in byte, e anche qui come dici tu mi da l'impressione che la 
conversione non sia esatta.
Cmq, le stringhe di una certa lunghezza mi servono perchè stò sviluppando un 
software che mi permetta di misurare le prestazioni delle reti e per far ciò 
ho bisogno di inviare pacchetti di dimensione variabile e fissati da me... e 
per questo avevo pensato alle stringhe che posso anche usare per trasportare 
informazioni...
Tore 

Le stringhe sono codificate in UTF-8 cioè Unicode quindi 2 byte di
memoria per carattere
credo che ciò sia stato fatto fatto per la portabilità ijn modo da
poter supportare meglio il passaggio ai caratteri di nazioni che non
utilizzano il nostro solito alfabeto (es Giappone)
ciao
Marco

 che posso anche usare per trasportare informazioni...
non ho capito perchè ragioni in termini di stringhe.
a te serve un buffer di byte. semplicemente facendo:
byte[] buffer = new byte[size];
hai già il tuo buffer esattamente di dimensione 'size', con il contenuto
inzializzato a zero, modificabile a piacere e pronto per essere messo nel
pacchetto. 
in che frangente ti serve convertirlo in stringa?

 memoria per carattere
be' veramente UTF-8 e Unicode sono due codifiche diverse: che io sappia in
Unicode ciascun carattere occupa 2 bytes (65536 possibili caratteri, è la
codifica usata in Windows) mentre in UTF-8 ogni carattere ha una
dimensione variabile da 1 a 6 bytes. la dimensione del carattere viene
stabilita in base al valore progressivo dei bytes incontrati durante la
scansione di una stringa: quando leggi un byte il suo valore ti indica se
il carattere corrente finisce lì (ed in tal caso esprime il valore di tale
carattere) o se devi leggere anche il byte successivo (ed in tal caso a
quale subrange Unicode appartiene il carattere). non conosco bene i
dettagli, ma li trovi naturalmente qui: 
http://en.wikipedia.org/wiki/UTF-8
per quanto riguarda Java poi, leggo che gli oggetti String contengono
sequenze di caratteri in formato UTF-16, un'ulteriore codifica che trovi
descritta qui: 
http://en.wikipedia.org/wiki/UTF-16
a quanto pare in UTF-16 un carattere occupa 2 oppure 4 bytes (in realtà
non conosco UTF-16, sto leggendo ora qualche dettaglio).
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 writes:
m> per quanto riguarda Java poi, leggo che gli oggetti String
m> contengono sequenze di caratteri in formato UTF-16,
Unicode. 2 byte per carattere, ovvero un unsigned a 16 bit.
-- 
 /\           ___
/___/\_|_|\_|__|___Gian Uberto Lauri_____
  //--\| | \|  |   Integralista GNUslamico
\/                 e coltivatore diretto di Software
A Cesare avrei detto di scrivermi a 
fn...@rat.vg
P.S.
Per lavorare con le reti, usare le stringhe è deletereo, anche se in C
le stringhe sono array di char, ed un char è di un byte.
Le reti non lavorano con i byte  (la cui dimensione può variare da 6 a
8 bit), ma con ottetti di bit, la cui dimensione è sempre di 8 bit.
Se la tua architettura prevede byte  di 8 bit (quasi tutte le macchine
che ho usato, salvo una) allora un array di byte è quello che ti serve
per generare una stringa di ottetti di dimensione voluta.

 che ho usato, salvo una) allora un array di byte è quello che ti serve
huh? quale?
/me curioso :)
Ciao Jack

> che ti serve
J> huh? quale?
J> /me curioso :)
IBM  4341,  ma a  ripensarci  in realtà  avevi  256  valori per  byte,
quindi... Quello che cambiava era la codifica dei caratteri... EBDCIC,
brrrrrr....
Il MIX 1009  di Knuth (mai usato in pratica,  solo letto gli esercizi)
non faceva assunzioni  sul numero di bit, ma solo  sul range di valori
ammessi (e non richiedeva 8 bit).
Il  CDC6600 (luogo di  nascita del  Pascal e  creatura di  Cray) credo
avesse i byte a 6 bit...


 ha scritto nel messaggio 
news:pan.2007.06.16...@secret.net...

Ciao ragazzi e grazie a tutti per la disponibilità...
Ho le idee un po' più chiare a parte il fatto che mi sconsigliate a quanto 
pare i pacchetti fatti da stringhe per misurare le prestazioni di una 
rete...
Lo reputo un modo comodo perché posso usare il campo dati anche per 
trasportare dati e messaggi oltre che generare traffico e uso il 
BufferedReader come buffer per poi inviare tramite socket i pacchetti...
Cmq penso arrivato a questo punto di generare delle stringhe considerando 
che ogni singolo elemento di essa è 2 byte e di inviarlo nel modo 
classico... Si accettano cmq ulteriori consigli...
Tore

On 14 Giu, 17:46, "Tore" <tor...@tore.tore> wrote:

CIAO! per mandare 100 byte, puoi fare una stringa di 50 caratteri,
dopo di che la sputi in byte tramite str.getBytes("UTF-16");
UTF-16 prevede la codifica di ogni carattere su due byte (ma non
mettere caratteri cinesi etc, se no sali a 4!), quindi dovresti essere
sicuro!
Lato ricevente, recuperi la stringa con: str = new
String(byteAray,"UTF-16");
CIAO!

 ha scritto nel messaggio 
news:1182417411.2...@u2g2000hsc.googlegroups.com...

Ciao Stefano, molto chiara e interessante la tua soluzione...
il dubbio che mi resta ora č... posso usare il BufferedRaeder sia per 
mandare che ricevere questa stringa? Perchč mi pare di capire che cosě 
facendo la stringa resta cmq stringa ma codificata secondo lo standard 
UTF-16 e quindi di dimensione conosciuta.... esatto?
Per quanto riguarda caratteri cinesi, non ne userň :) sono previsti solo 
lettere o numeri...
Grazie
Tore 

Ciao tore!
il punto chiave è che non importa come java codifichi le stringhe al
suo interno,
l'importante è poter scriverla e leggerla secondo la codifica che vuoi
tu!
BufferedReader non ricordo l'utilizzo,
io leggerei i miei 100 bytes in un vettore,
quindi recupero la stringa con l'istruzione String str = new String
(byteArray,"UTF-16")
e il gioco è fatto!


Perdonami se approfitto della tua disponibilità ma potresti 
farmi un 
esempio? Lo chiedo perchè se costruisco un vettore di 100 
elementi di tipo 
byte in byteArray e lo converto in stringa usando il costruttore 
da te 
indicato mi ritrovo ogni byte codificato con 16 bit e quindi 
alla fine una 
stringa di 200byte?
Tore
-- 
Postato da Alice Newsgroup: lo usi da web ma con le funzioni del newsreader 
http://newsgroup.alice.it
Gerarchie it, italia, it-alt, tin, it.binari. Unico!


String sendingString = "STRINGA DA 50 CARATTERI";
//ricava array di 100 byte
byte centoItems[] = sendingString.getBytes("UTF-16");
outSoket.write(centoItems ,0,centoItems.length);
byte centoItems[100];
inputSoket.read(centoItems,0,100); // legge i cento byte inviati dall'
altra parte
String str= new String(centoItems,"UTF-16");
ciao!