脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java数据类型转byte数组

Java实现基本数据类型与byte数组相互转换

 更新时间：2025年12月22日 09:28:14   作者：牛肉胡辣汤  
在编程中,尤其是在网络通信、文件读写等场景下,经常需要将基本数据类型（如int、long、double等）转换为字节数组（byte array）,本文将详细介绍Java中如何实现这些转换,感兴趣的可以了解下

在编程中，尤其是在网络通信、文件读写等场景下，经常需要将基本数据类型（如int、long、double等）转换为字节数组（byte array），或者从字节数组中恢复基本数据类型。本文将详细介绍Java中如何实现这些转换。

1. 基本数据类型转byte数组

1.1 int转byte数组

将一个​​int​​类型的值转换为​​byte​​数组，可以使用位运算来实现：

public static byte[] intToBytes(int value) {
    return new byte[]{
        (byte) (value >>> 24),
        (byte) (value >>> 16),
        (byte) (value >>> 8),
        (byte) value
    };
}

1.2 long转byte数组

将一个​​long​​类型的值转换为​​byte​​数组，同样可以使用位运算：

public static byte[] longToBytes(long value) {
    return new byte[]{
        (byte) (value >>> 56),
        (byte) (value >>> 48),
        (byte) (value >>> 40),
        (byte) (value >>> 32),
        (byte) (value >>> 24),
        (byte) (value >>> 16),
        (byte) (value >>> 8),
        (byte) value
    };
}

1.3 double转byte数组

将一个​​double​​类型的值转换为​​byte​​数组，可以先将其转换为​​long​​，然后再使用上述方法：

public static byte[] doubleToBytes(double value) {
    long longValue = Double.doubleToLongBits(value);
    return longToBytes(longValue);
}

2. byte数组转基本数据类型

2.1 byte数组转int

将一个​​byte​​数组转换为​​int​​类型的值，可以使用位运算和移位操作：

public static int bytesToInt(byte[] bytes) {
    return (bytes[0] << 24) |
           (bytes[1] << 16) |
           (bytes[2] << 8)  |
           (bytes[3]);
}

2.2 byte数组转long

将一个​​byte​​数组转换为​​long​​类型的值，同样可以使用位运算和移位操作：

public static long bytesToLong(byte[] bytes) {
    return ((long) bytes[0] << 56) |
           ((long) bytes[1] << 48) |
           ((long) bytes[2] << 40) |
           ((long) bytes[3] << 32) |
           ((long) bytes[4] << 24) |
           ((long) bytes[5] << 16) |
           ((long) bytes[6] << 8)  |
           ((long) bytes[7]);
}

2.3 byte数组转double

将一个​​byte​​数组转换为​​double​​类型的值，可以先将其转换为​​long​​，然后再使用​​Double.longBitsToDouble​​方法：

public static double bytesToDouble(byte[] bytes) {
    long longValue = bytesToLong(bytes);
    return Double.longBitsToDouble(longValue);
}

3. 示例代码

以下是一个完整的示例代码，展示了如何使用上述方法进行基本数据类型和​​byte​​数组之间的转换：

public class DataTypeConversion {

    public static void main(String[] args) {
        // int to byte array
        int intValue = 123456;
        byte[] intBytes = intToBytes(intValue);
        System.out.println("int to byte array: " + bytesToHex(intBytes));

        // byte array to int
        int intValueFromBytes = bytesToInt(intBytes);
        System.out.println("byte array to int: " + intValueFromBytes);

        // long to byte array
        long longValue = 1234567890123456789L;
        byte[] longBytes = longToBytes(longValue);
        System.out.println("long to byte array: " + bytesToHex(longBytes));

        // byte array to long
        long longValueFromBytes = bytesToLong(longBytes);
        System.out.println("byte array to long: " + longValueFromBytes);

        // double to byte array
        double doubleValue = 123.456;
        byte[] doubleBytes = doubleToBytes(doubleValue);
        System.out.println("double to byte array: " + bytesToHex(doubleBytes));

        // byte array to double
        double doubleValueFromBytes = bytesToDouble(doubleBytes);
        System.out.println("byte array to double: " + doubleValueFromBytes);
    }

    public static byte[] intToBytes(int value) {
        return new byte[]{
            (byte) (value >>> 24),
            (byte) (value >>> 16),
            (byte) (value >>> 8),
            (byte) value
        };
    }

    public static byte[] longToBytes(long value) {
        return new byte[]{
            (byte) (value >>> 56),
            (byte) (value >>> 48),
            (byte) (value >>> 40),
            (byte) (value >>> 32),
            (byte) (value >>> 24),
            (byte) (value >>> 16),
            (byte) (value >>> 8),
            (byte) value
        };
    }

    public static byte[] doubleToBytes(double value) {
        long longValue = Double.doubleToLongBits(value);
        return longToBytes(longValue);
    }

    public static int bytesToInt(byte[] bytes) {
        return (bytes[0] << 24) |
               (bytes[1] << 16) |
               (bytes[2] << 8)  |
               (bytes[3]);
    }

    public static long bytesToLong(byte[] bytes) {
        return ((long) bytes[0] << 56) |
               ((long) bytes[1] << 48) |
               ((long) bytes[2] << 40) |
               ((long) bytes[3] << 32) |
               ((long) bytes[4] << 24) |
               ((long) bytes[5] << 16) |
               ((long) bytes[6] << 8)  |
               ((long) bytes[7]);
    }

    public static double bytesToDouble(byte[] bytes) {
        long longValue = bytesToLong(bytes);
        return Double.longBitsToDouble(longValue);
    }

    public static String bytesToHex(byte[] bytes) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : bytes) {
            String hex = Integer.toHexString(0xFF & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

以上是关于基本数据类型与​​byte​​数组相互转化的技术博客文章。希望对你有所帮助！

4.方法补充

在Java中，基本数据类型（如int、float、double等）和byte数组之间的转换是常见的需求，尤其是在网络通信、文件读写等场景中。下面我将分别给出几个示例，展示如何将基本数据类型转换为byte数组，以及如何从byte数组恢复基本数据类型。

1. int 和 byte[] 的转换

int 转换为 byte[]

public class IntToByteArray {
    public static void main(String[] args) {
        int number = 123456789;
        byte[] bytes = new byte[4];
        
        // 将int转换为byte数组
        for (int i = 0; i < 4; i++) {
            bytes[i] = (byte) ((number >> (i * 8)) & 0xFF);
        }
        
        System.out.println("Byte array: " + Arrays.toString(bytes));
    }
}

byte[] 转换为 int

public class ByteArrayToInt {
    public static void main(String[] args) {
        byte[] bytes = { -86, 46, -42, 77 }; // 这个数组是从上面的例子得到的
        int number = 0;
        
        // 将byte数组转换为int
        for (int i = 0; i < 4; i++) {
            number |= (bytes[i] & 0xFF) << (i * 8);
        }
        
        System.out.println("Number: " + number);
    }
}

2. float 和 byte[] 的转换

float 转换为 byte[]

public class FloatToByteArray {
    public static void main(String[] args) {
        float number = 3.14f;
        byte[] bytes = new byte[4];
        
        // 将float转换为byte数组
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.putFloat(number);
        buffer.flip(); // 翻转缓冲区
        buffer.get(bytes);
        
        System.out.println("Byte array: " + Arrays.toString(bytes));
    }
}

byte[] 转换为 float

public class ByteArrayToFloat {
    public static void main(String[] args) {
        byte[] bytes = { 64, 9, 21, 115 }; // 这个数组是从上面的例子得到的
        float number = 0.0f;
        
        // 将byte数组转换为float
        ByteBuffer buffer = ByteBuffer.wrap(bytes);
        number = buffer.getFloat();
        
        System.out.println("Number: " + number);
    }
}

3. double 和 byte[] 的转换

double 转换为 byte[]

public class DoubleToByteArray {
    public static void main(String[] args) {
        double number = 3.141592653589793;
        byte[] bytes = new byte[8];
        
        // 将double转换为byte数组
        ByteBuffer buffer = ByteBuffer.allocate(8);
        buffer.putDouble(number);
        buffer.flip(); // 翻转缓冲区
        buffer.get(bytes);
        
        System.out.println("Byte array: " + Arrays.toString(bytes));
    }
}

byte[] 转换为 double

public class ByteArrayToDouble {
    public static void main(String[] args) {
        byte[] bytes = { 64, 9, 21, 115, -31, -11, -10, -21 }; // 这个数组是从上面的例子得到的
        double number = 0.0;
        
        // 将byte数组转换为double
        ByteBuffer buffer = ByteBuffer.wrap(bytes);
        number = buffer.getDouble();
        
        System.out.println("Number: " + number);
    }
}

在Java中，基本数据类型（如​​int​​​, ​​double​​​, ​​char​​​, ​​boolean​​​等）和​​byte[]​​之间的转换是一个常见的需求，尤其是在处理网络通信、文件读写或加密解密时。下面将详细介绍如何在Java中实现这些转换。

1. 基本数据类型转 ​​byte[]​​

1.1 ​​int​​ 转 ​​byte[]​​

public static byte[] intToByteArray(int value) {
    return new byte[] {
        (byte)((value >> 24) & 0xFF),
        (byte)((value >> 16) & 0xFF),
        (byte)((value >> 8) & 0xFF),
        (byte)(value & 0xFF)
    };
}

1.2 ​​long​​ 转 ​​byte[]​​

public static byte[] longToByteArray(long value) {
    return new byte[] {
        (byte)((value >> 56) & 0xFF),
        (byte)((value >> 48) & 0xFF),
        (byte)((value >> 40) & 0xFF),
        (byte)((value >> 32) & 0xFF),
        (byte)((value >> 24) & 0xFF),
        (byte)((value >> 16) & 0xFF),
        (byte)((value >> 8) & 0xFF),
        (byte)(value & 0xFF)
    };
}

1.3 ​​float​​ 转 ​​byte[]​​

public static byte[] floatToByteArray(float value) {
    return intToByteArray(Float.floatToIntBits(value));
}

1.4 ​​double​​ 转 ​​byte[]​​

public static byte[] doubleToByteArray(double value) {
    return longToByteArray(Double.doubleToLongBits(value));
}

1.5 ​​char​​ 转 ​​byte[]​​

public static byte[] charToByteArray(char value) {
    return new byte[] {
        (byte)((value >> 8) & 0xFF),
        (byte)(value & 0xFF)
    };
}

1.6 ​​boolean​​ 转 ​​byte[]​​

public static byte[] booleanToByteArray(boolean value) {
    return new byte[] { (byte)(value ? 1 : 0) };
}

2. ​​byte[]​​ 转基本数据类型

2.1 ​​byte[]​​ 转 ​​int​​

public static int byteArrayToInt(byte[] bytes) {
    return (bytes[0] & 0xFF) << 24 |
           (bytes[1] & 0xFF) << 16 |
           (bytes[2] & 0xFF) << 8  |
           (bytes[3] & 0xFF);
}

2.2 ​​byte[]​​ 转 ​​long​​

public static long byteArrayToLong(byte[] bytes) {
    return (bytes[0] & 0xFFL) << 56 |
           (bytes[1] & 0xFFL) << 48 |
           (bytes[2] & 0xFFL) << 40 |
           (bytes[3] & 0xFFL) << 32 |
           (bytes[4] & 0xFFL) << 24 |
           (bytes[5] & 0xFFL) << 16 |
           (bytes[6] & 0xFFL) << 8  |
           (bytes[7] & 0xFFL);
}

2.3 ​​byte[]​​ 转 ​​float​​

public static float byteArrayToFloat(byte[] bytes) {
    return Float.intBitsToFloat(byteArrayToInt(bytes));
}

2.4 ​​byte[]​​ 转 ​​double​​

public static double byteArrayToDouble(byte[] bytes) {
    return Double.longBitsToDouble(byteArrayToLong(bytes));
}

2.5 ​​byte[]​​ 转 ​​char​​

public static char byteArrayToChar(byte[] bytes) {
    return (char)(((bytes[0] & 0xFF) << 8) | (bytes[1] & 0xFF));
}

2.6 ​​byte[]​​ 转 ​​boolean​​

public static boolean byteArrayToBoolean(byte[] bytes) {
    return bytes[0] != 0;
}

3. 使用 ​​ByteBuffer​​ 进行转换

Java的​​ByteBuffer​​类提供了更方便的方法来进行基本数据类型和​​byte[]​​之间的转换。以下是一些示例：

3.1 ​​int​​ 转 ​​byte[]​​

import java.nio.ByteBuffer;

public static byte[] intToByteArray(int value) {
    return ByteBuffer.allocate(4).putInt(value).array();
}

3.2 ​​byte[]​​ 转 ​​int​​

public static int byteArrayToInt(byte[] bytes) {
    return ByteBuffer.wrap(bytes).getInt();
}

3.3 ​​double​​ 转 ​​byte[]​​

public static byte[] doubleToByteArray(double value) {
    return ByteBuffer.allocate(8).putDouble(value).array();
}

3.4 ​​byte[]​​ 转 ​​double​​

public static double byteArrayToDouble(byte[] bytes) {
    return ByteBuffer.wrap(bytes).getDouble();
}

4. 注意事项

字节序：上述示例默认使用大端字节序（Big-Endian）。如果需要小端字节序（Little-Endian），可以在​​ByteBuffer​​中调用​​order(ByteOrder.LITTLE_ENDIAN)​​方法。

异常处理：在实际应用中，建议添加异常处理，以应对可能的输入错误或异常情况。

通过这些方法，你可以在Java中轻松地进行基本数据类型和​​byte[]​​之间的转换。希望这些示例对你有所帮助！

以上就是Java实现基本数据类型与byte数组相互转换的详细内容，更多关于Java数据类型转byte数组的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • idea如何开启菜单栏

    idea如何开启菜单栏

    文章介绍了如何通过修改IntelliJ IDEA的样式文件`ui.lnf.xml`来重新显示被关闭的菜单栏,并分享了解决问题的步骤
    2025-01-01
  • Java将RTF文档转换为Word/PDF/HTML/图片

    Java将RTF文档转换为Word/PDF/HTML/图片

    RTF文档因其跨平台兼容性而广泛使用,但有时在不同的应用场景可能需要特定的文档格式,所以本文来讲讲如何通过Java将RTF转换为Word/PDF/HTML和图片格式
    2025-01-01
  • java实现飞机大战案例详解

    java实现飞机大战案例详解

    这篇文章主要为大家详细介绍了java实现飞机大战案例，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-03-03
  • Springboot实现对配置文件中的明文密码加密详解

    Springboot实现对配置文件中的明文密码加密详解

    我们在SpringBoot项目当中，会把数据库的用户名密码等配置直接放在yaml或者properties文件中，这样维护数据库的密码等敏感信息显然是有一定风险的。所以本文为大家整理了对配置文件中的明文密码加密的方法，希望对大家有所帮助
    2023-03-03
  • Spring的事件监听机制示例详解

    Spring的事件监听机制示例详解

    这篇文章主要给大家介绍了关于Spring的事件监听机制的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2018-11-11
  • Mybatis-Plus如何配置分页对象

    Mybatis-Plus如何配置分页对象

    本文主要介绍了Mybatis-Plus如何配置分页对象，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2022-08-08
  • Spring Boot 编写Servlet、Filter、Listener、Interceptor的方法

    Spring Boot 编写Servlet、Filter、Listener、Interceptor的方法

    这篇文章给大家介绍了spring-boot中如何定义过滤器、监听器和拦截器，对Spring Boot 编写Servlet、Filter、Listener、Interceptor的相关知识感兴趣的朋友一起看看吧
    2017-07-07
  • Java BeanUtils工具类常用方法讲解

    Java BeanUtils工具类常用方法讲解

    这篇文章主要介绍了Java BeanUtils工具类常用方法讲解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
    2021-08-08
  • Sentinel热门词汇限流的实现详解

    Sentinel热门词汇限流的实现详解

    这篇文章主要介绍了使用Sentinel对热门词汇进行限流的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2022-07-07
  • poi导出word表格的操作讲解

    poi导出word表格的操作讲解

    这篇文章主要介绍了poi导出word表格的操作讲解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-10-10

最新评论