从0开始，步步实现Android串口编程（二）

前言

这里主要记录一下，我在做串口编程时，用到的一些16进制，10进制，字符串，字节数组 转换方法，方便后面自己查找。

方法

1.16进制转Ascii

 /**
     * 16进制转ASCII
     * @param s
     * @return
     * @throws IllegalArgumentException
     */
    public static String hexToAscii(String s) throws IllegalArgumentException {
        int n = s.length();
        StringBuilder sb = new StringBuilder(n / 2);
        for (int i = 0; i < n; i += 2) {
            char a = s.charAt(i);
            char b = s.charAt(i + 1);
            sb.append((char) ((hexToInt(a) << 4) | hexToInt(b)));
        }
        return sb.toString();
    }

    public static int hexToInt(char ch) {
        if ('a' <= ch && ch <= 'f') {
            return ch - 'a' + 10;
        }
        if ('A' <= ch && ch <= 'F') {
            return ch - 'A' + 10;
        }
        if ('0' <= ch && ch <= '9') {
            return ch - '0';
        }
        throw new IllegalArgumentException(String.valueOf(ch));
    }

2.16进制，字符串（包括中文）转换，无需unicode解码

  /**
     * 16进制转字符串，无需unicode解码
     * 我的通讯协议里面规定的就是GB2312，这个看你们通讯协议规定，照着改就好了
     * @param
     * @return
     */
    public static String hexToStr(String hexStr) {
        String str = "0123456789ABCDEF";
        char[] hexs = hexStr.toUpperCase().toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int n;
        for (int i = 0; i < bytes.length; i++) {
            n = str.indexOf(hexs[2 * i]) * 16;
            n += str.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte) (n & 0xff);
        }
        try {
            return new String(bytes, "GB2312");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return "null";
    }
     /**
     * 字符串转16进制
     * @param str
     * @return
     */
    public static String strToHex(String str){
        char[] chars = "0123456789ABCDEF".toCharArray();
        StringBuilder sb = new StringBuilder("");
        byte[] bs = str.getBytes();
        int bit;
        for (int i = 0; i < bs.length; i++) {
            bit = (bs[i] & 0x0f0) >> 4;
            sb.append(chars[bit]);
            bit = bs[i] & 0x0f;
            sb.append(chars[bit]);
        }
        return sb.toString().trim();
    }

3.字节数组，16进制转换

    /**
     * byte类型转换为string类型	重载函数
     * 你可以用空格分割字符，也可以用","，随便啦，只不过我习惯“”
     * @param b
     * @param length
     * @return
     */
    public static String BytetoHexString(byte[] b, int length) {
        String a = "";
        for (int i = 0; i < length; i++) {
            String hex = Integer.toHexString(b[i] & 0xff);
            if ((b[i] < 0x10) && (b[i] >= 0x00))    //
            {
                hex = "0" + hex;
            }
            if (hex.length() == 1) {
//                hex = "\b" + hex;
                hex = "," + hex;
            }
//            a = a + "\b" + hex;        //加空格
            a = a + "," + hex;
        }

        return a.substring(1, a.length());
    }
	/**
	* 跟上面一样，如果，不需要处理显示格式，直接用这个
	*
	*/
     private static String ByteArrayToHexString(byte[] byteArray) {
        final StringBuilder hexString = new StringBuilder("");
        if (byteArray == null || byteArray.length <= 0)
            return null;
        for (int i = 0; i < byteArray.length; i++) {
            int v = byteArray[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                hexString.append(0);
            }
            hexString.append(hv);
        }
        return hexString.toString().toUpperCase();
    }
 /**
     * 16进制转字节数组
     * @param s
     * @return
     */
    private static byte[] HexStringToByteArray(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
                    + Character.digit(s.charAt(i + 1), 16));
        }
        return data;
    }

4.16进制转10进制，10进制转16进制，这个是最彪的

  /**
     * 16进制转10进制
     * 我能说，这个api给的太暴躁了吗，
     * @param hex
     * @return
     */
    public static long hexToTen(String hex) {
        return Long.valueOf(hex, 16);
    }
 /**
     * 10进制转16进制
     *
     * @param number
     * @return
     */
    public static String tenToHex(int number) {
        return Long.toHexString(number);
    }

5.10进制，BCD码 转换

  /**
 	 * 虽然这次没用到，还是要记下来，万一后面用到，就不用找了
     * bcd码转10进制
     *
     * @param bytes
     * @return
     */
    public static String bcdToTen(byte[] bytes) {
        StringBuffer temp = new StringBuffer(bytes.length * 2);
        for (int i = 0; i < bytes.length; i++) {
            temp.append((byte) ((bytes[i] & 0xf0) >>> 4));
            temp.append((byte) (bytes[i] & 0x0f));
        }
        return temp.toString().substring(0, 1).equalsIgnoreCase("0") ? temp
                .toString().substring(1) : temp.toString();

    }

    /**
     * 10进制转BCD码
     *
     * @param asc 10进制串
     * @return BCD码
     */
    public static byte[] tenToBcd(String asc) {
        int len = asc.length();
        int mod = len % 2;
        if (mod != 0) {
            asc = "0" + asc;
            len = asc.length();
        }
        byte abt[] = new byte[len];
        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;
    }

6.BCC校验字

    /**
     * 末位 添加BCC校验码
     *
     * @return
     */
    private static byte[] getBCC(byte[] oldDatas) {
        byte[] newDatas = new byte[oldDatas.length + 1];
        newDatas[0] = oldDatas[0];
        newDatas[oldDatas.length] = oldDatas[0];
        for (int i = 1; i < oldDatas.length; i++) {
            newDatas[i] = oldDatas[i];
            newDatas[oldDatas.length] ^= oldDatas[i];
        }
        return newDatas;
    }