Java中字符串转换

Java中字符串转换：转自http://www.voidcn.com/blog/hll174/article/p-5760755.html

      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; }