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