Java Iterate Bits in Byte Array

Question

How can i iterate bits in a byte array?

Answer 1

You'd have to write your own implementation of Iterable<Boolean> which took an array of bytes, and then created Iterator<Boolean> values which remembered the current index into the byte array and the current index within the current byte. Then a utility method like this would come in handy:

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

(where bit ranges from 0 to 7). Each time next() was called you'd have to increment your bit index within the current byte, and increment the byte index within byte array if you reached "the 9th bit".

It's not really hard - but a bit of a pain. Let me know if you'd like a sample implementation...

Answer 2

You can iterate through the byte array, and for each byte use the bitwise operators to iterate though its bits.

Answer 3

Original:

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

Or using Java idioms

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

Answer 4

I needed some bit streaming in my application. Here you can find my BitArray implementation. It is not a real iterator pattern but you can ask for 1-32 bits from the array in a streaming way. There is also an alternate implementation called BitReader later in the file.

Answer 5

An alternative would be to use a BitInputStream like the one you can find here and write code like this:

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

(Note: Code doesn't contain EOFException or IOException handling for brevity.)

But I'd go with Jon Skeets variant and do it on my own.

Answer 6

I know, probably not the "coolest" way to do it, but you can extract each bit with the following code.

    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

Bit number 1 = 1

Bit number 2 = 0

Bit number 3 = 0

Bit number 4 = 1

Bit number 5 = 1

Bit number 6 = 1

Bit number 7 = 0

Bit number 8 = 0

Answer 7

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