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做"|"运算,即可得到十六进制的二进制字节表示
其中一种转换的函数如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
/** * * @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进制字符串。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
* @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[] */ 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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/** * 字符串转换成十六进制字符串 */ 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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/** * 把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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/** * 数组转换成十六进制字符串 * @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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/** * 数组转成十六进制字符串 * @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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/** * 十六进制字符串转换成字符串 * @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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
/** * 十六进制字符串转换字符串 * @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进制的转换方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持服务器之家。