/* ========================= */
/* "primitive type --> byte[] data" Methods */
/* ========================= */
 
public static byte[] toByta(byte data) {
    return new byte[]{data};
}
 
public static byte[] toByta(byte[] data) {
    return data;
}
 
/* ========================= */
 
public static byte[] toByta(short data) {
    return new byte[] {
        (byte)((data >> 8) & 0xff),
        (byte)((data >> 0) & 0xff),
    };
}
 
public static byte[] toByta(short[] data) {
    if (data == null) return null;
    // ----------
    byte[] byts = new byte[data.length * 2];
    for (int i = 0; i < data.length; i++)
        System.arraycopy(toByta(data[i]), 0, byts, i * 2, 2);
    return byts;
}
 
/* ========================= */
 
public static byte[] toByta(char data) {
    return new byte[] {
        (byte)((data >> 8) & 0xff),
        (byte)((data >> 0) & 0xff),
    };
}
 
public static byte[] toByta(char[] data) {
    if (data == null) return null;
    // ----------
    byte[] byts = new byte[data.length * 2];
    for (int i = 0; i < data.length; i++)
        System.arraycopy(toByta(data[i]), 0, byts, i * 2, 2);
    return byts;
}
 
/* ========================= */
 
public static byte[] toByta(int data) {
    return new byte[] {
        (byte)((data >> 24) & 0xff),
        (byte)((data >> 16) & 0xff),
        (byte)((data >> 8) & 0xff),
        (byte)((data >> 0) & 0xff),
    };
}
 
public static byte[] toByta(int[] data) {
    if (data == null) return null;
    // ----------
    byte[] byts = new byte[data.length * 4];
    for (int i = 0; i < data.length; i++)
        System.arraycopy(toByta(data[i]), 0, byts, i * 4, 4);
    return byts;
}
 
/* ========================= */
 
public static byte[] toByta(long data) {
    return new byte[] {
        (byte)((data >> 56) & 0xff),
        (byte)((data >> 48) & 0xff),
        (byte)((data >> 40) & 0xff),
        (byte)((data >> 32) & 0xff),
        (byte)((data >> 24) & 0xff),
        (byte)((data >> 16) & 0xff),
        (byte)((data >> 8) & 0xff),
        (byte)((data >> 0) & 0xff),
    };
}
 
public static byte[] toByta(long[] data) {
    if (data == null) return null;
    // ----------
    byte[] byts = new byte[data.length * 8];
    for (int i = 0; i < data.length; i++)
        System.arraycopy(toByta(data[i]), 0, byts, i * 8, 8);
    return byts;
}
 
/* ========================= */
 
public static byte[] toByta(float data) {
    return toByta(Float.floatToRawIntBits(data));
}
 
public static byte[] toByta(float[] data) {
    if (data == null) return null;
    // ----------
    byte[] byts = new byte[data.length * 4];
    for (int i = 0; i < data.length; i++)
        System.arraycopy(toByta(data[i]), 0, byts, i * 4, 4);
    return byts;
}
 
/* ========================= */
 
public static byte[] toByta(double data) {
    return toByta(Double.doubleToRawLongBits(data));
}
 
public static byte[] toByta(double[] data) {
    if (data == null) return null;
    // ----------
    byte[] byts = new byte[data.length * 8];
    for (int i = 0; i < data.length; i++)
        System.arraycopy(toByta(data[i]), 0, byts, i * 8, 8);
    return byts;
}
 
/* ========================= */
 
public static byte[] toByta(boolean data) {
    return new byte[]{(byte)(data ? 0x01 : 0x00)}; // bool -> {1 byte}
}
 
public static byte[] toByta(boolean[] data) {
    // Advanced Technique: The byte array containts information
    // about how many boolean values are involved, so the exact
    // array is returned when later decoded.
    // ----------
    if (data == null) return null;
    // ----------
    int len = data.length;
    byte[] lena = toByta(len); // int conversion; length array = lena
    byte[] byts = new byte[lena.length + (len / 8) + (len % 8 != 0 ? 1 : 0)];
    // (Above) length-array-length + sets-of-8-booleans +? byte-for-remainder
    System.arraycopy(lena, 0, byts, 0, lena.length);
    // ----------
    // (Below) algorithm by Matthew Cudmore: boolean[] -> bits -> byte[]
    for (int i = 0, j = lena.length, k = 7; i < data.length; i++) {
        byts[j] |= (data[i] ? 1 : 0) << k--;
        if (k < 0) { j++; k = 7; }
    }
    // ----------
    return byts;
}
 
/* ========================= */
 
public static byte[] toByta(String data) {
    return (data == null) ? null : data.getBytes();
}
 
public static byte[] toByta(String[] data) {
    // Advanced Technique: Generates an indexed byte array
    // which contains the array of Strings. The byte array
    // contains information about the number of Strings and
    // the length of each String.
    // ----------
    if (data == null) return null;
    // ---------- flags:
    int totalLength = 0; // Measure length of final byte array
    int bytesPos = 0; // Used later
    // ----- arrays:
    byte[] dLen = toByta(data.length); // byte array of data length
    totalLength += dLen.length;
    int[] sLens = new int[data.length]; // String lengths = sLens
    totalLength += (sLens.length * 4);
    byte[][] strs = new byte[data.length][]; // array of String bytes
    // ----- pack strs:
    for (int i = 0; i < data.length; i++) {
        if (data[i] != null) {
            strs[i] = toByta(data[i]);
            sLens[i] = strs[i].length;
            totalLength += strs[i].length;
        } else {
            sLens[i] = 0;
            strs[i] = new byte[0]; // prevent null entries
        }
    }
    // ----------
    byte[] bytes = new byte[totalLength]; // final array
    System.arraycopy(dLen, 0, bytes, 0, 4);
    byte[] bsLens = toByta(sLens); // byte version of String sLens
    System.arraycopy(bsLens, 0, bytes, 4, bsLens.length);
    // -----
    bytesPos += 4 + bsLens.length; // mark position
    // -----
    for (byte[] sba : strs) {
        System.arraycopy(sba, 0, bytes, bytesPos, sba.length);
        bytesPos += sba.length;
    }
    // ----------
    return bytes;
}
 
/* ========================= */
/* "byte[] data --> primitive type" Methods */
/* ========================= */
 
public static byte toByte(byte[] data) {
    return (data == null || data.length == 0) ? 0x0 : data[0];
}
 
public static byte[] toByteA(byte[] data) {
    return data;
}
 
/* ========================= */
 
public static short toShort(byte[] data) {
    if (data == null || data.length != 2) return 0x0;
    // ----------
    return (short)(
            (0xff & data[0]) << 8   |
            (0xff & data[1]) << 0
            );
}
 
public static short[] toShortA(byte[] data) {
    if (data == null || data.length % 2 != 0) return null;
    // ----------
    short[] shts = new short[data.length / 2];
    for (int i = 0; i < shts.length; i++) {
        shts[i] = toShort( new byte[] {
            data[(i*2)],
            data[(i*2)+1]
        } );
    }
    return shts;
}
 
/* ========================= */
 
public static char toChar(byte[] data) {
    if (data == null || data.length != 2) return 0x0;
    // ----------
    return (char)(
            (0xff & data[0]) << 8   |
            (0xff & data[1]) << 0
            );
}
 
public static char[] toCharA(byte[] data) {
    if (data == null || data.length % 2 != 0) return null;
    // ----------
    char[] chrs = new char[data.length / 2];
    for (int i = 0; i < chrs.length; i++) {
        chrs[i] = toChar( new byte[] {
            data[(i*2)],
            data[(i*2)+1],
        } );
    }
    return chrs;
}
 
/* ========================= */
 
public static int toInt(byte[] data) {
    if (data == null || data.length != 4) return 0x0;
    // ----------
    return (int)( // NOTE: type cast not necessary for int
            (0xff & data[0]) << 24  |
            (0xff & data[1]) << 16  |
            (0xff & data[2]) << 8   |
            (0xff & data[3]) << 0
            );
}
 
public static int[] toIntA(byte[] data) {
    if (data == null || data.length % 4 != 0) return null;
    // ----------
    int[] ints = new int[data.length / 4];
    for (int i = 0; i < ints.length; i++)
        ints[i] = toInt( new byte[] {
            data[(i*4)],
            data[(i*4)+1],
            data[(i*4)+2],
            data[(i*4)+3],
        } );
    return ints;
}
 
/* ========================= */
 
public static long toLong(byte[] data) {
    if (data == null || data.length != 8) return 0x0;
    // ----------
    return (long)(
            // (Below) convert to longs before shift because digits
            //         are lost with ints beyond the 32-bit limit
            (long)(0xff & data[0]) << 56  |
            (long)(0xff & data[1]) << 48  |
            (long)(0xff & data[2]) << 40  |
            (long)(0xff & data[3]) << 32  |
            (long)(0xff & data[4]) << 24  |
            (long)(0xff & data[5]) << 16  |
            (long)(0xff & data[6]) << 8   |
            (long)(0xff & data[7]) << 0
            );
}
 
public static long[] toLongA(byte[] data) {
    if (data == null || data.length % 8 != 0) return null;
    // ----------
    long[] lngs = new long[data.length / 8];
    for (int i = 0; i < lngs.length; i++) {
        lngs[i] = toLong( new byte[] {
            data[(i*8)],
            data[(i*8)+1],
            data[(i*8)+2],
            data[(i*8)+3],
            data[(i*8)+4],
            data[(i*8)+5],
            data[(i*8)+6],
            data[(i*8)+7],
        } );
    }
    return lngs;
}
 
/* ========================= */
 
public static float toFloat(byte[] data) {
    if (data == null || data.length != 4) return 0x0;
    // ---------- simple:
    return Float.intBitsToFloat(toInt(data));
}
 
public static float[] toFloatA(byte[] data) {
    if (data == null || data.length % 4 != 0) return null;
    // ----------
    float[] flts = new float[data.length / 4];
    for (int i = 0; i < flts.length; i++) {
        flts[i] = toFloat( new byte[] {
            data[(i*4)],
            data[(i*4)+1],
            data[(i*4)+2],
            data[(i*4)+3],
        } );
    }
    return flts;
}
 
/* ========================= */
 
public static double toDouble(byte[] data) {
    if (data == null || data.length != 8) return 0x0;
    // ---------- simple:
    return Double.longBitsToDouble(toLong(data));
}
 
public static double[] toDoubleA(byte[] data) {
    if (data == null) return null;
    // ----------
    if (data.length % 8 != 0) return null;
    double[] dbls = new double[data.length / 8];
    for (int i = 0; i < dbls.length; i++) {
        dbls[i] = toDouble( new byte[] {
            data[(i*8)],
            data[(i*8)+1],
            data[(i*8)+2],
            data[(i*8)+3],
            data[(i*8)+4],
            data[(i*8)+5],
            data[(i*8)+6],
            data[(i*8)+7],
        } );
    }
    return dbls;
}
 
/* ========================= */
 
public static boolean toBoolean(byte[] data) {
    return (data == null || data.length == 0) ? false : data[0] != 0x00;
}
 
public static boolean[] toBooleanA(byte[] data) {
    // Advanced Technique: Extract the boolean array's length
    // from the first four bytes in the char array, and then
    // read the boolean array.
    // ----------
    if (data == null || data.length < 4) return null;
    // ----------
    int len = toInt(new byte[]{data[0], data[1], data[2], data[3]});
    boolean[] bools = new boolean[len];
    // ----- pack bools:
    for (int i = 0, j = 4, k = 7; i < bools.length; i++) {
        bools[i] = ((data[j] >> k--) & 0x01) == 1;
        if (k < 0) { j++; k = 7; }
    }
    // ----------
    return bools;
}
 
/* ========================= */
 
public static String toString(byte[] data) {
    return (data == null) ? null : new String(data);
}
 
public static String[] toStringA(byte[] data) {
    // Advanced Technique: Extract the String array's length
    // from the first four bytes in the char array, and then
    // read the int array denoting the String lengths, and
    // then read the Strings.
    // ----------
    if (data == null || data.length < 4) return null;
    // ----------
    byte[] bBuff = new byte[4]; // Buffer
    // -----
    System.arraycopy(data, 0, bBuff, 0, 4);
    int saLen = toInt(bBuff);
    if (data.length < (4 + (saLen * 4))) return null;
    // -----
    bBuff = new byte[saLen * 4];
    System.arraycopy(data, 4, bBuff, 0, bBuff.length);
    int[] sLens = toIntA(bBuff);
    if (sLens == null) return null;
    // ----------
    String[] strs = new String[saLen];
    for (int i = 0, dataPos = 4 + (saLen * 4); i < saLen; i++) {
        if (sLens[i] > 0) {
            if (data.length >= (dataPos + sLens[i])) {
                bBuff = new byte[sLens[i]];
                System.arraycopy(data, dataPos, bBuff, 0, sLens[i]);
                dataPos += sLens[i];
                strs[i] = toString(bBuff);
            } else return null;
        }
    }
    // ----------
    return strs;
}