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

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進制的轉換方法就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持武林網。