java中進位的轉換,Byte與16進位的轉換方法_java

java中對於進位的轉換有很多方式，其中對於常見的基本的二進位 八進位 十進位 十六進位等的轉換有對於的封裝類實現，不需要通過二外的演算法來進行實現，具體如下：

首先關於最簡單的二進位轉換的方法有：

十進位轉成十六進位：
String Integer.toHexString(int i)
十進位轉成八進位
String Integer.toOctalString(int i)
十進位轉成二進位
 String Integer.toBinaryString(int i)
十六進位轉成十進位
Integer.valueOf("FFFF",16).toString()   //不能處理帶首碼的情況 0x
八進位轉成十進位
Integer.valueOf("76",8).toString()  //首碼0可以被處理
二進位轉十進位
Integer.valueOf("0101",2).toString() 

有什麼方法可以直接將2,8,16 進位直接轉換為10進位的嗎 ?

java.lang.Integer類

parseInt(String s, int radix)

使用第二個參數指定的基數，將字串參數解析為有符號的整數。

examples from jdk:
parseInt("0", 10) returns 0
parseInt("473", 10) returns 473
parseInt("-0", 10) returns 0
parseInt("-FF", 16) returns -255
parseInt("1100110", 2) returns 102
parseInt("2147483647", 10) returns 2147483647
parseInt("-2147483648", 10) returns -2147483648
parseInt("2147483648", 10)throwsa NumberFormatException
parseInt("99",throwsa NumberFormatException
parseInt("Kona", 10)throwsa NumberFormatException
parseInt("Kona", 27)returns 411787

進位轉換如何寫（二，八，十六）不用演算法
Integer.toBinaryString
Integer.toOctalString
Integer.toHexString

然後是介紹java中的byte與十六進位數的轉換

原理分析：

Java中的byte是由8個bit組成的，而16進位即16中狀態，它是由4個bit來表示的，因為24=16。所以我們可以把一個byte轉換成兩個用16進位字元，即把高4位和低4位轉換成相應的16進位字元，並組合這兩個16進位字串，從而得到byte的16進位字串。同理，相反的轉換也是將兩個16進位字元轉換成一個byte。

在Java中位元組與十六進位的相互轉換主要思想有兩點：

1、二進位位元組轉十六進位時，將位元組高位與0xF0做"&"操作,然後再左移4位，得到位元組高位的十六進位A;將位元組低位與0x0F做"&"操作，得到低位的十六進位B，將兩個十六進位數拼裝到一塊AB就是該位元組的十六進位表示。

2、十六進位轉二進位位元組時，將十六進位字元對應的十進位數字右移動4為，得到位元組高位A;將位元組低位的十六進位字元對應的十進位數字B與A做"|"運算，即可得到十六進位的二進位位元組表示

其中一種轉換的函數如下：

/** *  * @param bytes * @return 將二進位轉換為十六進位字元輸出 */ </span>    private static String hexStr = "0123456789ABCDEF"; //全域   public static String BinaryToHexString(byte[] bytes){       String result = "";    String hex = "";    for(int i=0;i<bytes.length;i++){      //位元組高4位      <strong>hex = String.valueOf(hexStr.charAt((bytes[i]&0xF0)>>4)); </strong>    //位元組低4位     <strong>hex += String.valueOf(hexStr.charAt(bytes[i]&0x0F)); </strong>     result +=hex;    }    return result;     }     /** *  * @param hexString * @return 將十六進位轉換為位元組數組 */    public static byte[] HexStringToBinary(String hexString){    //hexString的長度對2取整，作為bytes的長度    int len = hexString.length()/2;    byte[] bytes = new byte[len];    byte high = 0;//位元組高四位    byte low = 0;//位元組低四位      for(int i=0;i<len;i++){      //右移四位得到高位      high = (byte)((hexStr.indexOf(hexString.charAt(2*i)))<<4);      low = (byte)hexStr.indexOf(hexString.charAt(2*i+1));      bytes[i] = (byte) (high|low);//高地位做或運算    }    return bytes;     }   } 

還有一種類似的方法：
    
<span style="font-size:14px;">* Convert byte[] to hex string.這裡我們可以將byte轉換成int，然後利用Integer.toHexString(int)來轉換成16進位字串。 

* @param src byte[] data  * @return hex string  */   public static String bytesToHexString(byte[] src){   StringBuilder stringBuilder = new StringBuilder("");   if (src == null || src.length <= 0) {     return null;   }   for (int i = 0; i < src.length; i++) {     int v = src[i] & 0xFF;     String hv = Integer.toHexString(v);     if (hv.length() < 2) {       stringBuilder.append(0);     }     stringBuilder.append(hv);   }   return stringBuilder.toString(); } /**  * Convert hex string to byte[]  * @param hexString the hex string  * @return byte[]  */ public static byte[] hexStringToBytes(String hexString) {   if (hexString == null || hexString.equals("")) {     return null;   }   hexString = hexString.toUpperCase();   int length = hexString.length() / 2;   char[] hexChars = hexString.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 byte charToByte(char c) {   return (byte) "0123456789ABCDEF".indexOf(c); } </span>

兩種方式類似，這裡注意下

上面是將byte[]轉化十六進位的字串,注意這裡b[ i ] & 0xFF將一個byte和 0xFF進行了與運算,然後使用Integer.toHexString取得了十六進位字串,可以看出

b[ i ] & 0xFF運算後得出的仍然是個int,那麼為何要和 0xFF進行與運算呢?直接 Integer.toHexString(b[ i ]);,將byte強轉為int不行嗎?答案是不行的.

其原因在於：

1.byte的大小為8bits而int的大小為32bits
2.java的二進位採用的是補碼形式

所以與負數&的時候負數會自動給補碼補位1，這樣就會有誤差

而0xff預設是整形，所以，一個byte跟0xff相與會先將那個byte轉化成整形運算，這樣，結果中的高的24個位元就總會被清0，於是結果總是我們想要的。

還有一些網上總結的方法：

字串轉換成十六進位字串方法1：

/**    * 字串轉換成十六進位字串   */   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]);     }     return sb.toString();   } 

十六進位字串轉換成為數組方法1：

/**  * 把16進位字串轉換成位元組數組  * @param hexString  * @return byte[]  */ public static byte[] hexStringToByte(String hex) {  int len = (hex.length() / 2);  byte[] result = new byte[len];  char[] achar = hex.toCharArray();  for (int i = 0; i < len; i++) {  int pos = i * 2;  result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));  }  return result; }  private static int toByte(char c) {  byte b = (byte) "0123456789ABCDEF".indexOf(c);  return b; }

數群組轉換成十六進位字串方法1：

/** * 數群組轉換成十六進位字串 * @param byte[] * @return HexString */ public static final String bytesToHexString(byte[] bArray) { StringBuffer sb = new StringBuffer(bArray.length); String sTemp; for (int i = 0; i < bArray.length; i++) {  sTemp = Integer.toHexString(0xFF & bArray[i]);  if (sTemp.length() < 2)  sb.append(0);  sb.append(sTemp.toUpperCase()); } return sb.toString(); }

byte[]數群組轉換成十六進位字串方法2：

/**   * 數組轉成十六進位字串   * @param byte[]   * @return HexString   */  public static String toHexString1(byte[] b){    StringBuffer buffer = new StringBuffer();    for (int i = 0; i < b.length; ++i){      buffer.append(toHexString1(b[i]));    }    return buffer.toString();  }  public static String toHexString1(byte b){    String s = Integer.toHexString(b & 0xFF);    if (s.length() == 1){      return "0" + s;    }else{      return s;    }  }

十六進位字串轉換字串方法1：

/** * 十六進位字串轉換成字串 * @param hexString * @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);   }

十六進位字串轉換字串方法2：

/**   * 十六進位字串轉換字串   * @param HexString   * @return String   */ public static String toStringHex(String s) { byte[] baKeyword = new byte[s.length() / 2]; for (int i = 0; i < baKeyword.length; i++) {  try {  baKeyword[i] = (byte) (0xff & Integer.parseInt(s.substring(   i * 2, i * 2 + 2), 16));  } catch (Exception e) {  e.printStackTrace();  } } try {  s = new String(baKeyword, "utf-8");// UTF-16le:Not } catch (Exception e1) {  e1.printStackTrace(); } return s; }

以上這篇java中進位的轉換,Byte與16進位的轉換方法就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支援雲棲社區。