Java中十六進制轉換 Integer.toHexString()

爲了顯示一個byte型的單字節十六進制(兩位十六進制表示)的編碼，請使用：

Integer.toHexString((byteVar & 0x000000FF) | 0xFFFFFF00).substring(6)

byteVar & 0x000000FF的做用是，若是byteVar 是負數，則會清除前面24個零，正的byte整型不受影響。

(...) | 0xFFFFFF00的做用是，若是byteVar 是正數，則置前24位爲一，這樣toHexString輸出一個小於等於15的byte整型的十六進制時，倒數第二位爲零且不會被丟棄，這樣能夠經過substring方法進行截取最後兩位便可。

實例說明

import junit.framework.TestCase;

public class Hex extends TestCase {

    public void testPositiveIntToHex() {
        //若是正數小於15時，只輸入一位，而不是按咱們想像的兩位標準十六進制輸出顯示的，後面解決這個問題
        System.out.println(Integer.toHexString(2));//2
        System.out.println(Integer.toHexString(15));//f
        System.out.println(Integer.toHexString(16));//10
        System.out.println(Integer.valueOf("F", 16));//16
    }

    /*
     * Integer.valueOf()實質上調用的是Integer.parseInt()來完成的，因此
     * Integer.parseInt()與Integer.valueOf()功能是同樣的，只是返回值不
     * 同樣而已
     */
    public void testNegativeIntToHex() {
        //負整數時，前面輸入了多餘的 FF ，沒有去掉前面多餘的 FF，按並雙字節形式輸出
        System.out.println(Integer.toHexString(-2).toUpperCase());//FFFFFFFE

        //實質上0xFF會像轉換成0x000000FF後再進行位運算
        System.out.println(Integer.toHexString(-2 & 0xFF).toUpperCase());//FE
        System.out.println(Integer.toHexString(-2 & 0x000000FF).toUpperCase());//FE

        //注，FE輸出時不會爲-2，由於此時不會把FE當作負數，valueOf會把全部數字串當作正的
        System.out.println(Integer.valueOf("FE", 16));//254
        //若是要輸出-2，只能按如下形式輸出
        System.out.println(Integer.valueOf("-2", 16));//-2

        //因此要把 FE 當作負的話，只能在前面加上負號，可是這裏輸出還不是-2，
        //而是先計算Integer.valueOf("FE", 16)，再在結果前加上負
        System.out.println(Integer.valueOf("-FE", 16));//-254

        /* 因此若是要輸入某個負數，咱們只能先求出該數的絕對值的原碼十六進制，再在前面加上負號，
         * 例如求表示-128，則先對絕對值128求十六進制 80，再在前面加上負號 -80
         */
        System.out.println(Integer.valueOf("-80", 16));//-128

        /* 爲何說valueOf把全部數字串當作正的呢？請看下面三行代碼，由於最大正數爲2147483647，
         * 若是再    在7fffffff基礎上加上一個一，運行確定會出錯誤（這與直接輸出0x80000000不同），
         * 那麼就能夠證實
         */
        System.out.println(Integer.valueOf("7fffffff", 16));//2147483647
        //此句運行時會報錯，由於最大正數爲7fffffff，但如 -80000000 卻又能夠運行，由於沒超出整數範圍
        //System.out.println(Integer.valueOf("80000000", 16));//不能運行，已注掉
        System.out.println(Integer.valueOf("-80000000", 16));//-2147483648

        /* 注，輸出時不是負數，而是正，由於0xFE只有8位，而整數是32位，因此以int形式出現時前
         * 面會自動補24個零，第一位是零，因此最後是正數
         */
        System.out.println(0xFE);//254
        System.out.println(-0xFE);//-254
        //但0x80000000已滿，無需補，第一位爲一，因此最後爲負數
        System.out.println(0x80000000);//-2147483648
    }

    public void testNegativeIntToBin() {
        System.out.println(Integer.toBinaryString(-2));//11111111111111111111111111111110
        //實質上0xFF會像轉換成0x000000FF後再進行位運算
        System.out.println(Integer.toBinaryString(-2 & 0xFF));//11111110
        System.out.println(Integer.toBinaryString(-2 & 0x000000FF));//11111110

        //與上面十六進制是同樣的
        System.out.println(Integer.valueOf("1111111111111111111111111111111", 2));//2147483647
        //下面語句運行會出錯，已注掉
        //System.out.println(Integer.valueOf("10000000000000000000000000000000", 2));
        System.out.println(Integer.valueOf("-10000000000000000000000000000000", 2));//-2147483648
        System.out.println(Integer.valueOf("11111110", 2));//254
        System.out.println(Integer.valueOf("-11111110", 2));//-254

        /* 注，Java中沒有直接使用二進制表示一個數（目前只支持八與十六進制直接表示法），下面實際上是一個
         * 八進制的數與十進制的數
         */
        System.out.println(010);//8
        System.out.println(10);//10
    }

    public void testByteToHex() {

        byte negativeByte = -2;
        byte positiveByte = 2;

        /* toHexString方法類型爲int型，因此轉Hex前參數會提高成整型後再進行轉換，過程以下：
         * 10000010(原碼)->11111110(補碼)->11111111 11111111 11111111 11111110(提高)
         * ->FFFFFFFE(轉Hex進制輸出)
         */
        System.out.println(Integer.toHexString(negativeByte).toUpperCase());// FFFFFFFE

        /* 第一步把-2轉成整型：
         * 10000010(原碼)->11111110(補碼)->11111111 11111111 11111111 11111110(轉整型)
         * 第二步把 0xFF 前補24個零：
         * 00000000 00000000 00000000 11111111
         * 第三步：把第一二步結果進行與位運算：
         * 00000000 00000000 00000000 11111110
         * 最後一步：轉十六進制結果爲 FE 
         */
        System.out.println(Integer.toHexString(negativeByte & 0xFF).toUpperCase());// FE        

        //另外一種轉換，能夠針對負數與正數的byte均可以以完整的單字節輸出
        System.out.println(Integer.toHexString((negativeByte & 0x000000ff) | 0xffffff00)
                .substring(6).toUpperCase());//FE
        System.out.println(Integer.toHexString((positiveByte & 0x000000ff) | 0xffffff00)
                .substring(6).toUpperCase());//02
    }

    /**
     * 位運算與算術運行中的類型提高機制是同樣的
     */
    public void testBiteMathematical() {
        System.out.println(0x8000000000000000L);//-9223372036854775808
        System.out.println((int) 0x8000000000000000L);//0
        System.out.println(0x8000000000000010L);//-9223372036854775792
        System.out.println(0x80000000);//-2147483648 
        System.out.println(0x80000010);//-2147483632 

        //0x00000010提高成長整型，最後結果爲長整型0x8000000000000010L
        System.out.println(0x00000010 | 0x8000000000000000L);//-9223372036854775792
        //0x0010提高成整形，最後結果爲整型0x80000010
        System.out.println(0x0010 | 0x80000000);//-2147483632 
    }
}