Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
public class ByteUtil {
/* ========================= */
/* "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 defaultLimit
(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;
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.