想起前段時間的物聯網的外包開發，經常遇到通過wifi接受的資料，要通過轉換成十六進位制字串，或者最後又是十進位制資料。都是根據雙方的協議來開發的。那麼我傳送過去的資料也需要，經過特殊轉換成byte位元組發過去，硬體那邊收到不至於亂碼的資料。

1、硬體除錯發給android這邊是十六進位制資料 原始資料：68 38 38 68 A 72 78 55 34 12 43 23 01 07 Y 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 CS 16

android讀到資料是byte位元組陣列 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;       }  readBuffer收到資料是這樣的：104, 56, 56, 104, 0, 114, 120, 85, 52, 18, 67, 35, 1, 7, 0, 0, 0, 0, 12, 19, 120, 86, 52, 18, 12, 59, 120, 52, 18, 12, 38, 120, 86, 52, 18, 11, 89, 69, 35, 0, 2, -3, 23, 0, 0, 22 那麼要根據這些資料轉換成十六進位制的字串，如果你直接轉換成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端發給硬體那邊 android的原始資料是這個的：68 04 04 68 35 FD 50 00 A0 16，也是十六進位制的字串 需要做的就是十六進位制的字串轉換成byte陣列 轉換程式碼：     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底層資料轉換 Java中二進位制、十進位制、十六進位制及ASCII碼與String及位元組陣列與十六進位制字串之間的轉換 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();     } }

/**     * 字串轉換成十六進位制字串    * @param String str 待轉換的ASCII字串    * @return String 每個Byte之間空格分隔，如: [61 6C 6B]    */       public static String str2HexStr(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]);             sb.append(' ');         }           return sb.toString().trim();       }          /**     * 十六進位制轉換字串    * @param String str Byte字串(Byte之間無分隔符 如:[616C6B])    * @return String 對應的字串    */       public static String hexStr2Str(String hexStr)     {           String str = "0123456789ABCDEF";           char[] hexs = hexStr.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);           }           return new String(bytes);       }          /**    * bytes轉換成十六進位制字串    * @param byte[] b byte陣列    * @return String 每個Byte值之間空格分隔    */     public static String byte2HexStr(byte[] b)     {         String stmp="";         StringBuilder sb = new StringBuilder("");         for (int n=0;n<b.length;n++)         {             stmp = Integer.toHexString(b[n] & 0xFF);             sb.append((stmp.length()==1)? "0"+stmp : stmp);             sb.append(" ");         }         return sb.toString().toUpperCase().trim();     }          /**    * bytes字串轉換為Byte值    * @param String src Byte字串，每個Byte之間沒有分隔符    * @return byte[]    */     public static byte[] hexStr2Bytes(String src)     {         int m=0,n=0;         int l=src.length()/2;         System.out.println(l);         byte[] ret = new byte[l];         for (int i = 0; i < l; i++)         {             m=i*2+1;             n=m+1;             ret[i] = Byte.decode("0x" + src.substring(i*2, m) + src.substring(m,n));         }         return ret;     }        /**    * String的字串轉換成unicode的String    * @param String strText 全形字串    * @return String 每個unicode之間無分隔符    * @throws Exception    */     public static String strToUnicode(String strText)         throws Exception     {         char c;         StringBuilder str = new StringBuilder();         int intAsc;         String strHex;         for (int i = 0; i < strText.length(); i++)         {             c = strText.charAt(i);             intAsc = (int) c;             strHex = Integer.toHexString(intAsc);             if (intAsc > 128)                 str.append("\\u" + strHex);             else // 低位在前面補00                 str.append("\\u00" + strHex);         }         return str.toString();     }          /**    * unicode的String轉換成String的字串    * @param String hex 16進位制值字串 （一個unicode為2byte）    * @return String 全形字串    */     public static String unicodeToString(String hex)     {         int t = hex.length() / 6;         StringBuilder str = new StringBuilder();         for (int i = 0; i < t; i++)         {             String s = hex.substring(i * 6, (i + 1) * 6);             // 高位需要補上00再轉             String s1 = s.substring(2, 4) + "00";             // 低位直接轉             String s2 = s.substring(4);             // 將16進位制的string轉為int             int n = Integer.valueOf(s1, 16) + Integer.valueOf(s2, 16);             // 將int轉換為字元             char[] chars = Character.toChars(n);             str.append(new String(chars));         }         return str.toString();     }   

大家要區分除錯時候，看到資料是不一樣。

---------------------  作者：mmsx  來源：CSDN  原文：https://blog.csdn.net/qq_16064871/article/details/50491309  版權宣告：本文為博主原創文章，轉載請附上博文連結！