Store binary sequence in byte array?

Question

I need to store a couple binary sequences that are 16 bits in length into a byte array (of length 2). The one or two binary numbers don\'t change, so a function that does co

Answer 1

I have been disappointed with all of the solutions I have found to converting strings of bits to byte arrays and vice versa -- all have been buggy (even the BigInteger solution above), and very few are as efficient as they should be.

I realize the OP was only concerned with a bit string to an array of two bytes, which the BitInteger approach seems to work fine for. However, since this post is currently the first search result when searching "bit string to byte array java" in Google, I am going to post my general solution here for people dealing with huge strings and/or huge byte arrays.

Note that my solution below is the only solution I have ran that passes all of my test cases -- many online solutions to this relatively simple problem simply do not work.

Code

/**
 * Zips (compresses) bit strings to byte arrays and unzips (decompresses)
 * byte arrays to bit strings.
 *
 * @author ryan
 *
 */
public class BitZip {

  private static final byte[] BIT_MASKS = new byte[] {1, 2, 4, 8, 16, 32, 64, -128};
  private static final int BITS_PER_BYTE = 8;
  private static final int MAX_BIT_INDEX_IN_BYTE = BITS_PER_BYTE - 1;

  /**
   * Decompress the specified byte array to a string.
   * <p>
   * This function does not pad with zeros for any bit-string result
   * with a length indivisible by 8.
   *
   * @param bytes The bytes to convert into a string of bits, with byte[0]
   *              consisting of the least significant bits in the byte array.
   * @return The string of bits representing the byte array.
   */
  public static final String unzip(final byte[] bytes) {
    int byteCount = bytes.length;
    int bitCount = byteCount * BITS_PER_BYTE;

    char[] bits = new char[bitCount];
    {
      int bytesIndex = 0;
      int iLeft = Math.max(bitCount - BITS_PER_BYTE, 0);
      while (bytesIndex < byteCount) {
        byte value = bytes[bytesIndex];
        for (int b = MAX_BIT_INDEX_IN_BYTE; b >= 0; --b) {
          bits[iLeft + b] = ((value % 2) == 0 ? '0' : '1');
          value >>= 1;
        }
        iLeft = Math.max(iLeft - BITS_PER_BYTE, 0);
        ++bytesIndex;
      }
    }
    return new String(bits).replaceFirst("^0+(?!$)", "");
  }

  /**
   * Compresses the specified bit string to a byte array, ignoring trailing
   * zeros past the most significant set bit.
   *
   * @param bits The string of bits (composed strictly of '0' and '1' characters)
   *             to convert into an array of bytes.
   * @return The bits, as a byte array with byte[0] containing the least
   *         significant bits.
   */
  public static final byte[] zip(final String bits) {
    if ((bits == null) || bits.isEmpty()) {
      // No observations -- return nothing.
      return new byte[0];
    }
    char[] bitChars = bits.toCharArray();

    int bitCount = bitChars.length;
    int left;

    for (left = 0; left < bitCount; ++left) {
      // Ignore leading zeros.
      if (bitChars[left] == '1') {
        break;
      }
    }
    if (bitCount == left) {
      // Only '0's in the string.
      return new byte[] {0};
    }
    int cBits = bitCount - left;
    byte[] bytes = new byte[((cBits) / BITS_PER_BYTE) + (((cBits % BITS_PER_BYTE) > 0) ? 1 : 0)];
    {
      int iRight = bitCount - 1;
      int iLeft = Math.max(bitCount - BITS_PER_BYTE, left);
      int bytesIndex = 0;
      byte _byte = 0;

      while (bytesIndex < bytes.length) {
        while (iLeft <= iRight) {
          if (bitChars[iLeft] == '1') {
            _byte |= BIT_MASKS[iRight - iLeft];
          }
          ++iLeft;
        }
        bytes[bytesIndex++] = _byte;
        iRight = Math.max(iRight - BITS_PER_BYTE, left);
        iLeft = Math.max((1 + iRight) - BITS_PER_BYTE, left);
        _byte = 0;
      }
    }
    return bytes;
  }
}

Performance

I was bored at work so I did some performance testing comparing against the accepted answer here for when N is large. (Pretending to ignore the fact that the BigInteger approach posted above doesn't even work properly as a general approach.)

This is running with a random bit string of size 5M and a random byte array of size 1M:

String -> byte[] -- BigInteger result: 39098ms
String -> byte[] -- BitZip result:     29ms
byte[] -> String -- Integer result:    138ms
byte[] -> String -- BitZip result:     71ms

And the code:

  public static void main(String[] argv) {

    int testByteLength = 1000000;
    int testStringLength = 5000000;

    // Independently random.
    final byte[] randomBytes = new byte[testByteLength];
    final String randomBitString;
    {
      StringBuilder sb = new StringBuilder();
      Random rand = new Random();

      for (int i = 0; i < testStringLength; ++i) {
        int value = rand.nextInt(1 + i);
        sb.append((value % 2) == 0 ? '0' : '1');
        randomBytes[i % testByteLength] = (byte) value;
      }
      randomBitString = sb.toString();
    }

    byte[] resultCompress;
    String resultDecompress;
    {
      Stopwatch s = new Stopwatch();
      TimeUnit ms = TimeUnit.MILLISECONDS;
      {
        s.start();
        {
          resultCompress = compressFromBigIntegerToByteArray(randomBitString);
        }
        s.stop();
        {
          System.out.println("String -> byte[] -- BigInteger result: " + s.elapsed(ms) + "ms");
        }
        s.reset();
      }
      {
        s.start();
        {
          resultCompress = zip(randomBitString);
        }
        s.stop();
        {
          System.out.println("String -> byte[] -- BitZip result:     " + s.elapsed(ms) + "ms");
        }
        s.reset();
      }
      {
        s.start();
        {
          resultDecompress = decompressFromIntegerParseInt(randomBytes);
        }
        s.stop();
        {
          System.out.println("byte[] -> String -- Integer result:    " + s.elapsed(ms) + "ms");
        }
        s.reset();
      }
      {
        s.start();
        {
          resultDecompress = unzip(randomBytes);
        }
        s.stop();
        {
          System.out.println("byte[] -> String -- BitZip result:     " + s.elapsed(ms) + "ms");
        }
        s.reset();
      }
    }
  }

Answer 2

    String val = "1111000011110001";
    byte[] bval = new BigInteger(val, 2).toByteArray();

There are other options, but I found it best to use BigInteger class, that has conversion to byte array, for this kind of problems. I prefer if, because I can instantiate class from String, that can represent various bases like 8, 16, etc. and also output it as such.

Edit: Mondays ... :P

public static byte[] getRoger(String val) throws NumberFormatException,
        NullPointerException {
    byte[] result = new byte[2];
    byte[] holder = new BigInteger(val, 2).toByteArray();
    
    if (holder.length == 1) result[0] = holder[0];
    else if (holder.length > 1) {
        result[1] = holder[holder.length - 2];
        result[0] = holder[holder.length - 1];
    }
    return result;
}

Example:

int bitarray = 12321;
String val = Integer.toString(bitarray, 2);
System.out.println(new StringBuilder().append(bitarray).append(':').append(val)
  .append(':').append(Arrays.toString(getRoger(val))).append('\n'));