[JAVA] Da stringa in esadecimale e viceversa

[andbin]

Originariamente inviato da SHARKSEAL
Il risultato deve essere : byte writeBuffer[] contenete i valori esadecimali della stringa "Pippo"

Praticamente writeBuffer [0] = 50 (esadecimale)
writeBuffer [1] = 69
ecc..."

Perchè non posso parlare di un array di esadecimale ?

Perché il dire "decimale", "esadecimale" o ancora "ottale" è solo una questione di rappresentazione "visiva". Non esiste un "byte decimale" o un "byte esadecimale" .... esiste un byte e basta. Sono 8 bit.
Al massimo si può dire se un tipo di dato (byte, int ecc...) è con segno o senza segno.

Originariamente inviato da SHARKSEAL
Se ho capito bene un array di byte (contiene valori di 8 bit ) ... ma cosa mi vieta che questi valori non possa rappresentarli in esadecimali??? Allora che senso avrebbe l'esistenza del byte, della word, della dword, della qword???

Termini come "word", "dword" e "qword" sono generalmente (e specialmente quando si lavora con il linguaggio assembly dei processori) usati per indicare semplicemente dei tipi di dato che sono più di 1 byte/8 bit. Ma non centra con la rappresentazione in una certa "base" (8, 10, 16 che sia) di un valore.

Originariamente inviato da SHARKSEAL
Io ho provato ad utilizzare questo pezzo di codice e funziona benissimo :

byte mioarray[]={(byte)0xFF,(byte)0xFF,(byte)0xFF};

Ma lo vedi che stai facendo ancora una volta una "rappresentazione" del valore in una certa base??? Nel sorgente stai scrivendo zero ics effe effe. Stai scrivendo un valore rappresentato in esadecimale che viene assegnato ad un byte. Non è che hai fatto un "byte esadecimale"!!

Praticamente penso tutti i linguaggi di programmazione hanno le regole per poter scrivere nel sorgente dei valori "literal" (letterali) non solo in decimale ma anche in altre basi. Insomma .... è solo una sintassi che ti permette di esprimere un valore in ottale piuttosto che esadecimale o altro. Non è che è il byte "esadecimale".

Originariamente inviato da SHARKSEAL
Io penso che l'unica cosa di cui devo preoccuparmi è che essendo un array di valori a 8 bit posso rappresentare al massimo 255 (valori in decimale) FF (in esadecimale ma essendo signed in java fino a 7F ovvero (127) in decimale

Per la questione del segno è una questione anche qui di "modo di trattamento". Dire ad esempio 0xFF non chiarisce tutto .... bisognerebbe vedere su quale tipo di dato (dimensione, signed o unsigned).

Se in un linguaggio c'è un tipo di dato che è 8 bit senza segno, allora 0xFF rappresenterebbe 255. Se invece, come succede in Java, il byte è signed (con segno), allora un byte con valore 0xFF vale in realtà -1 (decimale) non 255!!

Ma è solo questione del trattamento. Dire ad esempio 0xA5, potrebbe voler dire -91 se assegnato ad un byte "signed" oppure 165 se ci fosse (non c'è in Java) un byte "unsigned".

Se in Java ho un byte a cui assegno 0xA5 e lo stampo in decimale, mi visualizza -91. Se voglio "vedere" 165, nulla si è perso .... nel senso che basta solo farlo "vedere" come valore unsigned con l'ausilio di un tipo di dato più grande.

byte b = (byte) 0xA5;
System.out.println(b);   // Stampa -91
int i = b & 0xFF;        // lo porta a 0x000000A5
System.out.println(i);   // Stampa 165

Quindi un byte (come qualunque altro tipo di dato) non è esadecimale, ottale ecc.... è la rappresentazione del valore che può essere in una certa base!

Originariamente inviato da SHARKSEAL
Il metodo getByte si è vero mi restituisce un array di byte ma con valori decimali non esadecimali .

Ripeto ancora una volta che stai sbagliando l'approccio e il modo di vedere le cose. getBytes() ti restituisce un array di byte ... ogni byte ha un valore tra (in binario) 00000000 e 11111111. Cosa tu vuoi "vedere" e come vuoi stamparlo/rappresentarlo .... lo puoi scegliere tu.

Originariamente inviato da SHARKSEAL
Io chiedevo solo una funzione che mi convertisse una normale stringa "pippo" nei rispettivi valori esadecimali da poter poi assegnare in un array di byte ... tutto qui.

E in questa discussione ti ho già ampiamente spiegato tutta la questione, ti ho spiegato come eventualmente stampare un valore in esadecimale con l'uso dei toString() nella versione con radix.

[SHARKSEAL]

Credo che la questione sia più di lessico italiano che di concetto...

Mi serve un metodo che presa una Stringa " Pippo " la rappresenti carattere per carattere in esadecimale ...e che poi ogni rappresentazione esadecimale del carettere possa essere assegnata ad un array di tipo byte ...

Viceversa poi da una rappresentazione esadecimale carattere per carattere contenuta in un array di tipo byte devo riportarmi alla Stringa "pippo"

Visto che non sono in grado di afferrare il concetto ... forse per mia ignoranza grave in materia...

ti posto direttamente il codice cosi ...se tua bontà puoi spiegarmi come fare ...

Ecco i metodi che mi permettono di scrivere e leggere sulla memoria
(ripeto i dati sulla memoria sono scritti e letti rigorosamente in esadecimale)

write

public final void write(int address,
byte[] writeBuffer,
int offset,
int length,
byte isProtected)
throws ASEException

Sends a Write command to the Card

Parameters:
address - = the address to write to
writeBuffer - = buffer containing the data to be written
offset - = index at the buffer from where to start
length - = number of bytes to write
isProtected - = sets the Data as Protected

read

public final void read(int address,
byte[] readBuffer,
int offsetReadBuffer,
int length,
byte[] protReadBuffer,
int offsetProtReadBuffer)
throws ASEException

Sends a Read command to the Card

Parameters:
address - the address to read from
readBuffer - buffer to put the data in
offsetReadBuffer - index at the buffer from where to start
length - number of bytes to read
offsetProtReadBuffer - index at the buffer from where to start
protReadBuffer - buffer to put protected flags in
************************************************** **********
Ecco il codice

int startAddr=8;
int len=40;
byte readBuf[]=new byte[256];
byte writeBuf[]=new byte[256];

//read 40 bytes from address 8

memoria.read(startAddr,readBuf,0,len,null,0);

//print the memory content
for(int i=0;i<len;i++) {
System.out.print(readBuf[i]+" ");
if ((i & 0x7) == 0x7)
System.out.println();
}
System.out.println();
//prepare the write buffer - inverse of the read buffer

for (int i=0;i<len; i++)
writeBuf[i]=(byte)~readBuf[i];
memoria.write(startAddr,writeBuf,0,len,memoria.ASE MEM_WRITE_MODE);


Chiaramente io devo farlo con qualsiasi stringa che da interfaccia grafica gli inserisco (praticamente devo scrivere un nome e cognome su una memoria ...in esadecimale)


Spero di averti fatto capire il concetto ...ciao e grazie

[SHARKSEAL]

andbin facendo delle prove e stampando passo passo ...ho capito cosa intendevi ... sorry
effettivamente uso termini non consoni ma il concetto è chiaro...
mi traeva in inganno il fatto che sulla memoria leggessi in esadecimale ... ma praticamente è la visualizzazione che è in esadecimale ... ma poi riuscendo a vedere nel punto jar che contiene tutti i metodi ho fatto una prova ed effettivamente passa un byte a prescindere che poi il mio editor di memoria me lo visualizza in esadecimale


quindi il metodo getbyte va benissimo al caso mio


riguardo al charset di cui parlavi sopra (praticamente opero con tutti i simboli del codice ASCII)
quale charset mi consigli ???


Grazie sei gentilissimo e scusa se ti ho creato noia nelle spiegazioni

[andbin]

Originariamente inviato da SHARKSEAL
ma praticamente è la visualizzazione che è in esadecimale ...

Appunto.

Originariamente inviato da SHARKSEAL
riguardo al charset di cui parlavi sopra (praticamente opero con tutti i simboli del codice ASCII)
quale charset mi consigli ???

getBytes("US-ASCII")
Se dovessi gestire le lettere accentate à á è ecc.... allora meglio "ISO-8859-1".

[SHARKSEAL]

Si anche grazie gentilissimo

[SHARKSEAL]

Ciao andbin ... vorrei chiederti un'ulteriore delucidazione in merito ai byte...


Lavorando sempre al mio programmino ho notato che la memorizzazione dei dati numerici non avviene considerando le cifre come caratteri ma come interi...

mi spiego meglio


per risalire al nome e cognome io prelevo l'array di byte e mi ricostruisco la stringa cosi:

String nominativo = new String(readBuffer, "US-ASCII"); --> readbuffer (array di byte)


ma adesso mi occorre prelevare anche un id numerico ed altri informazioni numeriche
ed ho notato che per la memorizzazione dei numerici vengono utilizzati nella memoria 2 byte
quindi può rappresentare fino a 65535..

ad esempio il numero 21 --viene memorizzato come:
00 primo byte (visualizzato in esadecimale con 00)
21 secondo byte (visualizzato in esadecimale con 15)


e non come caratteri ascii ... tipo 50 nel primo byte (per il 2) e 49 nel secondo byte (per l'1)

quindi io usando l'istruzione per le stringhe non mi carica una stringa con il numero 21
ma due quadratini ovvero come se non fossero convertiti i caratteri siccome il codice ascii parte da 32 ( lo spazio) ...

la mia domanda è come posso costruirmi l'effettivo valore intero da un byte ...o meglio
poter fare una cosa del genere:

int idutente = .... (come per le stringhe ma che mi memorizzi l'effettivo valore intero)

Grazie come sempre per la disponibilità

[andbin]

Originariamente inviato da SHARKSEAL
ma adesso mi occorre prelevare anche un id numerico ed altri informazioni numeriche
ed ho notato che per la memorizzazione dei numerici vengono utilizzati nella memoria 2 byte
quindi può rappresentare fino a 65535..

ad esempio il numero 21 --viene memorizzato come:
00 primo byte (visualizzato in esadecimale con 00)
21 secondo byte (visualizzato in esadecimale con 15)


e non come caratteri ascii ... tipo 50 nel primo byte (per il 2) e 49 nel secondo byte (per l'1)

quindi io usando l'istruzione per le stringhe non mi carica una stringa con il numero 21
ma due quadratini ovvero come se non fossero convertiti i caratteri siccome il codice ascii parte da 32 ( lo spazio) ...

No, alt. Se hai una stringa come es. "21" e ne ottieni la sequenza di byte in US-ASCII:

byte[] buf = "21".getBytes("US-ASCII");

Allora nell'array avrai 2 byte:
buf[0] = 50 decimale (32 in hex), il carattere '2' in ASCII
buf[1] = 49 decimale (31 in hex), il carattere '1' in ASCII

Su questo non ci piove.

Cosa hai fatto tu per avere 2 byte con valori 0 e 21 .... non lo so. Ma probabilmente devi rivedere quello che hai fatto. Non vorrei che magari hai assegnato ai caratteri della stringa i codici 0 e 21 (il char è alla fin fine un tipo numerico anche lui, a 16 bit unsigned).

[SHARKSEAL]

No mi spiego meglio ... non dipende da me io devo solo scrivere su una memoria nuova leggendo da una già esistente ti riporto un esempio :


00 15 ...41 4C 45 53 53 41 4E 44 52 4F questa è una stringa che io vedo con un editor dalla memoria ... chiaramente visualizzati in esadecimale ... adesso io tramite un metodo prelevo o scrivo queste informazione tramite un array di byte ... readbuffer (lettura) writebuffer (scrittura)

ogni coppia rappresenta in memoria un byte

41 4C 45 53 53 41 4E 44 52 4F questo è il nome ALESSANDRO scorrendo il mio array readbuffer ho in decimale 65 76 69 83 83 65 78 68 82 79 ogni byte un carattere e con il metodo da te suggerito :

String nome = new String(readbuffer, "US-ASCII") ottengo perfettamente il nome quindi va benissimo ..

il problema si ha nella prima parte:
00 15 ovvero il codice numerico assegnato al nome ALESSANDRO che è 21 intero che con il metodo a mia disposizione vado a inserire nel readbuffer quindi avro' un array di due byte
00 21 in decimale chiaramente ... ma usando il metodo sopra non mi converte nulla ...non mi crea la stringa perche in ascii fino al 32 decimale ( lo spazio) non ci sono caratteri ...da qui ho capito che i numeri in memoria sono memorizzati come numeri interi (sfruttanto 2byte) quindi posso trovarci valori da 0 a 65535.

quindi come posso assegnare ad una variabile intera l'effettivo valore e non caratteri?

esempio

int numero = invece di (new String (readbuffer, "US-ASCII") esiste un metodo che da un array di 2byte (00, 21) possa orrenere il numero intero 21 ... un po come per le stringhe ???

anche perchè mi potrebbe capitare di leggere un numero tipo 995 che rappresentato in esadecimale sarebbe :
03 E3

che se leggessi come singoli caratteri mi darebbe:

3
e
227

il che sarebbe errato ... spero di essere stato più chiaro

grazie andbin ...

[andbin]

Originariamente inviato da SHARKSEAL
00 15 ovvero il codice numerico assegnato al nome ALESSANDRO che è 21 intero che con il metodo a mia disposizione vado a inserire nel readbuffer quindi avro' un array di due byte
00 21 in decimale chiaramente

Allora non li devi certo mettere nell'array di byte che converti in stringa, perché questi 2 byte non rappresentano dei "caratteri" ma un valore numerico (che non è nemmeno il codice di un carattere né ASCII né Unicode ... solo un valore e basta)!

Originariamente inviato da SHARKSEAL
ma usando il metodo sopra non mi converte nulla ...non mi crea la stringa perche in ascii fino al 32 decimale ( lo spazio) non ci sono caratteri

Prima del codice ASCII 32 sono caratteri detti "di controllo". Ma non è comunque nemmeno questa la interpretazione di questi due byte.

Originariamente inviato da SHARKSEAL
da qui ho capito che i numeri in memoria sono memorizzati come numeri interi (sfruttanto 2byte) quindi posso trovarci valori da 0 a 65535.

Sì, da quanto si deduce, quei 2 byte iniziali formano un valore che in Java l'equivalente potrebbe essere uno "short" (a 16 bit) se signed. Se fosse unsigned, si potrebbe comunque assegnarlo ad un int.

Originariamente inviato da SHARKSEAL
int numero = invece di (new String (readbuffer, "US-ASCII") esiste un metodo che da un array di 2byte (00, 21) possa orrenere il numero intero 21 ... un po come per le stringhe ???

Tu dai due byte 0x00 0x15 vuoi ottenere un valore numerico 21. E questo è perfettamente possibile.
Il valore è memorizzato in formato Big-Endian, ovvero il primo byte è quello più significativo. DataInputStream è in grado di leggere tipi primitivi (int, long ...) in formato fisso Big-Endian (hanno stabilito così). Ma se vuoi basta solo fare qualche operazione con gli operatori bit-wise e di shift.

dati i due byte in es. buf[0] (contiene 0x00) e buf[1] (contiene 0x15) basta fare:

int valore = (buf[0] & 0xFF) << 8 | (buf[1] & 0xFF);

Cioè buf[1] viene messo come la parte più bassa del int (bit 7-0) mentre buf[0] viene shiftato a sinistra e messo come parte un po' più alta del int (bit 15-8). Ed ecco che è "ricomposto" il valore numerico.

Tutto qui. Semplice uso di AND, OR e shift sui valori.

[SHARKSEAL]

Grazie andbin provo subito