Enregistrer dans le fichier binaire

Question

Je souhaite enregistrer les données dans un fichier binaire à l'aide de Java. Par exemple j'ai le numéro 101 et dans mon programme le fichier de sortie a 4 octets. Comment puis-je enregistrer le numéro seulement dans trois bits (101) dans le fichier de sortie? Mon programme ressemble à ceci:

public static void main(String args[]) throws FileNotFoundException, IOException { 
    int i = 101; 
    DataOutputStream os = new DataOutputStream(new FileOutputStream("file")); 
    os.writeInt(i); 
    os.close(); 
} 

J'ai trouvé quelque chose comme ça: http://www.developer.nokia.com/Community/Wiki/Bit_Input/Output_Stream_utility_classes_for_efficient_data_transfer

Answer 1

Vous ne pouvez pas écrire moins d'un octet dans un fichier. Si vous voulez écrire le nombre binaire 101, faites int i = 5 et utilisez os.write(i) à la place. Cela écrira un octet: 0000 0101.

Answer 2

Tout d'abord, vous ne pouvez pas écrire seulement 3 bits dans un fichier, la mémoire est alignée sur des valeurs spécifiques (8, 16, 32, 64 ou même 128 bits, c'est un compilateur/plateforme spécifique). Si vous écrivez des tailles plus petites, elles seront agrandies pour correspondre à l'alignement.

Deuxièmement, le nombre décimal 101, écrit en binaire est 0b01100101. le nombre binaire 0b00000101, est décimal 5.

Troisièmement, ces nombres sont maintenant seulement 1 octet (8 bits) de long, de sorte que vous pouvez utiliser un caractère au lieu d'un int.

Et last but not least, d'écrire les nombres non entiers, utilisez os.write()

Donc, pour obtenir ce que vous voulez, vérifiez d'abord si vous voulez écrire 0b01100101 ou 0b00000101. Changez l'int en un caractère et au nombre approprié (vous pouvez écrire 0b01100101 en Java). Et utiliser os.write()

Answer 3

Une implémentation vraiment naïve, j'espère que cela vous aidera à saisir l'idée. Aussi non testé, susceptible de contenir hors par une erreur etc ...

class BitArray { 
    // public fields for example code, in real code encapsulate 
    public int bits=0; // actual count of stored bits 
    public byte[] buf=new byte[1]; 

    private void doubleBuf() { 
    byte [] tmp = new byte[buf.length * 2]; 
    System.arraycopy(buf, 0, tmp, 0, buf.length); 
    buf = tmp; 
    } 

    private int arrayIndex(int bitNum) { 
    return bitNum/8; 
    } 

    private int bitNumInArray(int bitNum) { 
    return bitNum & 7; // change to change bit order in buf's bytes 
    } 

    // returns how many elements of buf are actually in use, for saving etc. 
    // note that last element usually contains unused bits. 
    public int getUsedArrayElements() { 
    return arrayIndex(this.bits-1) + 1; 
    } 

    // bitvalue is 0 for 0, non-0 for 1 
    public void setBit(byte bitValue, int bitNum) { 
    if (bitNum >= this.bits || bitNum < 0) throw new InvalidArgumentException(); 
    if (bitValue == 0) this.buf[arrayIndex(bitNum)] &= ~((byte)1 << bitNumInArray(bitNum)); 
    else this.buf[arrayIndex(bitNum)] |= (byte)1 << bitNumInArray(bitNum); 
    } 

    public void addBit(int bitValue) { 
    // this.bits is old bit count, which is same as index of new last bit 
    if (this.buf.length <= arrayIndex(this.bits)) doubleBuf(); 
    ++this.bits; 
    setBit(bitValue, this.bits-1); 
    } 

    int readBit(int bitNum) { // return 0 or 1 
    if (bitNum >= this.bits || bitNum < 0) throw new InvalidArgumentException(); 
    byte value = buf[arrayIndex(bitNum)] & ((byte)1 << bitNumInArray(bitNum)); 
    return (value == 0) ? 0 : 1; 
    } 

    void addBits(int bitCount, int bitValues) { 
    for (int num = bitCount - 1 ; num >= 0 ; --num) { 
     // change loop iteration order to change bit order of bitValues 
     addBit(bitValues & (1 << num)); 
    } 
} 

Pour une solution efficace, il devrait utiliser int ou long tableau au lieu de tableau d'octets, et inclure la méthode plus efficace pour addition multiple bits (ajouter parties de bitValues un élément entier de tableau buf à la fois, pas bit par bit comme ci-dessus).

Pour sauvegarder ceci, vous devez sauvegarder le bon nombre d'octets de buf, calculé par getUsedArrayElements().