Translates between byte arrays and strings of "0"s and "1"s. : Byte Array « File « Java Tutorial






/*
 * Copyright 2001-2004 The Apache Software Foundation.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Translates between byte arrays and strings of "0"s and "1"s.
 * 
 * @todo may want to add more bit vector functions like and/or/xor/nand
 * @todo also might be good to generate boolean[] from byte[] et. cetera.
 * 
 * @author Apache Software Foundation
 * @since 1.3
 * @version $Id $
 */
public class BinaryCodec {
  /*
   * tried to avoid using ArrayUtils to minimize dependencies while using these
   * empty arrays - dep is just not worth it.
   */
  /** Empty char array. */
  private static final char[] EMPTY_CHAR_ARRAY = new char[0];

  /** Empty byte array. */
  private static final byte[] EMPTY_BYTE_ARRAY = new byte[0];

  /** Mask for bit 0 of a byte. */
  private static final int BIT_0 = 1;

  /** Mask for bit 1 of a byte. */
  private static final int BIT_1 = 0x02;

  /** Mask for bit 2 of a byte. */
  private static final int BIT_2 = 0x04;

  /** Mask for bit 3 of a byte. */
  private static final int BIT_3 = 0x08;

  /** Mask for bit 4 of a byte. */
  private static final int BIT_4 = 0x10;

  /** Mask for bit 5 of a byte. */
  private static final int BIT_5 = 0x20;

  /** Mask for bit 6 of a byte. */
  private static final int BIT_6 = 0x40;

  /** Mask for bit 7 of a byte. */
  private static final int BIT_7 = 0x80;

  private static final int[] BITS = { BIT_0, BIT_1, BIT_2, BIT_3, BIT_4, BIT_5, BIT_6, BIT_7 };

  /**
   * Converts an array of raw binary data into an array of ascii 0 and 1
   * characters.
   * 
   * @param raw
   *          the raw binary data to convert
   * @return 0 and 1 ascii character bytes one for each bit of the argument
   * @see org.apache.commons.codec.BinaryEncoder#encode(byte[])
   */
  public byte[] encode(byte[] raw) {
    return toAsciiBytes(raw);
  }

  /**
   * Converts an array of raw binary data into an array of ascii 0 and 1 chars.
   * 
   * @param raw
   *          the raw binary data to convert
   * @return 0 and 1 ascii character chars one for each bit of the argument
   * @throws EncoderException
   *           if the argument is not a byte[]
   * @see org.apache.commons.codec.Encoder#encode(java.lang.Object)
   */
  public Object encode(Object raw) throws RuntimeException {
    if (!(raw instanceof byte[])) {
      throw new RuntimeException("argument not a byte array");
    }
    return toAsciiChars((byte[]) raw);
  }

  /**
   * Decodes a byte array where each byte represents an ascii '0' or '1'.
   * 
   * @param ascii
   *          each byte represents an ascii '0' or '1'
   * @return the raw encoded binary where each bit corresponds to a byte in the
   *         byte array argument
   * @throws DecoderException
   *           if argument is not a byte[], char[] or String
   * @see org.apache.commons.codec.Decoder#decode(java.lang.Object)
   */
  public Object decode(Object ascii) throws RuntimeException {
    if (ascii == null) {
      return EMPTY_BYTE_ARRAY;
    }
    if (ascii instanceof byte[]) {
      return fromAscii((byte[]) ascii);
    }
    if (ascii instanceof char[]) {
      return fromAscii((char[]) ascii);
    }
    if (ascii instanceof String) {
      return fromAscii(((String) ascii).toCharArray());
    }
    throw new RuntimeException("argument not a byte array");
  }

  /**
   * Decodes a byte array where each byte represents an ascii '0' or '1'.
   * 
   * @param ascii
   *          each byte represents an ascii '0' or '1'
   * @return the raw encoded binary where each bit corresponds to a byte in the
   *         byte array argument
   * @see org.apache.commons.codec.Decoder#decode(Object)
   */
  public byte[] decode(byte[] ascii) {
    return fromAscii(ascii);
  }

  /**
   * Decodes a String where each char of the String represents an ascii '0' or
   * '1'.
   * 
   * @param ascii
   *          String of '0' and '1' characters
   * @return the raw encoded binary where each bit corresponds to a byte in the
   *         byte array argument
   * @see org.apache.commons.codec.Decoder#decode(Object)
   */
  public byte[] toByteArray(String ascii) {
    if (ascii == null) {
      return EMPTY_BYTE_ARRAY;
    }
    return fromAscii(ascii.toCharArray());
  }

  // ------------------------------------------------------------------------
  //
  // static codec operations
  //
  // ------------------------------------------------------------------------
  /**
   * Decodes a byte array where each char represents an ascii '0' or '1'.
   * 
   * @param ascii
   *          each char represents an ascii '0' or '1'
   * @return the raw encoded binary where each bit corresponds to a char in the
   *         char array argument
   */
  public static byte[] fromAscii(char[] ascii) {
    if (ascii == null || ascii.length == 0) {
      return EMPTY_BYTE_ARRAY;
    }
    // get length/8 times bytes with 3 bit shifts to the right of the length
    byte[] l_raw = new byte[ascii.length >> 3];
    /*
     * We decr index jj by 8 as we go along to not recompute indices using
     * multiplication every time inside the loop.
     */
    for (int ii = 0, jj = ascii.length - 1; ii < l_raw.length; ii++, jj -= 8) {
      for (int bits = 0; bits < BITS.length; ++bits) {
        if (ascii[jj - bits] == '1') {
          l_raw[ii] |= BITS[bits];
        }
      }
    }
    return l_raw;
  }

  /**
   * Decodes a byte array where each byte represents an ascii '0' or '1'.
   * 
   * @param ascii
   *          each byte represents an ascii '0' or '1'
   * @return the raw encoded binary where each bit corresponds to a byte in the
   *         byte array argument
   */
  public static byte[] fromAscii(byte[] ascii) {
    if (ascii == null || ascii.length == 0) {
      return EMPTY_BYTE_ARRAY;
    }
    // get length/8 times bytes with 3 bit shifts to the right of the length
    byte[] l_raw = new byte[ascii.length >> 3];
    /*
     * We decr index jj by 8 as we go along to not recompute indices using
     * multiplication every time inside the loop.
     */
    for (int ii = 0, jj = ascii.length - 1; ii < l_raw.length; ii++, jj -= 8) {
      for (int bits = 0; bits < BITS.length; ++bits) {
        if (ascii[jj - bits] == '1') {
          l_raw[ii] |= BITS[bits];
        }
      }
    }
    return l_raw;
  }

  /**
   * Converts an array of raw binary data into an array of ascii 0 and 1
   * character bytes - each byte is a truncated char.
   * 
   * @param raw
   *          the raw binary data to convert
   * @return an array of 0 and 1 character bytes for each bit of the argument
   * @see org.apache.commons.codec.BinaryEncoder#encode(byte[])
   */
  public static byte[] toAsciiBytes(byte[] raw) {
    if (raw == null || raw.length == 0) {
      return EMPTY_BYTE_ARRAY;
    }
    // get 8 times the bytes with 3 bit shifts to the left of the length
    byte[] l_ascii = new byte[raw.length << 3];
    /*
     * We decr index jj by 8 as we go along to not recompute indices using
     * multiplication every time inside the loop.
     */
    for (int ii = 0, jj = l_ascii.length - 1; ii < raw.length; ii++, jj -= 8) {
      for (int bits = 0; bits < BITS.length; ++bits) {
        if ((raw[ii] & BITS[bits]) == 0) {
          l_ascii[jj - bits] = '0';
        } else {
          l_ascii[jj - bits] = '1';
        }
      }
    }
    return l_ascii;
  }

  /**
   * Converts an array of raw binary data into an array of ascii 0 and 1
   * characters.
   * 
   * @param raw
   *          the raw binary data to convert
   * @return an array of 0 and 1 characters for each bit of the argument
   * @see org.apache.commons.codec.BinaryEncoder#encode(byte[])
   */
  public static char[] toAsciiChars(byte[] raw) {
    if (raw == null || raw.length == 0) {
      return EMPTY_CHAR_ARRAY;
    }
    // get 8 times the bytes with 3 bit shifts to the left of the length
    char[] l_ascii = new char[raw.length << 3];
    /*
     * We decr index jj by 8 as we go along to not recompute indices using
     * multiplication every time inside the loop.
     */
    for (int ii = 0, jj = l_ascii.length - 1; ii < raw.length; ii++, jj -= 8) {
      for (int bits = 0; bits < BITS.length; ++bits) {
        if ((raw[ii] & BITS[bits]) == 0) {
          l_ascii[jj - bits] = '0';
        } else {
          l_ascii[jj - bits] = '1';
        }
      }
    }
    return l_ascii;
  }

  /**
   * Converts an array of raw binary data into a String of ascii 0 and 1
   * characters.
   * 
   * @param raw
   *          the raw binary data to convert
   * @return a String of 0 and 1 characters representing the binary data
   * @see org.apache.commons.codec.BinaryEncoder#encode(byte[])
   */
  public static String toAsciiString(byte[] raw) {
    return new String(toAsciiChars(raw));
  }
}








11.77.Byte Array
11.77.1.Load file to byte array
11.77.2.Load File as byte array
11.77.3.Convert Byte array to Int
11.77.4.Gets an array of bytes corresponding to the given object
11.77.5.Convert byte array to string
11.77.6.An optimized reader for reading byte streams that only contain 7-bit ASCII characters.
11.77.7.Convert a base16 string into a byte array.
11.77.8.Convert a byte array to a human-readable String for debugging purposes.
11.77.9.Convert the bytes within the specified range of the given byte array into a String
11.77.10.Convert the bytes within the specified range of the given byte array into a signed integer in the given radix
11.77.11.Converts a byte array into a hexadecimal string
11.77.12.Converts a byte array into hexadecimal characters which are written as ASCII to the given output stream.
11.77.13.Decode hex string to a byte array
11.77.14.Encode a byte array to hex string
11.77.15.Get bytes from InputStream
11.77.16.Read and return the entire contents of the supplied file.
11.77.17.Reads bytes available from one InputStream and returns these bytes in a byte array.
11.77.18.Return the specified class. Checks the ThreadContext classloader first, then uses the System classloader.
11.77.19.Translates between byte arrays and strings of "0"s and "1"s.