Java中对于字节数组的操作（持续更新中....）

字符串转成字节数组

public static byte[] parse(String hexString) {
        String[] hexes = hexString.split(" ");
        byte[] data = new byte[hexes.length];
        for (int i = 0; i < hexes.length; i++) {
            data[i] = (byte) (Integer.parseInt(hexes[i], 16) & 0xff);
        }
        return data;
    }

将十进制字符串转换成BCD编码

    /**
     * 将10进制字符串转换为BCD码
     *
     * @param asc 十进制字符串
     * @return BCD码
     */
    public static byte[] stringToBcd(String asc) {
        int len = asc.length();
        int mod = len % 2;

        if (mod != 0) {
            asc = "0" + asc;
            len = asc.length();
        }

        byte[] abt;
        if (len >= 2) {
            len = len / 2;
        }

        byte[] bbt = new byte[len];
        abt = asc.getBytes();
        int j, k;

        for (int p = 0; p < asc.length() / 2; p++) {
            if ((abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {
                j = abt[2 * p] - '0';
            } else if ((abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {
                j = abt[2 * p] - 'a' + 0x0a;
            } else {
                j = abt[2 * p] - 'A' + 0x0a;
            }

            if ((abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {
                k = abt[2 * p + 1] - '0';
            } else if ((abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {
                k = abt[2 * p + 1] - 'a' + 0x0a;
            } else {
                k = abt[2 * p + 1] - 'A' + 0x0a;
            }

            int a = (j << 4) + k;
            byte b = (byte) a;
            bbt[p] = b;
        }
        return bbt;
    }

将byte数组转换成字符串

    /**
     * 将传入的byte数组转成字符串
     *
     * @param data 要转换的数据
     * @return 转换后的数据
     */
    public static String toString(byte[] data) {
        if (null == data) {
            return "";
        }
        return arrayToHex(data, data.length);
    }

将字节数组转换为十六进制并转换成字符串

    /**
     * 将字节数组转换为十六进制并转换为字符串
     *
     * @param buff   要转换的字节数组
     * @param length 长度
     * @return 转换后的字符串数据
     */
    public static String arrayToHex(byte[] buff, int length) {
        StringBuffer sb = new StringBuffer(length * 2);
        for (int i = 0; i < buff.length && i < length; i++) {
            if ((buff[i] & 0xff) < 0x10) {
                sb.append('0');//追加内容
            }
            sb.append(Integer.toHexString(buff[i] & 0xff).toUpperCase());//转为大写并转为十六进制然后追加
            sb.append(' ');//追加一个空格
        }
        return sb.toString();
    }

将int类型转换成16进制并转换成String

    /**
     * 将int类型转换为16进制并转换成String
     *
     * @param n 要转换的int数据
     * @return 转换后的String数据
     */
    public static String intToHex(int n) {
        StringBuffer buffer = new StringBuffer();
        String a;
        char[] b = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        while (n != 0) {
            buffer = buffer.append(b[n % 16]);
            n = n / 16;
        }
        a = buffer.reverse().toString();
        if ("".equals(a)) {
            a = "00";
        }
        if (a.length() == 1) {
            a = "0" + a;
        }
        return a;
    }

字符串转换成十六进制字符串

    /**
     * 字符串转换成16进制字符串
     *
     * @param strPart 要转换的字符串
     * @return 转换后的字符串
     */
    public static String stringToHex(String strPart) {
        StringBuffer hexString = new StringBuffer();
        for (int i = 0; i < strPart.length(); i++) {
            int ch = strPart.charAt(i);
            String strHex = Integer.toHexString(ch);
            hexString.append(strHex);
        }
        return hexString.toString();
    }

HEX字符串转换成byte

    /**
     * Hex字符串转byte
     *
     * @param inHex 要转换的hex字符串
     * @return 转换后的byte
     */
    public static byte hexToByte(String inHex) {
        return (byte) Integer.parseInt(inHex, 16);
    }

hex字符串转换为byte数组

    /**
     * hex字符串转换为byte数组
     *
     * @param inHex 要转换的数据
     * @return 转换后的byte数组
     */
    public static byte[] hexToByteArray(String inHex) {
        int hexlen = inHex.length();
        byte[] result;
        if (hexlen % 2 == 1) {
            //奇数
            hexlen++;
            result = new byte[(hexlen / 2)];
            inHex = "0" + inHex;
        } else {
            //偶数
            result = new byte[(hexlen / 2)];
        }
        int j = 0;
        for (int i = 0; i < hexlen; i += 2) {
            result[j] = hexToByte(inHex.substring(i, i + 2));
            j++;
        }
        return result;
    }