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进制的转换方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。