No hay forma de hacerlo directamente. La unidad más pequeña que las computadoras pueden manejar es un byte (incluso los booleanos ocupan un byte). Sin embargo, puede crear una clase de flujo personalizado que empaqueta un byte con los bits que desea y luego lo escribe. A continuación, puede crear un contenedor para esta clase cuya función de escritura adopta un tipo integral, verifica que esté entre 0 y 7 (o -4 y 3 ... o lo que sea), extrae los bits de la misma manera que la clase BitInputStream (abajo) hace, y hace las llamadas correspondientes al método de escritura de BitOutputStream. Tal vez piense que podría hacer un solo conjunto de clases de flujo IO, pero 3 no pasa a 8 de manera uniforme.Entonces, si desea una eficiencia de almacenamiento óptima y no desea trabajar realmente duro, está atrapado con dos capas de abstracción. A continuación se muestra una clase BitOutputStream, una clase correspondiente BitInputStream y un programa que se asegura de que funcionen.
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();
}
}
estoy seguro de que hay una manera de empaquetar el int con los operadores bit a bit y así evitar tener que invertir la entrada, pero no lo sé qué pensar tan difícil.
También, usted probablemente ha notado que no hay manera local para detectar que el último bit se ha leído en esta implementación, pero realmente no quiere pensar que duro.
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();
}
}
usted probablemente sabe esto, pero usted debe poner un BufferedStream en medio de su BitStream y FileStream o se va a tomar para siempre.
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.");
}
}
Parece que voy a tener que leer los bytes/escritura y aprender operaciones bit a bit ... Gracias a todos por las respuestas .... –
Gracias nos, para el punto de eficiencia ... –
Por anding b y 0x3, aren ¿Solo se conservan los 2 bits menos significativos en personas de bajos recursos? –