Java Iterate Bits in Byte Array

Question

How can i iterate bits in a byte array?

Solution 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...

Solution 2

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

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

Solution 4

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.

Solution 5

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

View more solutions

Comments

[palantus]

I'd say C# if I had to guess.

[palantus]

@Oscar: That's a left-shift operator. Java has it too.

[Reginaldo]

It's cool because it makes no use of those "scary" bitwise operations.

[eric-hunter]

I don't see any need to use the bitwise operator for something as simple as the OP asked for: iterate through the bits.

[Jonik]

This would answer the question better if it showed how to extract bits from a byte array (instead of String or char array)