java中进制的转换,Byte与16进制的转换⽅法
java中对于进制的转换有很多⽅式，其中对于常见的基本的⼆进制⼋进制⼗进制⼗六进制等的转换有对于的包装类实现，不需要通过⼆外的算法来进⾏实现，具体如下：
⾸先关于最简单的⼆进制转换的⽅法有：
⼗进制转成⼗六进制：
HexString(int i)
⼗进制转成⼋进制
OctalString(int i)
⼗进制转成⼆进制
BinaryString(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
进制转换如何写（⼆，⼋，⼗六）不⽤算法
然后是介绍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 >* Convert byte[] to hex string.这⾥我们可以将byte转换成int，然后利⽤HexString(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 = HexString(v);
if (hv.length() < 2) {
stringBuilder.append(0);
}
stringBuilder.append(hv);
}
String();
}
/**
* 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 = UpperCase();
int length = hexString.length() / 2;
char[] hexChars = CharArray();
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进⾏了与运算，然后使⽤HexString取得了⼗六进制字符串，可以看出
b[ i ] & 0xFF运算后得出的仍然是个int，那么为何要和 0xFF进⾏与运算呢?直接 HexString(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 = Bytes();
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]);
}
String();
}
⼗六进制字符串转换成为数组⽅法1：
/**
* 把16进制字符串转换成字节数组
* @param hexString
* @return byte[]
*/
public static byte[] hexStringToByte(String hex) {
int len = (hex.length() / 2);
byte[] result = new byte[len];
char[] achar = CharArray();
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 HexStringjava数组字符串转数组
*/
public static final String bytesToHexString(byte[] bArray) { StringBuffer sb = new StringBuffer(bArray.length);
String sTemp;
for (int i = 0; i < bArray.length; i++) {
sTemp = HexString(0xFF & bArray[i]);
if (sTemp.length() < 2)
sb.append(0);
sb.UpperCase());
}
String();
}
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]));
}
String();
}
public static String toHexString1(byte b){
String s = HexString(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 = CharArray();
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进制的转换⽅法就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。