java बाइट ऐरे में जावा इटरेट बिट्स




arrays byte (6)

आप बाइट सरणी के माध्यम से पुनरावृत्त कर सकते हैं, और प्रत्येक बाइट बिट बिट ऑपरेटर का उपयोग इसके बिट्स के बावजूद फिर से करने के लिए करते हैं।

मैं बाइट सरणी में बिट्स को कैसे पुन: सक्रिय कर सकता हूं?


एक विकल्प BitInputStream का उपयोग करना होगा जैसा कि आप here पा सकते हैं और इस तरह कोड लिख सकते हैं:

BitInputStream bin = new BitInputStream(new ByteArrayInputStream(bytes));
    while(true){
        int bit = bin.readBit();
        // do something
    }
bin.close();

(नोट: कोड में ब्रेवटी के लिए EOFException या IOException हैंडलिंग शामिल नहीं है।)

लेकिन मैं जॉन स्कीट्स संस्करण के साथ जाऊंगा और इसे अपने आप करूँगा।


मुझे अपने आवेदन में कुछ स्ट्रीमिंग की आवश्यकता थी। Here आप मेरा बिटरएरे कार्यान्वयन पा सकते हैं। यह वास्तविक इटरेटर पैटर्न नहीं है लेकिन आप स्ट्रीमिंग तरीके से सरणी से 1-32 बिट्स मांग सकते हैं। फ़ाइल में बाद में बिटराइडर नामक एक वैकल्पिक कार्यान्वयन भी है।


मूल:

for (int i = 0; i < byteArray.Length; i++)
{
   byte b = byteArray[i];
   byte mask = 0x01;
   for (int j = 0; j < 8; j++)
   {
      bool value = b & mask;
      mask << 1;
   }
}

या जावा idioms का उपयोग कर

for (byte b : byteArray ) {
  for ( int mask = 0x01; mask != 0x100; mask <<= 1 ) {
      boolean value = ( b & mask ) != 0;
  }
}

public class ByteArrayBitIterable implements Iterable<Boolean> {
    private final byte[] array;

    public ByteArrayBitIterable(byte[] array) {
        this.array = array;
    }

    public Iterator<Boolean> iterator() {
        return new Iterator<Boolean>() {
            private int bitIndex = 0;
            private int arrayIndex = 0;

            public boolean hasNext() {
                return (arrayIndex < array.length) && (bitIndex < 8);
            }

            public Boolean next() {
                Boolean val = (array[arrayIndex] >> (7 - bitIndex) & 1) == 1;
                bitIndex++;
                if (bitIndex == 8) {
                    bitIndex = 0;
                    arrayIndex++;
                }
                return val;
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }

    public static void main(String[] a) {
        ByteArrayBitIterable test = new ByteArrayBitIterable(
                   new byte[]{(byte)0xAA, (byte)0xAA});
        for (boolean b : test)
            System.out.println(b);
    }
}

आपको Iterable<Boolean> का अपना कार्यान्वयन लिखना होगा, जिसने बाइट्स की एक सरणी ली थी, और फिर Iterator<Boolean> मानों को बनाया जो वर्तमान इंडेक्स को बाइट सरणी और वर्तमान बाइट के भीतर वर्तमान इंडेक्स में याद करते थे। फिर इस तरह की एक उपयोगिता विधि काम में आ जाएगी:

private static Boolean isBitSet(byte b, int bit)
{
    return (b & (1 << bit)) != 0;
}

(जहां bit 0 से 7 तक है)। प्रत्येक बार next() को कॉल किया गया था, आपको वर्तमान बाइट के भीतर अपनी बिट इंडेक्स में वृद्धि करना होगा, और बाइट सरणी के भीतर बाइट इंडेक्स में वृद्धि करना होगा यदि आप "9वीं बिट" तक पहुंचे।

यह वास्तव में कठिन नहीं है - लेकिन दर्द का थोड़ा सा। अगर आप नमूना कार्यान्वयन चाहते हैं तो मुझे बताएं ...





loops