Newsgroup: it.comp.java
Titolo: File Binario

Ciao a tutti
io devo leggere un file binario bit per bit e memorizzare ogni gruppo
di 32768 bit in una classe BitSet.Per fare ciò io ho utilizzato una
classe FileRandomAccess ed in particolare il metodo readBoolean in un
ciclo che va 32767 volte.Il metodo è esatto oppure ogni volta che fa
una readboolean legge un byte al posto di un bit(sulla documentazione
non ho capito molto bene uesto punto).Grazie a tutti per l'attenzione.
Ciao
Alessio

 writes:
A> Ciao a tutti io devo leggere un file binario bit per bit e
A> memorizzare ogni gruppo di 32768 bit in una classe BitSet.Per fare
A> ciò io ho utilizzato una classe FileRandomAccess ed in particolare
A> il metodo readBoolean in un ciclo che va 32767 volte.Il metodo è
A> esatto oppure ogni volta che fa una readboolean legge un byte al
A> posto di un bit(sulla documentazione non ho capito molto bene uesto
A> punto).Grazie a tutti per l'attenzione.  Ciao Alessio
"This method reads a single byte from the file. A value of 0 represents
 false. Any other value represents true."
        ^^^
Non avrebbe usato  any se non ci fossero  stati più valori alternativi
allo 0...
Temo  che  così  come  è  il  tuo  sia  un  carinissimo  algoritmo  di
compressione lossy che comprime 8 bit in uno che viene posto a zero se
sono tutti a zero, ad 1 se almeno uno dei bit originari è a 1 :) :) :).
Forse per  efficienza la readFully()  è da preferire, per  comodità di
scrittura del codice userei la readUnsignedByte(), che ti trovi comodi
comodi i valori da  0 a 255 da analizzare a colpi di  & con in un loop
di otto passi, eventualmente srotolato.
-- 
 /\            ___
/___/\__|_|\_|__|___Gian Uberto Lauri_____________________
  //--\ | | \|  |   Integralista GNUslamico  
\/		    e allevatore di bug da competizione

Ti ringrazio della risposta.Purtroppo al momento non posso verificare
se ho ben capito come funziona il metodo .Tuttavia ti ringrazio lo
stesso dell'interessamento 
Ciao 
Alessio

 writes:
A> Ti ringrazio della risposta.Purtroppo al momento non posso
A> verificare se ho ben capito come funziona il metodo .Tuttavia ti
A> ringrazio lo stesso dell'interessamento Ciao Alessio
Avevo tempo di giocare. Prova questa e convinciti :)
0001 import java.util.BitSet;
0002 import java.io.IOException;
0003 import java.io.RandomAccessFile;
0004 import java.io.EOFException;
0005 import java.io.File;
0006 
0007 public class Bit {
0008 
0009   public static final void main(final String[] args) {
0010 
0011     int idx=0;
0012     File fff=null;
0013     RandomAccessFile faf=null;;
0014     int bitcount=0;
0015 
0016     try {
0017       fff = new File("prova");
0018       faf = new RandomAccessFile(fff, "r");
0019 
0020       idx =1;
0021 
0022       while (true) {
0023         // uscirò per botto!
0024         boolean tmp = faf.readBoolean();
0025         System.out.print(tmp?"1":"0");
0026         idx++;
0027 
0028       }
0029 
0030 
0031     }
0032     catch (EOFException eofe) {
0033       System.out.println("\nLettura N^" + idx + " fallita per eof.");
0034       try {
0035         faf.close();
0036       } catch (IOException e) {
0037         e.printStackTrace();
0038       }
0039 
0040     }
0041     catch (IOException ioe) {
0042       ioe.printStackTrace();
0043     }
0044 
0045     BitSet bs = new BitSet(8);
0046 
0047     try {
0048       fff = new File("prova");
0049       faf = new RandomAccessFile(fff, "r");
0050 
0051       idx =1;
0052       while (true) {
0053         // uscirò per botto!
0054         int tmp = faf.readUnsignedByte();
0055 
0056         bs.set(bitcount++,( (tmp & 1) == 0) ? false: true);
0057         bs.set(bitcount++,( (tmp & 2) == 0) ? false: true);
0058         bs.set(bitcount++,( (tmp & 4) == 0) ? false: true);
0059         bs.set(bitcount++,( (tmp & 8) == 0) ? false: true);
0060         bs.set(bitcount++,( (tmp & 16) == 0) ? false: true);
0061         bs.set(bitcount++,( (tmp & 32) == 0) ? false: true);
0062         bs.set(bitcount++,( (tmp & 64) == 0) ? false: true);
0063         bs.set(bitcount++,( (tmp & 128) == 0) ? false: true);
0064 
0065         idx++;
0066       }
0067 
0068 
0069     }
0070     catch (EOFException eofe) {
0071       System.out.println("\nLettura N^" + idx + " fallita per eof.");
0072       try {
0073         faf.close();
0074       } catch (IOException e) {
0075         e.printStackTrace();
0076       }
0077 
0078     }
0079     catch (IOException ioe) {
0080       ioe.printStackTrace();
0081     }
0082 
0083 
0084     for (bitcount--; bitcount >= 0; bitcount--) {
0085       System.out.print((bs.get(bitcount))?"1":"0");
0086     }
0087     System.out.println(" ");
0088 
0089   }
0090 
0091 }
da me il file prova ha questo contenuto
@ABC
e l'output è
{paperoga} 13:15:08
[76]~/java:java Bit
1111
Lettura 5 fallita per eof.
Lettura 5 byte fallita per eof.
01000011010000100100000101000000 
(sono i bit di CBA@, non  avevo voglia di complicarmi la vita, solo di
giocare, volevo far vedere che si leggevano 32 bit)
