ByteHelper.java

package com.yanzuoguang.util.helper;


import com.yanzuoguang.util.YzgError;

/**
 * 通信格式转换
 * <p>
 * Java和一些windows编程语言如c、c++、delphi所写的网络程序进行通讯时，需要进行相应的转换 高、低字节之间的转换
 * windows的字节序为低字节开头 linux,unix的字节序为高字节开头 java则无论平台变化，都是高字节开头
 * @author 颜佐光
 */
public class ByteHelper {

    /**
     * 每个字节所占用的字符串的长度
     */
    public static final int BYTE_STRING_SIZE = 2;
    /**
     * 16进制转换标识
     */
    public static final int BYTE_HEX_UNIT = 16;
    /**
     * 10进制转换单位
     */
    public static final int BYTE_TEN_UNIT = 10;
    /**
     * BCD标识
     */
    public static final int BCD_MAX_FLAG = 100;

    private ByteHelper(){}

    // --------------------------------------- toLH -------------------------------------

    /**
     * 将 long 值转成低字节在前，高字节在后的byte数组
     *
     * @param n   需要转换的值
     * @param max 字节最大长度
     * @return 转换后的数据
     */
    public static byte[] toLH(long n, int max) {
        byte[] b = new byte[max];
        for (int i = 0; i < max; i++) {
            int offset = i * 8;
            b[i] = (byte) (n >> offset & 0xff);
        }
        return b;
    }

    /**
     * 将 long 值转成低字节在前，高字节在后的byte数组
     *
     * @param n 需要转换的值
     * @return 转换后的数据
     */
    public static byte[] toLH(long n) {
        return toLH(n, 8);
    }

    /**
     * 将int转为低字节在前，高字节在后的byte数组
     *
     * @param n 需要转换的数据
     * @return 转换后的数据
     */
    public static byte[] toLH(int n) {
        return toLH(n, 4);
    }

    /**
     * 将short转为低字节在前，高字节在后的byte数组
     *
     * @param n 需要转换的数据
     * @return 转换后的数据
     */
    public static byte[] toLH(short n) {
        return toLH(n, 2);
    }

    /**
     * 将float转为低字节在前，高字节在后的byte数组
     *
     * @param f 需要转换的数据
     * @return 转换后的数据
     */
    public static byte[] toLH(float f) {
        return toLH(Float.floatToRawIntBits(f));
    }

    // --------------------------------------- toHL -------------------------------------

    /**
     * 将 long 值转成高字节在前，低字节在后的byte数组
     *
     * @param n   需要转换的值
     * @param max 字节最大长度
     * @return 转换后的数据
     */
    public static byte[] toHL(long n, int max) {
        byte[] b = new byte[max];
        for (int i = 0; i < max; i++) {
            int offset = (max - 1 - i) * 8;
            b[i] = (byte) (n >> offset & 0xff);
        }
        return b;
    }

    /**
     * 将 long 值转成高字节在前，低字节在后的byte数组
     *
     * @param n 需要转换的值
     * @return 转换后的数据
     */
    public static byte[] toHL(long n) {
        return toHL(n, 8);
    }

    /**
     * 将int转为高字节在前，低字节在后的byte数组
     *
     * @param n 需要转换的值
     * @return 转换后的数据
     */
    public static byte[] toHL(int n) {
        return toHL(n, 4);
    }

    /**
     * 将short转为高字节在前，低字节在后的byte数组
     *
     * @param n 需要转换的值
     * @return 转换后的数据
     */
    public static byte[] toHL(short n) {
        return toHL(n, 2);
    }

    /**
     * 将float转为高字节在前，低字节在后的byte数组
     *
     * @param f 需要转换的值
     * @return 转换后的数据
     */
    public static byte[] toHL(float f) {
        return toHL(Float.floatToRawIntBits(f));
    }

    // --------------------------------------- byLH -------------------------------------

    /**
     * 将低字节转换为长整形
     *
     * @param bytes 字节
     * @param off   开始位置
     * @param max   最大位置
     * @return 转换后的结果
     */
    public static long toLongByLH(byte[] bytes, int off, int max) {
        long ret = 0;
        for (int i = 0; i < max; i++) {
            int b = bytes[off + i] & 0xFF;
            int offset = i * 8;
            ret |= (b << offset);
        }
        return ret;
    }

    /**
     * 将低字节数组转换为long
     *
     * @param b 需要转换的值
     * @return 转换后的数据
     */
    public static long toLongByLH(byte[] b) {
        return toLongByLH(b, 0);
    }

    /**
     * 将低字节数组转换为long
     *
     * @param b   需要转换的值
     * @param off 偏移位置
     * @return 转换后的数据
     */
    public static long toLongByLH(byte[] b, int off) {
        return toLongByLH(b, off, 8);
    }

    /**
     * 将低字节数组转换为int
     *
     * @param b 需要转换的值
     * @return 转换后的数据
     */
    public static int toIntByLH(byte[] b) {
        return toIntByLH(b, 0);
    }

    /**
     * 将低字节数组转换为int
     *
     * @param b   需要转换的值
     * @param off 偏移位置
     * @return 转换后的数据
     */
    public static int toIntByLH(byte[] b, int off) {
        return (int) toLongByLH(b, off, 4);
    }

    /**
     * 低字节数组到short的转换
     *
     * @param b 需要转换的值
     * @return 转换后的数据
     */
    public static short toShortByLH(byte[] b) {
        return toShortByLH(b, 0);
    }

    /**
     * 低字节数组到short的转换
     *
     * @param b   需要转换的值
     * @param off 偏移位置
     * @return 转换后的数据
     */
    public static short toShortByLH(byte[] b, int off) {
        return (short) toLongByLH(b, off, 2);
    }

    /**
     * 低字节数组转换为float
     *
     * @param b 需要转换的值
     * @return 转换后的数据
     */
    public static float toFloatByLH(byte[] b) {
        return Float.intBitsToFloat(toIntByLH(b));
    }


    // --------------------------------------- byHL -------------------------------------

    /**
     * 将高字节转换为长整型
     *
     * @param bytes 字节
     * @param off   开始位置
     * @param max   最大位置
     * @return 转换后的数据
     */
    public static long toLongByHL(byte[] bytes, int off, int max) {
        long ret = 0;
        for (int i = 0; i < max; i++) {
            int b = bytes[off + i] & 0xFF;
            int offset = (max - 1 - i) * 8;
            ret |= (b << offset);
        }
        return ret;
    }

    /**
     * 将高字节数组转换为long
     *
     * @param b 需要转换的值
     * @return 转换后的数据
     */
    public static long toLongByHL(byte[] b) {
        return toLongByHL(b, 0);
    }

    /**
     * 将高字节数组转换为long
     *
     * @param b   字节
     * @param off 开始位置
     * @return 转换后的数据
     */
    public static long toLongByHL(byte[] b, int off) {
        return toLongByHL(b, off, 8);
    }


    /**
     * 将高字节数组转换为int
     *
     * @param b 字节
     * @return 转换后的数据
     */
    public static int toIntByHL(byte[] b) {
        return toIntByHL(b, 0);
    }

    /**
     * 将高字节数组转换为int
     *
     * @param b   字节
     * @param off 开始位置
     * @return 转换后的数据
     */
    public static int toIntByHL(byte[] b, int off) {
        return (int) toLongByHL(b, off, 4);
    }


    /**
     * 高字节数组到short的转换
     *
     * @param b 字节
     * @return 转换后的数据
     */
    public static short toShortByHL(byte[] b) {
        return toShortByHL(b, 0);
    }

    /**
     * 高字节数组到short的转换
     *
     * @param b   字节
     * @param off 开始位置
     * @return 转换后的数据
     */
    public static short toShortByHL(byte[] b, int off) {
        return (short) toLongByHL(b, off, 2);
    }


    /**
     * 高字节数组转换为float
     *
     * @param b 字节
     * @return 转换后的数据
     */
    public static float toFloatByHL(byte[] b) {
        int i = toIntByHL(b);
        return Float.intBitsToFloat(i);
    }

    /**
     * 获取短整形的字节,高字节在前，低字节在后的byte数组
     *
     * @param value 需要转换的数据
     * @return 转换后的数据
     */
    public static byte[] getBytes(short value) {
        return toHL(value);
    }

    /**
     * 获取短整形的字节,高字节在前，低字节在后的byte数组
     *
     * @param value 需要转换的数据
     * @return 转换后的数据
     */
    public static byte[] getBytes(int value) {
        return toHL(value);
    }

    /**
     * 获取短整形的字节,高字节在前，低字节在后的byte数组
     *
     * @param value 需要转换的数据
     * @return 转换后的数据
     */
    public static byte[] getBytes(long value) {
        return toHL(value);
    }

    /**
     * 将byte数组中的元素倒序排列
     *
     * @param b 需要转换的数据
     * @return 转换后的数据
     */
    public static byte[] bytesReverseOrder(byte[] b) {
        int length = b.length;
        byte[] result = new byte[length];
        for (int i = 0; i < length; i++) {
            result[length - i - 1] = b[i];
        }
        return result;
    }

    /**
     * 将本机的 short 转换成网络上传输支持的 short ,用于多语言通讯时处理, 将 short 类型的值转换为字节序颠倒过来对应的 short 值
     *
     * @param from 需要转换的数据
     * @return 转换后的数据
     */
    public static short reverse(short from) {
        return toShortByHL(toLH(from));
    }

    /**
     * 将本机的 int 转换成网络上传输支持的 int ,用于多语言通讯时处理, 将 int 类型的值转换为字节序颠倒过来对应的 int 值
     *
     * @param from 需要转换的数据
     * @return 转换后的数据
     */
    public static int reverse(int from) {
        return toIntByHL(toLH(from));
    }

    /**
     * 将本机的 long 转换成网络上传输支持的 long ,用于多语言通讯时处理, 将 long 类型的值转换为字节序颠倒过来对应的 long 值
     *
     * @param from 需要转换的数据
     * @return 转换后的数据
     */
    public static long reverse(long from) {
        return toLongByHL(toLH(from));
    }

    /**
     * 将本机的 float 转换成网络上传输支持的 float ,用于多语言通讯时处理, 将 float 类型的值转换为字节序颠倒过来对应的 float 值
     *
     * @param from 需要转换的数据
     * @return 转换后的数据
     */
    public static float reverse(float from) {
        return toFloatByHL(toLH(from));
    }

    /**
     * 将字节数组转换为String
     *
     * @param bytes 需要转换的字节,如 [0x00,0x01]
     * @return 返回转换成功的字符串 如: 0001
     */
    public static String toHexString(byte[] bytes) {
        StringBuilder result = new StringBuilder();
        for (byte b : bytes) {
            String hv = Integer.toHexString(b & 0xff);
            if (hv.length() < 2) {
                result.append(0);
            }
            result.append(hv);
        }
        return result.toString();
    }

    /**
     * 将字节数组转换为String
     *
     * @param bytes 需要转换的字节,如 [0x00,0x01]
     * @return 返回转换成功的字符串 如: 0001
     */
    public static String toHexString1(byte[] bytes) {
        return toHexString1(bytes, 0, 0);
    }

    /**
     * 将字节数组转换为String
     *
     * @param bytes  需要转换的字节,如 [0x00,0x01]
     * @param offset 偏移量
     * @param len    需要转换的长度,当为0时，则默认为整个字符串的长度
     * @return 返回转换成功的字符串 如: 0001
     */
    public static String toHexString1(byte[] bytes, int offset, int len) {
        if (len == 0) {
            len = bytes.length;
        }
        StringBuilder sb = new StringBuilder();
        for (int i = offset; i < len; i++) {
            byte by = bytes[i];
            sb.append(String.format("%02X", by));
        }
        return sb.toString();
    }

    /**
     * 将字节数组转换为String
     *
     * @param from 需要转换的字节,如 0001
     * @return 返回转换成功的字符串 如: [0x00,0x01]
     */
    public static byte[] fromHexString(String from) {
        if (from == null || from.length() < 1) {
            return new byte[0];
        }
        from = from.toUpperCase().replaceAll(" ", "");
        int length = from.length() / 2;

        char[] hexChars = from.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }

    /**
     * convert char to byte
     *
     * @param c char
     * @return byte
     */
    private static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }


    /**
     * 将字节数组转换为String
     *
     * @param from 需要转换的字节,如 0001
     * @return 返回转换成功的字符串 如: [0x00,0x01]
     */
    public static byte[] fromHexString1(String from) {
        byte[] bytes = new byte[from.length() / BYTE_STRING_SIZE];
        for (int i = 0; i < from.length() / BYTE_STRING_SIZE; i++) {
            int b = Integer.parseInt(from.substring(i * BYTE_STRING_SIZE, i * BYTE_STRING_SIZE + BYTE_STRING_SIZE), BYTE_HEX_UNIT);
            bytes[i] = (byte) b;
        }
        return bytes;
    }

    /**
     * 将字节转换为字节字符串。如 [0x00,0x01]转成成 00 01
     *
     * @param bytes 需要转化的数据
     * @return 转换后的数据
     */
    public static String logBytes(byte[] bytes) {
        int length = bytes.length;
        StringBuilder sb = new StringBuilder(length);
        for (byte b : bytes) {
            sb.append(b);
            sb.append(" ");
        }
        return sb.toString();
    }

    /**
     * 将整形转换为BCD值
     *
     * @param from 需要转换的整形
     * @return 转换之后的值
     */
    public static byte toBCD(int from) {
        if (from >= BCD_MAX_FLAG) {
            throw YzgError.getRuntimeException("007");
        }
        byte bt = (byte) ((from / BYTE_TEN_UNIT * BYTE_HEX_UNIT) + from % BYTE_TEN_UNIT);
        return bt;
    }

    /**
     * 将BCD值转换为整形
     *
     * @param from 需要转换的BCD值
     * @return 转换之后的值
     */
    public static int fromBCD(byte from) {
        return (from / BYTE_HEX_UNIT) * BYTE_TEN_UNIT + from %
                BYTE_HEX_UNIT;
    }
}