[java]da Byte a bit

[Frank1962]

come faccio a codificare un ByteBuffer in codice binario !!?

è possibile?

[PGI]

"codificare un bytebuffer in codice binario" non è l'apice della chiarezza, ci vuole qualche informazione in più per sapere quali strumenti usare.

In via generale, il metodo Integer.toBinaryDigits(int) restituisce un letterale String che rappresenta la sequenza di bit che corrisponde al valore intero in notazione binaria (es. 2 -> 10), ma è una stringa e non un numero, per cui l'uso ha scopi estranei al calcolo.

La notazione binaria è estranea all'armamentario dei letterali numerici di Java (ci sono interi esadecimali, ottali, decimali a 32 e 64 bit, numeri in virgola mobile a precisione singola e doppia ma niente notazione binaria), il che significa che non puoi fare operazioni usando direttamente la notazione binaria.

Altro paio di maniche è la possibilità di operare sui singoli bit che compongono un intero: qui c'è tutta la famiglia degli operatori & | ^ e chi più ne ha più ne metta.

A titolo d'esempio, volendo conoscere il valore del terzo bit che compone il byte 53 è sufficiente una riga di codice e l'operatore bitwise "&" :

int bit = (53 & 4) == 4 ? 1 : 0;


In tutta sincerità non oso immaginare quale masochistica ragione ti porti a dover considerare una sequela di byte per i bit che compongono ciascun elemento (ma sono pronto ad essere stupefatto :D ).

&Ciao.

[Frank1962]

io non vorrei esattamente "operare" con i bit .....a me basta aver la possibilità di leggere un file e conoscere esattamente la sua struttura binaria invece dei bytes; ho fatto qualche prova usando anche il metodo che citi, Integer.toBinaryDigits(int), ma purtroppo non funziona, o meglio, l'Hex editor che uso per comparare i risultati mi segna qualcosa di completamente diverso ..........quindi evidentemente sbaglio in qualcosa, forse i bit di complemento non vengono calcolati con quel metodo :muro:


edit:

ho provato il codice che hai postato con gli operatori bit

array = (Reader.Leggi()).array(); <--- array ricavato dal ByteBuffer
for(int i=0; i<array.length; i++) {
for(int e=0; e<8; e++) {
int bit = (array[i] & e) == e ? 1 : 0;
System.out.print(bit);
}
}

...credo però che il problema sia questo:


try { inputFile = new FileInputStream(unFile); } catch(Exception e) { }
FileChannel inChannel = inputFile.getChannel();
try { inChannel.read(naltro); } catch(Exception e) { }
int dimFile = Integer.parseInt(ok.valueOf(unFile.length()));

try {
while(inChannel.read(bite) == -1) {
bite.clear();
}
inputFile.close();
} catch(Exception e) { System.out.println(e); }

....ovvero come vado a "creare" il ByteBuffer .....ho provato a stamparmi il contenuto del buffer appena gli "alloco" la grandezza e l'otput è stato: "100000001000000010000000...ecc" per ogni byte in + ........in pratica su un ByteBuffer di 20byte mi trovavo una ventina di byte inizializzati a "10000000" e non a "00000000" ....forse il problema può essere questo ? :confused:


edit2:

le prove le ho fatte su un file txt dove ho scritto la parola "ciao" .......salvato su hd, credo in formato unicode, con il notepad; se leggo con l'hexeditor il risultato è questo:

01100011 01101001 01100001 01101111

mentre con il programma java:

11110000 11000000 11000000 11111111


un pò "diverso" come risultato :rolleyes: :muro: :cry:

[PGI]

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

public class BitProva {
public static void main(String[] a) {
try {
FileChannel channel = new FileInputStream("c:\\ciao.txt").getChannel();

int numBytes = (int)channel.size();

ByteBuffer buffer = ByteBuffer.allocate(numBytes);

channel.read(buffer);

buffer.flip();

for(int i = 0; i < numBytes; i++) {
String binDigits = Integer.toBinaryString(buffer.get(i));
System.out.println(binDigits);
}

channel.close();

} catch(IOException e) {
e.printStackTrace();
}

}
}


1100011
1101001
1100001
1101111

[Frank1962]

Originariamente inviato da PGI
1100011
1101001
1100001
1101111
edit:

ma perchè non vengono aggiunti gli 0 iniziali ?

1100011 1101001 1100001 1101111

01100011 01101001 01100001 01101111

[PGI]

Probabilmente hanno scelto di "tradurre" solo i bit significativi, tra 0010 e 10 non c'è alcuna differenza, sempre 2 è.

[Frank1962]

Originariamente inviato da PGI
Probabilmente hanno scelto di "tradurre" solo i bit significativi, tra 0010 e 10 non c'è alcuna differenza, sempre 2 è.

String binDigits = 0+Integer.toBinaryString(buffer.get(i));
cmq per avere il codice corretto basta aggiungere uno 0 :D

ps: ma se volessi avere un array di valori short che mi contenga gli 0/1 come dovrei fare ..........mi occuperebbe + spazio in memoria l'array di short oppure la stringa completa? :confused:

[PGI]

Originariamente inviato da Frank1962

String binDigits = 0+Integer.toBinaryString(buffer.get(i));
cmq per avere il codice corretto basta aggiungere uno 0 :D


Beh, no. Per avere la notazione corretta dovresti generalizzare un pelo la faccenda. In realtà devi aggiungere un numero di cifre 0 compreso tra 8 e 0 a seconda di dove si trovi la prima cifra 1 a partire da sinistra.

10 -> 2 -> 0000 0010 (8 bit x 1 byte)

Originariamente inviato da Frank1962
ps: ma se volessi avere un array di valori short che mi contenga gli 0/1 come dovrei fare ..........mi occuperebbe + spazio in memoria l'array di short oppure la stringa completa? :confused:

Fai un "benchmark" sull'occupazione di memoria di un oggetto String e poi su un array di short e scopri subito. In teoria la stringa dovrebbe essere più piccola (perchè si "basa" su un array di char, ma bisogna poi vedere quanto pesa il resto del contenuto dell'oggetto String).

&Ciao.