मैं जावा में फ़ाइल से/बिट्स को बिट्स कैसे पढ़/लिख सकता हूं?

Question

मुझे बिट स्ट्रीम के रूप में फ़ाइल स्ट्रीम पढ़ने की आवश्यकता है और फिर मुझे दोबारा फाइल करने के लिए बिट्स लिखने में सक्षम होना चाहिए। क्या इस उद्देश्य के लिए कोई कक्षाएं हैं?

Answer 1

जहां तक ​​मुझे पता है, इसे सीधे स्तर पर करने के लिए कोई रास्ता नहीं बनाया गया है। अंतर्निर्मित धाराओं का उपयोग करके बाइट द्वारा बाइट को पढ़ने/लिखने के तरीके हैं। आप एक स्ट्रीम पर एक रैपर लिख सकते हैं जो ऐसा लगता है जैसे बिट्स पढ़ता है और लिखता है।

यदि आप पहले से लिखे गए कुछ चीज चाहते हैं, तो ओपन सोर्स प्रोजेक्ट्स की तलाश करें जो कुछ प्रकार के ऑडियो या वीडियो एन्कोडिंग करते हैं, क्योंकि ऐसी चीजें हैं। उदाहरण के लिए, एफएलएसी कोडेक में बिट बिटपुटस्ट्रीम था जो आपकी आवश्यकताओं को पूरा कर सकता है।

Answer 2

मैं सीईआरएन से colt लाइब्रेरी से बहुत खुश था। याद नहीं है कि यह फ़ाइल I/O का समर्थन करता है लेकिन मैंने इसे बिटस्ट्रीम पढ़ने, विश्लेषण और संशोधित करने और फ़ाइलों को वापस लिखने के लिए उपयोग किया।

Answer 3

Preon जो भी आप खोज रहे हैं हो सकता है। अपने प्रश्नों को देखते हुए, मैं कल्पना कर सकता हूं कि प्रीन आप जो भी खोज रहे हैं उससे और हो सकता है।

प्रीऑन को लाइब्रेरी के रूप में सोचें जो बिटस्ट्रीम एन्कोडेड सामग्री को प्रदान करता है जो हाइबरनेट का उद्देश्य डाटाबेस को रिलेशनल करना है, और जेएक्सबी को एक्सएमएल में रखना है। अब, यह कुछ मॉड्यूल की मौजूदगी है। उन मॉड्यूल में से एक preon बाध्यकारी है। यह वास्तविक डेटा बाध्यकारी ढांचा है। (एनोटेशन द्वारा संचालित।)

हालांकि, प्रीऑन-बाइंडिंग प्रीऑन-बिटबफर के शीर्ष पर बनाया गया है (बाद में अवतारों को प्रीऑन-आईओ में फिर से डब किया गया है)। उस लाइब्रेरी में बिटस्ट्रीम संपीड़ित डेटा तक पहुंचने के लिए बिटबफर प्रकार का अबास्ट्रक्शन है।

alt text http://preon.flotsam.nl/images/layers.png

Preon रिहाई पिछली गर्मियों में अभी तक एन्कोडिंग के लिए समर्थन नहीं है। यह काम प्रगति पर है।

Answer 4

https://github.com/jinahya/bit-io

ले जाया गया कृपया http://jinahya.googlecode.com/svn/trunk/com.googlecode.jinahya/bit-io/src/main/java/com/googlecode/jinahya/io/

<dependency> 
    <!-- resides in central repo --> 
    <groupId>com.googlecode.jinahya</groupId> 
    <artifactId>bit-io</artifactId> 
    <version>1.0-alpha-13</version> 
</dependency> 

पर एक नज़र डालें यह पढ़ने के लिए एक छोटा सा काम पुस्तकालय/है जावा के साथ बिट्स की मनमाने ढंग से लंबाई लेखन।

final InputStream stream; 
final BitInput input = new BitInput(new BitInput.StreamInput(stream)); 

final int b = input.readBoolean(); // reads a 1-bit boolean value 
final int i = input.readUnsignedInt(3); // reads a 3-bit unsigned int 
final long l = input.readLong(47); // reads a 47-bit signed long 

input.align(1); // 8-bit byte align; padding 


final WritableByteChannel channel; 
final BitOutput output = new BitOutput(new BitOutput.ChannelOutput(channel)); 

output.writeBoolean(true); // writes a 1-bit boolean value 
output.writeInt(17, 0x00); // writes a 17-bit signed int 
output.writeUnsignedLong(54, 0x00L); // writes a 54-bit unsigned long 

output.align(4); // 32-bit byte align; discarding 

Answer 5

और बस आपको अपना स्वयं का स्ट्रीम रैपर तैयार करने का विचार देने के लिए, यहां कोड स्निपेट है। अगर थोड़ा उपलब्ध है, या -1 अंतर्निहित धारा के अंत तक पहुँच जाता है, तो

import java.io.FilterInputStream; 
import java.io.IOException; 
import java.io.InputStream; 

public class BitInputStream extends FilterInputStream { 

    private int bitsBuffer = -1; 

    private int remainingBits = 0; 

    public BitInputStream(InputStream in) { 
     super(in); 
    } 

    @Override 
    public int read() throws IOException { 
     if (remainingBits == 0) { 
      bitsBuffer = in.read(); 
      remainingBits = Byte.SIZE; 
     } 
     if (bitsBuffer == -1) { 
      return -1; 
     } 
     remainingBits--; 
     return (bitsBuffer >> remainingBits) & 1; 
    } 

} 

आप पढ़ने() विधि देख सकते हैं 0 या 1 वापस जाने के लिए ओवरराइड है।

import org.junit.Test; 
import java.io.ByteArrayInputStream; 
import static org.junit.Assert.assertEquals; 

public class BitInputStreamTest { 

    @Test 
    public void read() throws Exception { 
     // 99 in two's complement binary form is 01100011 
     BitInputStream in = new BitInputStream(
      new ByteArrayInputStream(new byte[]{99})); 

     assertEquals(0, in.read()); 
     assertEquals(1, in.read()); 
     assertEquals(1, in.read()); 
     assertEquals(0, in.read()); 

     assertEquals(0, in.read()); 
     assertEquals(0, in.read()); 
     assertEquals(1, in.read()); 
     assertEquals(1, in.read()); 

     assertEquals(-1, in.read()); 
    } 

}