Java二進位、十進位、十六進位、字元串之間的相互轉換

1. 位元組轉10進位

直接使用(int)類型轉換。

    /*
     * 位元組轉10進位
     */
    public static int byte2Int(byte b){
        int r = (int) b;
        return r;
    }

2. 10進位轉位元組

直接使用(byte)類型轉換。

    /*
     * 10進位轉位元組
     */
    public static byte int2Byte(int i){
        byte r = (byte) i;
        return r;
    }

3. 位元組數組轉16進位字元串

對每一個位元組，先和0xFF做與運算，然後使用Integer.toHexString()函數，如果結果只有1位，需要在前面加0。

    /*
     * 位元組數組轉16進位字元串
     */
    public static String bytes2HexString(byte[] b) {
        String r = "";
        
        for (int i = 0; i < b.length; i++) {
            String hex = Integer.toHexString(b[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            r += hex.toUpperCase();
        }
        
        return r;
    }

4. 16進位字元串轉位元組數組

這個比較複雜，每一個16進位字元是4bit，一個位元組是8bit，所以兩個16進位字元轉換成1個位元組，對於第1個字元，轉換成byte以後左移4位，然後和第2個字元的byte做或運算，這樣就把兩個字元轉換為1個位元組。

    /*
     * 字元轉換為位元組
     */
    private static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
     }
    
    /*
     * 16進位字元串轉位元組數組
     */
    public static byte[] hexString2Bytes(String hex) {
            
            if ((hex == null) || (hex.equals(""))){
                return null;
            }
            else if (hex.length()%2 != 0){
                return null;
            }
            else{                
                hex = hex.toUpperCase();
                int len = hex.length()/2;
                byte[] b = new byte[len];
                char[] hc = hex.toCharArray();
                for (int i=0; i<len; i++){
                    int p=2*i;
                    b[i] = (byte) (charToByte(hc[p]) << 4 | charToByte(hc[p+1]));
                }
              return b;
            }           
            
    }

5. 位元組數組轉字元串

直接使用new String()。

    /*
     * 位元組數組轉字元串
     */
    public static String bytes2String(byte[] b) throws Exception {
        String r = new String (b,"UTF-8");        
        return r;
    }

6. 字元串轉位元組數組

直接使用getBytes()。

    /*
     * 字元串轉位元組數組
     */
    public static byte[] string2Bytes(String s){
        byte[] r = s.getBytes();
        return r;
    }

7. 16進位字元串轉字元串

先轉換成byte[]，再轉換成字元串。

    /*
     * 16進位字元串轉字元串
     */
    public static String hex2String(String hex) throws Exception{
        String r = bytes2String(hexString2Bytes(hex));        
        return r;
    }

8. 字元串轉16進位字元串

先轉換為byte[]，再轉換為16進位字元串。

    /*
     * 字元串轉16進位字元串
     */
    public static String string2HexString(String s) throws Exception{
        String r = bytes2HexString(string2Bytes(s));        
        return r;
    }

main函數：

    public static void main(String[] args) throws Exception{        
        byte b1 = (byte) 45;
        System.out.println("1.位元組轉10進位:" + byte2Int(b1));
        
        int i = 89;
        System.out.println("2.10進位轉位元組:" + int2Byte(i));
        
        byte[] b2 = new byte[]{(byte)0xFF, (byte)0x5F, (byte)0x6, (byte)0x5A};
        System.out.println("3.位元組數組轉16進位字元串:" + bytes2HexString(b2));
        
        String s1 = new String("1DA47C");
        System.out.println("4.16進位字元串轉位元組數組:" + Arrays.toString(hexString2Bytes(s1)));
        
        System.out.println("5.位元組數組轉字元串:" + bytes2String(b2));
        
        System.out.println("6.字元串轉位元組數組:" + Arrays.toString(string2Bytes(s1)));
        
        System.out.println("7.16進位字元串轉字元串:" + hex2String(s1));
        
        String s2 = new String("Hello!");
        System.out.println("8.字元串轉16進位字元串:" + string2HexString(s2));
    }

運行結果：

1.位元組轉10進位:45
2.10進位轉位元組:89
3.位元組數組轉16進位字元串:FF5F065A
4.16進位字元串轉位元組數組:[29, -92, 124]
5.位元組數組轉字元串:?_Z
6.字元串轉位元組數組:[49, 68, 65, 52, 55, 67]
7.16進位字元串轉字元串:?|
8.字元串轉16進位字元串:48656C6C6F21