Java Utililty Methods Array Unpack

List of utility methods to do Array Unpack

  1. HOME
  2. Java
  3. A
  4. Array Unpack

Description

The list of methods to do Array Unpack are organized into topic(s).

Method

StringBufferunpack(byte[] array)
unpack 
int len = array.length;
int length = len << 1;
StringBuffer buf = new StringBuffer(length);
buf.setLength(length);
for (int i = 0, j = 0; i < len; ++i) {
    byte by = array[i];
    byte hi = (byte) ((by & 0xF0) >> 4);
    byte lo = (byte) (by & 0x0F);
...
Stringunpack(byte[] bytes)
unpack 
if (bytes.length == 0)
    return "";
int len = bytes[0] & 0xFF, off = 1;
StringBuilder builder = new StringBuilder();
int key = 0;
for (;;) {
    byte b = bytes[off++];
    for (int mask = 0x80; mask != 0; mask >>= 1) {
...
double[][]unpack(double[] packed, int width, int height, int outputIndex)
Returns a new array that is the result of unpacking the given 1D array into a 2D array, row-first. 
double[][] unpacked = new double[height][width];
return unpack(packed, unpacked, outputIndex);
intunpack(int[] sourcearray, int arraypos, int[] data, int datapos, int num, int b)
unpack 
if (b > 16) {
    System.arraycopy(sourcearray, arraypos, data, 0, num);
    return num + arraypos;
final int mask = (1 << b) - 1;
int inwordpointer = 0;
for (int k = 0; k < num; ++k) {
    data[k + datapos] = ((sourcearray[arraypos] >>> inwordpointer) & mask);
...
byte[]unpackBCD(byte[] source)
Unpack the binary-coded decimal. 
byte[] ret = new byte[source.length * 2];
int index = 0;
for (byte aSource : source) {
    ret[index + 1] = (byte) (aSource & 0x0F);
    ret[index] = (byte) ((aSource >> 4) & 0x0F);
    index += 2;
return ret;
...
boolean[]unpackDie(byte[] bytes)
unpack Die 
boolean[] bits = new boolean[bytes.length * 8];
int mask = 1;
for (int i = 0; i < bits.length; i++) {
    int dataIndex = i / 8;
    byte dataByte = bytes[dataIndex];
    int bitIndex = i % 8;
    bits[i] = (dataByte & ((byte) (mask << bitIndex))) != 0;
return bits;
byte[]UnpackFloat(byte[] bytes, float value)
Unpacks a floating-point value into four bytes. 
int intBits = Float.floatToRawIntBits(value);
return UnpackLittle32(bytes, intBits);
voidUnpackFloatBuffer(byte[] buffer, long bytes_read, long num_loaded, float[] list)
Get the float values stored in the input file buffer and put the values into the proper positions in the list[] array. 
int index = (int) (num_loaded);
for (int i = 0; i < bytes_read; i += 4)
    list[index++] = getFloat_32(buffer, i);
intunpackInt(byte[] data, int offset)
Unpack an int stored as MSB first in a byte array 
int value = 0;
value |= (data[offset] << 24) & 0xff000000;
value |= (data[offset + 1] << 16) & 0x00ff0000;
value |= (data[offset + 2] << 8) & 0x0000ff00;
value |= data[offset + 3] & 0x000000ff;
return value;
intunpackIntegerByWidth(int len, byte[] buf, int offset)
Unpack a big endian integer, of a given length, from a byte array. 
if (len == 1) {
    return buf[offset];
} else if (len == 2) {
    return (buf[offset] << 24 | (buf[offset + 1] & 0xFF) << 16) >> 16;
} else if (len == 3) {
    return (buf[offset] << 24 | (buf[offset + 1] & 0xFF) << 16 | (buf[offset + 2] & 0xFF) << 8) >> 8;
} else if (len == 4) {
    return buf[offset] << 24 | (buf[offset + 1] & 0xFF) << 16 | (buf[offset + 2] & 0xFF) << 8
...