package crrc.stringstudytest2;

import java.nio.ByteBuffer;
import java.util.Arrays;

/**
 * 字节数组和基本数据类型转换：
 * 此功能在处理网络传输、文件IO等场景中非常有用，因为它能够将数据转换为可传输或可存储的字节格式
 */
public class ByteUtil {
    /**
     * 将int转换为字节数组
     *
     * @param value 输入的整型值
     * @return 转换后的字节数组
     */
    public static byte[] intToBytes(int value) {
        //ByteBuffer.allocate(4):
        //这一部分用于创建一个新的字节缓冲区（ByteBuffer），容量为4字节。
        //整型（int）在Java中占用4个字节，因此这里的参数为4。

        //putInt(value)：
        //这一部分调用了之前创建的ByteBuffer对象（即4字节的缓冲区）的putInt方法。
        //putInt方法的参数是一个整数值（value），它会将这个整型值写入到字节缓冲区中，按大端序（big-endian）存储，这意味着高位字节在前，低位字节在后。

        //array():
        //最后，这部分调用了ByteBuffer的array()方法。
        //array()方法返回ByteBuffer内部使用的字节数组。此时，字节数组中就包含了刚刚写入的整型值的字节表示。
        return ByteBuffer.allocate(4).putInt(value).array();
    }

    /**
     * 将字节数组转换为int
     *
     * @param bytes 输入的字节数组
     * @return 转换后的整型
     */
    public static int bytesToInt(byte[] bytes) {
        //ByteBuffer.wrap(bytes):
        //ByteBuffer 是 Java 中用于操作字节数据的类。
        //wrap(bytes) 方法接受一个字节数组（bytes），并返回一个新的 ByteBuffer 实例，
        //该实例将这个字节数组包装起来。
        //这个方法不会复制字节数组，而是直接使用它。
        //因此，后续对 ByteBuffer 的修改会影响到原始的字节数组。

        //getInt():
        //getInt() 是 ByteBuffer 类中的一个方法，它会从当前的 ByteBuffer 位
        //置读取 4 个字节，并将其转换为一个整型（int）。
        //在 Java 中，整型（int）占用 4 个字节，getInt() 方法会
        //以大端序的方式（即高位字节在前）读取这 4 个字节，并返回对应的整型值。
        return ByteBuffer.wrap(bytes).getInt();
    }

    /**
     * 将long转换为字节数组
     *
     * @param value 输入的长整型值
     * @return 转换后的字节数组
     */
    public static byte[] longToBytes(long value) {
        return ByteBuffer.allocate(8).putLong(value).array();
    }

    /**
     * 将字节数组转换为long
     *
     * @param bytes 输入的字节数组
     * @return 转换后的长整型
     */
    public static long bytesToLong(byte[] bytes) {
        return ByteBuffer.wrap(bytes).getLong();
    }

    /**
     * 将float转换为字节数组
     *
     * @param value 输入的浮点型值
     * @return 转换后的字节数组
     */
    public static byte[] floatToBytes(float value) {
        return ByteBuffer.allocate(4).putFloat(value).array();
    }

    /**
     * 将字节数组转换为float
     *
     * @param bytes 输入的字节数组
     * @return 转换后的浮点型
     */
    public static float bytesToFloat(byte[] bytes) {
        return ByteBuffer.wrap(bytes).getFloat();
    }

    /**
     * 将double转换为字节数组
     *
     * @param value 输入的双精度型值
     * @return 转换后的字节数组
     */
    public static byte[] doubleToBytes(double value) {
        return ByteBuffer.allocate(8).putDouble(value).array();
    }

    /**
     * 将字节数组转换为double
     *
     * @param bytes 输入的字节数组
     * @return 转换后的双精度型
     */
    public static double bytesToDouble(byte[] bytes) {
        return ByteBuffer.wrap(bytes).getDouble();
    }

    public static void main(String[] args) {
        int intValue = 123456;
        byte[] intBytes = intToBytes(intValue);
        System.out.println("Int to Bytes: " + Arrays.toString(intBytes));//Arrays.toString(intBytes)将数组直观展示出来以字符串的形式
        System.out.println("Bytes to Int: " + bytesToInt(intBytes));

        long longValue = 123456789L;
        byte[] longBytes = longToBytes(longValue);
        System.out.println("Long to Bytes: " + Arrays.toString(longBytes));
        System.out.println("Bytes to Long: " + bytesToLong(longBytes));

        float floatValue = 45.67f;
        byte[] floatBytes = floatToBytes(floatValue);
        System.out.println("Float to Bytes: " + Arrays.toString(floatBytes));
        System.out.println("Bytes to Float: " + bytesToFloat(floatBytes));

        double doubleValue = 123.456;
        byte[] doubleBytes = doubleToBytes(doubleValue);
        System.out.println("Double to Bytes: " + Arrays.toString(doubleBytes));
        System.out.println("Bytes to Double: " + bytesToDouble(doubleBytes));
    }
}