Il n'y a aucun moyen de le faire directement. La plus petite unité qu'un ordinateur peut gérer est un octet (même les booléens prennent un octet). Cependant, vous pouvez créer une classe de flux personnalisée qui emballe un octet avec les bits que vous voulez, puis l'écrit. Vous pouvez ensuite créer un wrapper pour cette classe dont la fonction write prend un type entier, vérifie qu'il est compris entre 0 et 7 (ou -4 et 3 ... ou autre), extrait les bits de la même manière que la classe BitInputStream (ci-dessous) fait, et effectue les appels correspondants à la méthode d'écriture de BitOutputStream. Vous pourriez penser que vous pourriez juste faire un ensemble de classes de flux IO, mais 3 ne va pas dans 8 même.Donc, si vous voulez une efficacité de stockage optimale et que vous ne voulez pas travailler très dur, vous êtes coincé avec deux couches d'abstraction. Voici une classe BitOutputStream, une classe BitInputStream correspondante et un programme qui vérifie qu'ils fonctionnent.
import java.io.IOException;
import java.io.OutputStream;
class BitOutputStream {
private OutputStream out;
private boolean[] buffer = new boolean[8];
private int count = 0;
public BitOutputStream(OutputStream out) {
this.out = out;
}
public void write(boolean x) throws IOException {
this.count++;
this.buffer[8-this.count] = x;
if (this.count == 8){
int num = 0;
for (int index = 0; index < 8; index++){
num = 2*num + (this.buffer[index] ? 1 : 0);
}
this.out.write(num - 128);
this.count = 0;
}
}
public void close() throws IOException {
int num = 0;
for (int index = 0; index < 8; index++){
num = 2*num + (this.buffer[index] ? 1 : 0);
}
this.out.write(num - 128);
this.out.close();
}
}
Je suis sûr qu'il ya un moyen d'emballer l'int avec les opérateurs bit à bit et ainsi éviter d'avoir à inverser l'entrée, mais je ne pas quoi penser que dur.
En outre, vous avez probablement remarqué qu'il n'y a aucun moyen local pour détecter que le dernier bit a été lu dans cette mise en œuvre, mais je vraiment ne veux pas penser que dur.
import java.io.IOException;
import java.io.InputStream;
class BitInputStream {
private InputStream in;
private int num = 0;
private int count = 8;
public BitInputStream(InputStream in) {
this.in = in;
}
public boolean read() throws IOException {
if (this.count == 8){
this.num = this.in.read() + 128;
this.count = 0;
}
boolean x = (num%2 == 1);
num /= 2;
this.count++;
return x;
}
public void close() throws IOException {
this.in.close();
}
}
Vous le savez probablement, mais vous devriez mettre un BufferedStream entre votre Bitstream et FileStream ou il va prendre une éternité.
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Random;
class Test {
private static final int n = 1000000;
public static void main(String[] args) throws IOException {
Random random = new Random();
//Generate array
long startTime = System.nanoTime();
boolean[] outputArray = new boolean[n];
for (int index = 0; index < n; index++){
outputArray[index] = random.nextBoolean();
}
System.out.println("Array generated in " + (double)(System.nanoTime() - startTime)/1000/1000/1000 + " seconds.");
//Write to file
startTime = System.nanoTime();
BitOutputStream fout = new BitOutputStream(new BufferedOutputStream(new FileOutputStream("booleans.bin")));
for (int index = 0; index < n; index++){
fout.write(outputArray[index]);
}
fout.close();
System.out.println("Array written to file in " + (double)(System.nanoTime() - startTime)/1000/1000/1000 + " seconds.");
//Read from file
startTime = System.nanoTime();
BitInputStream fin = new BitInputStream(new BufferedInputStream(new FileInputStream("booleans.bin")));
boolean[] inputArray = new boolean[n];
for (int index = 0; index < n; index++){
inputArray[index] = fin.read();
}
fin.close();
System.out.println("Array read from file in " + (double)(System.nanoTime() - startTime)/1000/1000/1000 + " seconds.");
//Delete file
new File("booleans.bin").delete();
//Check equality
boolean equal = true;
for (int index = 0; index < n; index++){
if (outputArray[index] != inputArray[index]){
equal = false;
break;
}
}
System.out.println("Input " + (equal ? "equals " : "doesn't equal ") + "output.");
}
}
Il semble que je vais devoir lire/écrire des octets et apprendre des opérations au niveau du bit ... Merci à tous pour les réponses .... –
Merci nos, pour le point d'efficacité ... –
Par anding b et 0x3, aren Est-ce que seuls les 2 bits les moins significatifs sont conservés en lowbits? –