android byte字节数组转换十六进制字符串（物联网开发小结）

想起前段时间的物联网的外包开发，经常遇到通过wifi接受的数据，要通过转换成十六进制字符串，或者最后又是十进制数据。都是根据双方的协议来开发的。那么我发送过去的数据也需要，经过特殊转换成byte字节发过去，硬件那边收到不至于乱码的数据。

1、硬件调试发给android这边是十六进制数据

DataInputStream dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));byte readBuffer[] = new byte[64];	int count = 0; try {	count = dis.read(readBuffer);      } catch (IOException e) {	continue;      } 

那么要根据这些数据转换成十六进制的字符串，如果你直接转换成String字符串那肯定乱码了。因为硬件调试发给android这边是十六进制数据。

readBuffer字节数组转后数据十六进制是这样的：68 , 38 , 38 , 68 , 00 , 72 , 78 , 55 , 34 , 12 , 43 , 23 , 01 , 07 , 00 , 00 , 00 , 00 , 0C , 13 , 78 , 56 , 34 , 12 , 0C , 3B , 78 , 34 , 12 , 0C , 26 , 78 , 56 , 34 , 12 , 0B , 59 , 45 , 23 , 00 , 02 , FD , 17 , 00 , 00 , 16
可以看出跟硬件发的是不是一样了。这里面不是十六进制Y，CS就用00填充了。
当然这些都是根据双方收发数据来解析，处理的。

2、android端发给硬件那边

	private String mstrRestartSend = "FE FE 68 04 04 68 53 FD 50 00 A0 16";        private byte[] mRestart = null;        mRestart = StringUtil.HexCommandtoByte(mstrRestartSend.getBytes());public class StringUtil {    //  十六进制的字符串转换成byte数组		public static byte[] HexCommandtoByte(byte[] data) {		if (data == null) {			return null;		}		int nLength = data.length; 				String strTemString = new String(data, 0, nLength);		String[] strings = strTemString.split(" ");		nLength = strings.length;		data = new byte[nLength];					for (int i = 0; i < nLength; i++) {			if (strings[i].length() != 2) {				data[i] = 00;				continue;			}			try {				data[i] = (byte)Integer.parseInt(strings[i], 16);			} catch (Exception e) {				data[i] = 00;				continue;			}		}			return data;	}  }

3、写了demo测试转换数据转换

下载地址：下载
示例图：

4、网上收集较全面的java底层数据转换

public class DigitalTrans {    /**     * 数字字符串转ASCII码字符串     *      * @param String     *            字符串     * @return ASCII字符串     */    public static String StringToAsciiString(String content) {        String result = "";        int max = content.length();        for (int i = 0; i < max; i++) {            char c = content.charAt(i);            String b = Integer.toHexString(c);            result = result + b;        }        return result;    }    /**     * 十六进制转字符串     *      * @param hexString     *            十六进制字符串     * @param encodeType     *            编码类型4：Unicode，2：普通编码     * @return 字符串     */    public static String hexStringToString(String hexString, int encodeType) {        String result = "";        int max = hexString.length() / encodeType;        for (int i = 0; i < max; i++) {            char c = (char) DigitalTrans.hexStringToAlgorism(hexString                    .substring(i * encodeType, (i + 1) * encodeType));            result += c;        }        return result;    }    /**     * 十六进制字符串装十进制     *      * @param hex     *            十六进制字符串     * @return 十进制数值     */    public static int hexStringToAlgorism(String hex) {        hex = hex.toUpperCase();        int max = hex.length();        int result = 0;        for (int i = max; i > 0; i--) {            char c = hex.charAt(i - 1);            int algorism = 0;            if (c >= '0' && c <= '9') {                algorism = c - '0';            } else {                algorism = c - 55;            }            result += Math.pow(16, max - i) * algorism;        }        return result;    }    /**     * 十六转二进制     *      * @param hex     *            十六进制字符串     * @return 二进制字符串     */    public static String hexStringToBinary(String hex) {        hex = hex.toUpperCase();        String result = "";        int max = hex.length();        for (int i = 0; i < max; i++) {            char c = hex.charAt(i);            switch (c) {            case '0':                result += "0000";                break;            case '1':                result += "0001";                break;            case '2':                result += "0010";                break;            case '3':                result += "0011";                break;            case '4':                result += "0100";                break;            case '5':                result += "0101";                break;            case '6':                result += "0110";                break;            case '7':                result += "0111";                break;            case '8':                result += "1000";                break;            case '9':                result += "1001";                break;            case 'A':                result += "1010";                break;            case 'B':                result += "1011";                break;            case 'C':                result += "1100";                break;            case 'D':                result += "1101";                break;            case 'E':                result += "1110";                break;            case 'F':                result += "1111";                break;            }        }        return result;    }    /**     * ASCII码字符串转数字字符串     *      * @param String     *            ASCII字符串     * @return 字符串     */    public static String AsciiStringToString(String content) {        String result = "";        int length = content.length() / 2;        for (int i = 0; i < length; i++) {            String c = content.substring(i * 2, i * 2 + 2);            int a = hexStringToAlgorism(c);            char b = (char) a;            String d = String.valueOf(b);            result += d;        }        return result;    }    /**     * 将十进制转换为指定长度的十六进制字符串     *      * @param algorism     *            int 十进制数字     * @param maxLength     *            int 转换后的十六进制字符串长度     * @return String 转换后的十六进制字符串     */    public static String algorismToHEXString(int algorism, int maxLength) {        String result = "";        result = Integer.toHexString(algorism);        if (result.length() % 2 == 1) {            result = "0" + result;        }        return patchHexString(result.toUpperCase(), maxLength);    }    /**     * 字节数组转为普通字符串（ASCII对应的字符）     *      * @param bytearray     *            byte[]     * @return String     */    public static String bytetoString(byte[] bytearray) {        String result = "";        char temp;        int length = bytearray.length;        for (int i = 0; i < length; i++) {            temp = (char) bytearray[i];            result += temp;        }        return result;    }    /**     * 二进制字符串转十进制     *      * @param binary     *            二进制字符串     * @return 十进制数值     */    public static int binaryToAlgorism(String binary) {        int max = binary.length();        int result = 0;        for (int i = max; i > 0; i--) {            char c = binary.charAt(i - 1);            int algorism = c - '0';            result += Math.pow(2, max - i) * algorism;        }        return result;    }    /**     * 十进制转换为十六进制字符串     *      * @param algorism     *            int 十进制的数字     * @return String 对应的十六进制字符串     */    public static String algorismToHEXString(int algorism) {        String result = "";        result = Integer.toHexString(algorism);        if (result.length() % 2 == 1) {            result = "0" + result;        }        result = result.toUpperCase();        return result;    }    /**     * HEX字符串前补0，主要用于长度位数不足。     *      * @param str     *            String 需要补充长度的十六进制字符串     * @param maxLength     *            int 补充后十六进制字符串的长度     * @return 补充结果     */    static public String patchHexString(String str, int maxLength) {        String temp = "";        for (int i = 0; i < maxLength - str.length(); i++) {            temp = "0" + temp;        }        str = (temp + str).substring(0, maxLength);        return str;    }    /**     * 将一个字符串转换为int     *      * @param s     *            String 要转换的字符串     * @param defaultInt     *            int 如果出现异常,默认返回的数字     * @param radix     *            int 要转换的字符串是什么进制的,如16 8 10.     * @return int 转换后的数字     */    public static int parseToInt(String s, int defaultInt, int radix) {        int i = 0;        try {            i = Integer.parseInt(s, radix);        } catch (NumberFormatException ex) {            i = defaultInt;        }        return i;    }    /**     * 将一个十进制形式的数字字符串转换为int     *      * @param s     *            String 要转换的字符串     * @param defaultInt     *            int 如果出现异常,默认返回的数字     * @return int 转换后的数字     */    public static int parseToInt(String s, int defaultInt) {        int i = 0;        try {            i = Integer.parseInt(s);        } catch (NumberFormatException ex) {            i = defaultInt;        }        return i;    }    /**     * 十六进制字符串转为Byte数组,每两个十六进制字符转为一个Byte     *      * @param hex     *            十六进制字符串     * @return byte 转换结果     */    public static byte[] hexStringToByte(String hex) {        int max = hex.length() / 2;        byte[] bytes = new byte[max];        String binarys = DigitalTrans.hexStringToBinary(hex);        for (int i = 0; i < max; i++) {            bytes[i] = (byte) DigitalTrans.binaryToAlgorism(binarys.substring(                    i * 8 + 1, (i + 1) * 8));            if (binarys.charAt(8 * i) == '1') {                bytes[i] = (byte) (0 - bytes[i]);            }        }        return bytes;    }    /**     * 十六进制串转化为byte数组     *      * @return the array of byte     */    public static final byte[] hex2byte(String hex)            throws IllegalArgumentException {        if (hex.length() % 2 != 0) {            throw new IllegalArgumentException();        }        char[] arr = hex.toCharArray();        byte[] b = new byte[hex.length() / 2];        for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {            String swap = "" + arr[i++] + arr[i];            int byteint = Integer.parseInt(swap, 16) & 0xFF;            b[j] = new Integer(byteint).byteValue();        }        return b;    }    /**     * 字节数组转换为十六进制字符串     *      * @param b     *            byte[] 需要转换的字节数组     * @return String 十六进制字符串     */    public static final String byte2hex(byte b[]) {        if (b == null) {            throw new IllegalArgumentException(                    "Argument b ( byte array ) is null! ");        }        String hs = "";        String stmp = "";        for (int n = 0; n < b.length; n++) {            stmp = Integer.toHexString(b[n] & 0xff);            if (stmp.length() == 1) {                hs = hs + "0" + stmp;            } else {                hs = hs + stmp;            }        }        return hs.toUpperCase();    }}