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

于 2021-03-15 21:17:15 发布
阅读量1.6k 收藏 2
点赞数 1
文章标签： 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、付费专栏及课程。

              

            

          

      

      余额充值