有沒有人有一個很好的Java BitBuffer？

Question

我正在做一個學校作業（做霍夫曼編碼），我需要某種bitbuffer來把所有的東西都放進去。雖然我發現了一些做google的東西，但大部分東西都是垃圾 - 沒有編譯，參考其他圖書館我沒有，等等有沒有人有一個實際的好bitbuffer類在那裏？我真正想要做的就是一次讀寫一個位。如果沒有人擁有一個好的數據結構，是否有一些現有的數據結構可以有效地保存那些有用的數據，我可以自己寫一個數據結構？

Answer 1

在這裏尋找一個bitbuffer例如

http://www.javadocexamples.com/java_source/com/sun/java/help/search/BitBuffer.java.html

Answer 2

隊列通常會產生良好的緩衝區（FIFO）。一點可以用布爾值表示。在Java庫中的Queue實現是通用的，所以你可以實例化位緩衝區這樣的：

Queue<Boolean> bbuff = new Queue<Boolean>(); 
Boolean imabit = false; 

您排隊/緩衝位是這樣的：

bbuff.add(imabit); 

你出列/閱讀（刪除）下一個位是這樣的：

Boolean dequeuedbit = bbuff.remove(); 

Answer 3

解決Huffman編碼實現的時候我面臨同樣的問題，我用這個庫和測試它，它的工作原理..

BitOutputStream

import java.io.*; 

/** 
* Write bits-at-a-time where the number of bits is between 1 and 32. 
* Client programs must call <code>flush</code> or 
* <code>close</code> when finished writing or not all bits will be written. 
* This class is intended to be used with <code>BitInputStream</code> to 
* facilitate reading and writing data in a bits-at-a-time manner. 
* <P> 
* Updated for version 2.0 to extend java.io.OutputStream 
* <P> 
* Any exceptions generated are rethrown as <code>RuntimeException</code> objects 
* so client code does not have to catch or rethrow them. 
* <P> 
* @author Owen Astrachan 
* @version 1.0, July 2000 
* @version 2.0, October 2004 
* @version 2.1, March 2010, Fixed >> to >>> bug in writeBits 
*/ 


public class BitOutputStream extends OutputStream 
{ 


    private OutputStream myOutput; 
    private int   myBuffer; 
    private int   myBitsToGo; 

    private static final int bmask[] = { 
     0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff, 
     0x1ff,0x3ff,0x7ff,0xfff,0x1fff,0x3fff,0x7fff,0xffff, 
     0x1ffff,0x3ffff,0x7ffff,0xfffff,0x1fffff,0x3fffff, 
     0x7fffff,0xffffff,0x1ffffff,0x3ffffff,0x7ffffff, 
     0xfffffff,0x1fffffff,0x3fffffff,0x7fffffff,0xffffffff 
    }; 

    private static final int BITS_PER_BYTE = 8; 

    /** 
    * Required by OutputStream subclasses, write the low 
    * 8-bits to the underlying outputstream 
    */ 
    public void write(int b) throws IOException { 
     myOutput.write(b); 
    } 

    /** 
    * Create a stream that writes-through to the <code>OutputStream</code> object 
    * passed as a parameter. 
    * @param out is the output stream to which bits are written 
    */ 
    public BitOutputStream(OutputStream out){ 
     myOutput = out; 
     initialize(); 
    } 

    private void initialize(){ 
     myBuffer = 0; 
     myBitsToGo = BITS_PER_BYTE; 
    } 
    /** 
    * Construct a bit-at-a-time output stream with specified file 
    * name. 
    * @param filename is the name of the file being written 
    * @throws RuntimeException if opening file fails for either FileNotFound 
    * or for Security exceptoins 
    */ 
    public BitOutputStream(String filename) 
    { 
     try{ 
      myOutput = new BufferedOutputStream(new FileOutputStream(filename)); 
     } 
     catch (FileNotFoundException fnf){ 
      throw new RuntimeException("could not create " + filename + " " + fnf); 
     } 
     catch(SecurityException se){ 
      throw new RuntimeException("security exception on write " + se); 
     } 
     initialize(); 
    } 


    /** 
    * Flushes bits not yet written, must be called by client 
    * programs if <code>close</code> isn't called. 
    * @throws RuntimeException if there's a problem writing bits 
    */ 
    public void flush() 
    { 
     if (myBitsToGo != BITS_PER_BYTE) { 
      try{ 
       write((myBuffer << myBitsToGo)); 
      } 
      catch (java.io.IOException ioe){ 
       throw new RuntimeException("error writing bits on flush " + ioe); 
      } 
      myBuffer = 0; 
      myBitsToGo = BITS_PER_BYTE; 
     } 

     try{ 
      myOutput.flush();  
     } 
     catch (java.io.IOException ioe){ 
      throw new RuntimeException("error on flush " + ioe); 
     } 
    } 

    /** 
    * Releases system resources associated with file and 
    * flushes bits not yet written. Either this function 
    * or flush must be called or not all bits will be written 
    * @throws RuntimeException if close fails 
    */ 
    public void close() 
    { 
     flush(); 
     try{ 
      myOutput.close(); 
     } 
     catch (IOException ioe){ 
      throw new RuntimeException("error closing BitOutputStream " + ioe); 
     } 
    } 

    /** 
    * Write specified number of bits from value to a file. 
    * @param howManyBits is number of bits to write (1-32) 
    * @param value is source of bits, rightmost bits are written 
    * @throws RuntimeException if there's an I/O problem writing bits 
    */ 

    public void writeBits(int howManyBits, int value) 
    { 
     value &= bmask[howManyBits]; // only right most bits valid 

     while (howManyBits >= myBitsToGo){ 
      myBuffer = (myBuffer << myBitsToGo) | 
         (value >>> (howManyBits - myBitsToGo)); 
      try{ 
       write(myBuffer);  
      } 
      catch (java.io.IOException ioe){ 
       throw new RuntimeException("error writing bits " + ioe); 
      } 

      value &= bmask[howManyBits - myBitsToGo]; 
      howManyBits -= myBitsToGo; 
      myBitsToGo = BITS_PER_BYTE; 
      myBuffer = 0; 
     } 

     if (howManyBits > 0) { 
      myBuffer = (myBuffer << howManyBits) | value; 
      myBitsToGo -= howManyBits; 
     } 
    } 
} 

BitInputStream

import java.io.*; 

/** 
* Reads bits-at-a-time where the number of bits is between 1 and 32. 
* Updated for version 2.0 to extend java.io.InputStream. This class 
* can be used together with <code>BitOutputStream</code> to facilitate 
* reading and writing data several bits-at-a-time. BitInputStream objects 
* that are constructed from a File support <code>reset()</code>. However, 
* if constructed from an <code>InputStream</code> an object cannot be reset. 
* <P> 
* Any exceptions generated are rethrown as <code>RuntimeException</code> objects 
* so client code does not have to catch or rethrow them. (Unless the extension 
* of <code>InputStream</code> requires throwing as another type of exception, e.g., 
* as with method <code>read</code>. 
* <P> 
* @author Owen Astrachan 
* @version 1.0, July 2000 
* @version 2.0, October 2004 
*/ 

public class BitInputStream extends InputStream 
{ 
    private InputStream  myInput; 
    private int    myBitCount; 
    private int    myBuffer; 
    private File   myFile; 

    private static final int bmask[] = { 
     0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff, 
     0x1ff,0x3ff,0x7ff,0xfff,0x1fff,0x3fff,0x7fff,0xffff, 
     0x1ffff,0x3ffff,0x7ffff,0xfffff,0x1fffff,0x3fffff, 
     0x7fffff,0xffffff,0x1ffffff,0x3ffffff,0x7ffffff, 
     0xfffffff,0x1fffffff,0x3fffffff,0x7fffffff,0xffffffff 
    }; 

    private static final int BITS_PER_BYTE = 8; 
    /** 
    * Construct a bit-at-a-time input stream from a file whose 
    * name is supplied. 
    * @param filename is the name of the file that will be read. 
    * @throws RuntimeException if filename cannot be opened. 
    */ 
    public BitInputStream(String filename) 
    { 
     this(new File(filename)); 
    } 

    /** 
    * Construct a bit-at-a-time input stream from <code>file</code>. 
    * @param file is the File that is the source of the input 
    * @throws RuntimeExceptoin if file cannot be opened. 
    */ 
    public BitInputStream(File file) 
    { 
     myFile = file; 
     try { 
      reset(); 
     } catch (IOException e) { 
      throw new RuntimeException("could not open file for reading bits "+e); 
     } 

    } 

    /** 
    * Open a bit-at-a-time stream that reads from supplied InputStream. If this 
    * constructor is used the BitInputStream is not reset-able. 
    * @param in is the stream from which bits are read. 
    */ 
    public BitInputStream(InputStream in){ 
     myInput = in; 
     myFile = null; 
    } 

    /** 
    * Return true if the stream has been initialized from a File and 
    * is thus reset-able. If constructed from an InputStream it is not reset-able. 
    * @return true if stream can be reset (it has been constructed appropriately from a File). 
    */ 
    public boolean markSupported(){ 
     return myFile != null; 
    } 

    /** 
    * Reset stream to beginning. The implementation creates a new 
    * stream. 
    * @throws IOException if not reset-able (e.g., constructed from InputStream). 
    */ 

    public void reset() throws IOException 
    { 
     if (! markSupported()){ 
      throw new IOException("not resettable"); 
     } 
     try{ 
      close(); 
      myInput = new BufferedInputStream(new FileInputStream(myFile)); 
     } 
     catch (FileNotFoundException fnf){ 
      System.err.println("error opening " + myFile.getName() + " " + fnf); 
     } 
     myBuffer = myBitCount = 0; 
    } 

    /** 
    * Closes the input stream. 
    * @throws RuntimeException if the close fails 
    */ 

    public void close() 
    { 
     try{ 
      if (myInput != null) { 
       myInput.close(); 
      } 
     } 
     catch (java.io.IOException ioe){ 
      throw new RuntimeException("error closing bit stream " + ioe); 
     } 
    } 

    /** 
    * Returns the number of bits requested as rightmost bits in 
    * returned value, returns -1 if not enough bits available to 
    * satisfy the request. 
    * 
    * @param howManyBits is the number of bits to read and return 
    * @return the value read, only rightmost <code>howManyBits</code> 
    * are valid, returns -1 if not enough bits left 
    */ 

    public int readBits(int howManyBits) throws IOException 
    { 
     int retval = 0; 
     if (myInput == null){ 
      return -1; 
     } 

     while (howManyBits > myBitCount){ 
      retval |= (myBuffer << (howManyBits - myBitCount)); 
      howManyBits -= myBitCount; 
      try{ 
       if ((myBuffer = myInput.read()) == -1) { 
        return -1; 
       } 
      } 
      catch (IOException ioe) { 
       throw new IOException("bitreading trouble "+ioe); 
      } 
      myBitCount = BITS_PER_BYTE; 
     } 

     if (howManyBits > 0){ 
      retval |= myBuffer >> (myBitCount - howManyBits); 
      myBuffer &= bmask[myBitCount - howManyBits]; 
      myBitCount -= howManyBits; 
     } 
     return retval; 
    } 

    /** 
    * Required by classes extending InputStream, returns 
    * the next byte from this stream as an int value. 
    * @return the next byte from this stream 
    */ 
    public int read() throws IOException { 
     return readBits(8); 
    } 
}