CODEWITHSUNDEEP
javaarraysbytebitloops
Hamza Yerlikaya
Hamza Yerlikaya

Reputation: 49329

Java Iterate Bits in Byte Array

How can i iterate bits in a byte array?

Upvotes: 36

Views: 53664

Answers (8)

dan1st
dan1st

Reputation: 16373

In addition to the approaches shown in the other answers, you can use BitSet for this:

byte[] bytes = ...;
BitSet bitSet = BitSet.valueOf(bytes);
for(int i = 0; i < bitSet.length(); i++){
    boolean bit = bitSet.get(i);
    //use your bit
}

BitSet.valueOf was introduced in Java 7.

Upvotes: 1

Matthew Flaschen
Matthew Flaschen

Reputation: 284836

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

Upvotes: 18

Paul Sonier
Paul Sonier

Reputation: 39480

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

Upvotes: 10

amischiefr
amischiefr

Reputation: 4880

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

Upvotes: 1

the.duckman
the.duckman

Reputation: 6406

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.

Upvotes: 2

akarnokd
akarnokd

Reputation: 69997

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.

Upvotes: 1

HasaniH
HasaniH

Reputation: 8402

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

Upvotes: 0

Jon Skeet
Jon Skeet

Reputation: 1500815

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

Upvotes: 43

Related Questions