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




arrays byte (5)

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


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


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

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

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

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


मुझे पता है, शायद यह करने के लिए "सबसे अच्छा" तरीका नहीं है, लेकिन आप प्रत्येक बिट को निम्न कोड से निकाल सकते हैं।

    int n = 156;

String bin = Integer.toBinaryString(n);
System.out.println(bin);

char arr[] = bin.toCharArray();
for(int i = 0; i < arr.length; ++i) {
    System.out.println("Bit number " + (i + 1) + " = " + arr[i]);
}

10011100

बिट संख्या 1 = 1

बिट संख्या 2 = 0

बिट संख्या 3 = 0

बिट संख्या 4 = 1

बिट संख्या 5 = 1

बिट संख्या 6 = 1

बिट संख्या 7 = 0

बिट संख्या 8 = 0


मूल:

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);
    }
}




loops