脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → 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数组的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • Spring Boot Cache使用方法整合代码实例

    Spring Boot Cache使用方法整合代码实例

    这篇文章主要介绍了Spring Boot Cache使用方法整合代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-02-02
  • Java虚拟机的核心原理与工作机制解读

    Java虚拟机的核心原理与工作机制解读

    这篇文章主要介绍了Java虚拟机的核心原理与工作机制,将深入探讨JVM的核心概念、架构、内存模型、垃圾回收机制等内容,帮助你全面掌握JVM的知识
    2025-05-05
  • java基于mongodb实现分布式锁的示例代码

    java基于mongodb实现分布式锁的示例代码

    本文主要介绍了java基于mongodb实现分布式锁，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-08-08
  • Java带default方法接口的应用示例

    Java带default方法接口的应用示例

    这篇文章主要介绍了Java带default方法接口的应用,结合实例形式分析了java带default方法接口定义、用法及相关操作注意事项,需要的朋友可以参考下
    2019-08-08
  • Java 九宫重排(满分解法)

    Java 九宫重排(满分解法)

    本文主要介绍了Java 九宫重排(满分解法),文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-05-05
  • springboot整合TDengine全过程

    springboot整合TDengine全过程

    这篇文章主要介绍了springboot整合TDengine全过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2025-06-06
  • RabbitMQ中的channel信道、exchange交换机和queue队列详解

    RabbitMQ中的channel信道、exchange交换机和queue队列详解

    这篇文章主要介绍了RabbitMQ中的channel信道、exchange交换机和queue队列详解,connection是指物理的连接,一个client与一个server之间有一个连接,一个连接上可以建立多个channel,可以理解为逻辑上的连接,需要的朋友可以参考下
    2023-08-08
  • JDK8(Java Development kit)的安装与配置全过程

    JDK8(Java Development kit)的安装与配置全过程

    文章简要介绍了Java的核心特点（如跨平台、JVM机制）及JDK/JRE的区别,重点讲解了如何通过配置环境变量（PATH和JAVA_HOME）实现Java程序的正确运行,并提供了安装步骤和常见问题解决方法
    2025-09-09
  • java复制文件的4种方式及拷贝文件到另一个目录下的实例代码

    java复制文件的4种方式及拷贝文件到另一个目录下的实例代码

    这篇文章主要介绍了java复制文件的4种方式,通过实例带给大家介绍了java 拷贝文件到另一个目录下的方法，需要的朋友可以参考下
    2018-06-06
  • Java 程序初始化顺序

    Java 程序初始化顺序

    这篇文章主要介绍了Java 程序初始化顺序，在Java语言中，当实例化对象时，对象所在类的所有成员变量首先要进行初始化，只有当所有的类成员完成了初始化之后，才会调用对象所在类的构造函数创建对象,需要的朋友可以参考一下
    2022-01-01

最新评论