java数据类型byte,Java byte[]与基本数据类型之间的转换

本文提供了一套Java工具类,用于字节数组与short、int、float等基本数据类型之间的大小端方式转换。介绍了如何通过位运算实现不同数据类型的互相转换,并附带示例代码。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

在网络编程当中,常常会涉及到字节数组(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数组转换的一些总结。

如有纰漏,有误,欢迎各位指正,在下感激万分。

f9be91f33554

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值