在网络编程当中，常常会涉及到字节数组（buffer）的解析，与其他数据类型相互转换。
例如Socket，BLE等等。以下是字节数组与各种数据类型之间的大小端方式相互转换的Java实现工具类汇总。
大端：高地址存储低字节；
小端：低地址存储低字节。
例如：整形 0x12345678 (注意：0x12是高字节 ~ 0x78是低字节)
内存地址（字节数组下标 0 ~ 7）
大端：12 34 56 78
小端：78 56 34 12
如果转换设计无符号数据类型参考我的另一篇：Java无符号数据类型处理
Note：计算机系统默认小端方式存储，在日常开发当中，通常都是使用小端方式。
大端与小端的详细介绍就不在此详细阐述了。
代码如下，主要是比特位运算和Java的基本API实现，详细的设计编程语言基本数据类型与计算机数据存储原理，相信这些知识在教科书上也是有详述，附上简单的说明：
1、byte[] 与 short互相转换
2、byte[] 与 int互相转换
3、byte[] 与 float互相转换
4、byte[] 与 long互相转换
5、byte[] 与 double互相转换
6、byte[] 与 16进制字符串互相转换
/**
*
* author : wushaohong
* date : 2020-05-01
* desc : 字节数组与基本数据类型的转换
* byte、short、int、float、long、double、16进制字符串
* version: 1.0
*
*/
public class ByteArrayUtil {
/**
* 字节数组转 short，小端
*/
public static short byteArray2Short_Little_Endian(byte[] array) {
// 数组长度有误
if (array.length > 2) {
return 0;
}
short value = 0;
for (int i = 0; i < array.length; i++) {
// & 0xff，除去符号位干扰
value |= ((array[i] & 0xff) << (i * 8));
}
return value;
}
/**
* 字节数组转 short，大端
*/
public static short byteArray2Short_Big_Endian(byte[] array) {
// 数组长度有误
if (array.length > 2) {
return 0;
}
short value = 0;
for (int i = 0; i < array.length ; i++) {
value |= ((array[i] & 0xff) << ((array.length - i - 1) * 8));
}
return value;
}
/**
* 字节数组转 int，小端
*/
public static int byteArray2Int_Little_Endian(byte[] array) {
// 数组长度有误
if (array.length > 4) {
return 0;
}
int value = 0;
for (int i = 0; i < array.length; i++) {
value |= ((array[i] & 0xff) << (i * 8));
}
return value;
}
/**
* 字节数组转 int，大端
*/
public static int byteArray2Int_Big_Endian(byte[] array) {
// 数组长度有误
if (array.length > 4) {
return 0;
}
int value = 0;
for (int i = 0; i < array.length ; i++) {
value |= ((array[i] & 0xff) << ((array.length - i - 1) * 8));
}
return value;
}
/**
* 字节数组转 float，小端
*/
public static float byteArray2Float_Little_Endian(byte[] array) {
// 数组长度有误
if (array.length != 4) {
return 0;
}
return Float.intBitsToFloat(byteArray2Int_Little_Endian(array));
}
/**
* 字节数组转 float，大端
*/
public static float byteArray2Float_Big_Endian(byte[] array) {
// 数组长度有误
if (array.length > 4) {
return 0;
}
return Float.intBitsToFloat(byteArray2Int_Big_Endian(array));
}
/**
* 字节数组转 long，小端
*/
public static long byteArray2Long_Little_Endian(byte[] array) {
// 数组长度有误
if (array.length != 8) {
return 0;
}
long value = 0;
for (int i = 0; i < array.length ; i++) {
// 需要转long再位移，否则int丢失精度
value |= ((long)(array[i]& 0xff) << (i * 8));
}
return value;
}
/**
* 字节数组转 long，大端
*/
public static long byteArray2Long_Big_Endian(byte[] array) {
// 数组长度有误
if (array.length != 8) {
return 0;
}
long value = 0;
for (int i = 0; i < array.length ; i++) {
value |= ((long)(array[i] & 0xff) << ((array.length - i - 1) * 8));
}
return value;
}
/**
* 字节数组转 double，小端
*/
public static double byteArray2Double_Little_Endian(byte[] array) {
// 数组长度有误
if (array.length != 8) {
return 0;
}
return Double.longBitsToDouble(byteArray2Long_Little_Endian(array));
}
/**
* 字节数组转 double，大端
*/
public static double byteArray2Double_Big_Endian(byte[] array) {
// 数组长度有误
if (array.length != 8) {
return 0;
}
return Double.longBitsToDouble(byteArray2Long_Big_Endian(array));
}
/**
* 字节数组转 HexString
*/
public static String byteArray2HexString(byte[] array) {
StringBuilder builder = new StringBuilder();
for (byte b : array) {
String s = Integer.toHexString(b & 0xff);
if (s.length() < 2) {
builder.append("0");
}
builder.append(s);
}
return builder.toString().toUpperCase();
}
//---------------------------------华丽的分割线-------------------------------------
/**
* short 转字节数组，小端
*/
public static byte[] short2ByteArray_Little_Endian(short s) {
byte[] array = new byte[2];
for (int i = 0; i < array.length; i++) {
array[i] = (byte) (s >> (i * 8));
}
return array;
}
/**
* short 转字节数组，大端
*/
public static byte[] short2ByteArray_Big_Endian(short s) {
byte[] array = new byte[2];
for (int i = 0; i < array.length; i++) {
array[array.length - 1 - i] = (byte) (s >> (i * 8));
}
return array;
}
/**
* int 转字节数组，小端
*/
public static byte[] int2ByteArray_Little_Endian(int s) {
byte[] array = new byte[4];
for (int i = 0; i < array.length; i++) {
array[i] = (byte) (s >> (i * 8));
}
return array;
}
/**
* int 转字节数组，大端
*/
public static byte[] int2ByteArray_Big_Endian(int s) {
byte[] array = new byte[4];
for (int i = 0; i < array.length; i++) {
array[array.length - 1 - i] = (byte) (s >> (i * 8));
}
return array;
}
/**
* float 转字节数组，小端
*/
public static byte[] float2ByteArray_Little_Endian(float f) {
return int2ByteArray_Little_Endian(Float.floatToIntBits(f));
}
/**
* float 转字节数组，大端
*/
public static byte[] float2ByteArray_Big_Endian(float f) {
return int2ByteArray_Big_Endian(Float.floatToIntBits(f));
}
/**
* long 转字节数组，小端
*/
public static byte[] long2ByteArray_Little_Endian(long l) {
byte[] array = new byte[8];
for (int i = 0; i < array.length; i++) {
array[i] = (byte) (l >> (i * 8));
}
return array;
}
/**
* long 转字节数组，大端
*/
public static byte[] long2ByteArray_Big_Endian(long l) {
byte[] array = new byte[8];
for (int i = 0; i < array.length; i++) {
array[array.length - 1 - i] = (byte) (l >> (i * 8));
}
return array;
}
/**
* double 转字节数组，小端
*/
public static byte[] double2ByteArray_Little_Endian(double d) {
return long2ByteArray_Little_Endian(Double.doubleToLongBits(d));
}
/**
* double 转字节数组，大端
*/
public static byte[] double2ByteArray_Big_Endian(double d) {
return long2ByteArray_Big_Endian(Double.doubleToLongBits(d));
}
/**
* HexString 转字节数组
*/
public static byte[] hexString2ByteArray(String hexString) {
// 两个十六进制字符一个 byte，单数则有误
if (hexString.length() % 2 != 0) {
return null;
}
byte[] array = new byte[hexString.length() / 2];
int value = 0;
for (int i = 0; i < hexString.length(); i++) {
char s = hexString.charAt(i);
// 前半个字节
if (i % 2 == 0) {
value = Integer.parseInt(String.valueOf(s), 16) * 16;
} else {
// 后半个字节
value += Integer.parseInt(String.valueOf(s), 16);
array[i / 2] = (byte) value;
value = 0;
}
}
return array;
}
}
上面的工具类，对号入座即可。除了字节比特位运算转换之外，还能够使用Java 的一个类进行基本数据类型的互转：
ByteBuffer
例子1：int转字节数组
ByteBuffer byteBuffer = ByteBuffer.allocate(4);
// 小端，如果不指定小端，ByteBuffer默认是大端 ByteOrder.BIG_ENDIAN
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
byteBuffer.putInt(2020);
// 转成字节数组
byteBuffer.array();
例子2：字节数组转 int
byte[] array = new byte[]{-28, 7, 0, 0};
ByteBuffer byteBuffer = ByteBuffer.allocate(4);
// 小端
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
byteBuffer.put(array);
// 在bytebuffer中读取一个 int
System.out.println(byteBuffer.getInt(0));
以上是对byte数组转换的一些总结。