JAVA byte[]、十六進位制字串、整形(Long、int)資料型別之間的轉換

在程式設計中我們經常遇到資料型別之間的轉換,現在我們來總結一下,有更好的請大家共享指導：

• 十六進位制字串資料 轉 byte[]
• byte[] 轉 十六進位制字串
• byte[] 轉 int
• *int 轉 byte[]
• byte[] 轉 Long
• Long 轉 byte[]

十六進位制字串資料 轉 byte[]

    /**
     * 16進位制字串轉byte
     * @param strIn
     * @return
     * @throws Exception
     */
    public static byte[] hexStr2ByteArr(String strIn) {
        try
 
 {
            if (strIn==null)return null;
            byte[] arrB = strIn.getBytes();
            int iLen = arrB.length;
            byte[] arrOut = new byte[iLen/2];
            for (int i = 0; i < iLen; i = i + 2) {
                String strTmp = new String(arrB, i, 2);
                arrOut[i / 2
 
] = (byte) Integer.parseInt(strTmp, 16);
            }
            return arrOut;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

byte[] 轉 十六進位制字串

    /**
     * 16進位制的形式輸出
     * @param b
     * @return
     */
    public static String byte2HexStr
 
(byte[] b){    
        String stmp="";    
        StringBuilder sb = new StringBuilder("");    

        try {
            for (int n=0;n<b.length;n++)    
            {    
                stmp = Integer.toHexString(b[n] & 0xFF);    
                sb.append((stmp.length()==1)? "0"+stmp : stmp);    
                //sb.append(" ");    
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }   

        return sb.toString().toUpperCase().trim();    
    }

byte[] 轉 int

/**
     * byte裝成int
     * @param value
     * @return
     */
    public static int bytesToint(byte[] value) {
        int ret = 0;
        for (int i = 0; i < value.length; i++) {
            ret += (value[value.length - i - 1] & 0xFF) << (i * 8);
        }
        return ret;
    }

int 轉 byte[]

    /**
     * 轉成位元組長度
     * @param iSource 原資料
     * @param iArrayLen 輸出資料
     * 只能轉整形最多4個位元組
     * @return
     */
    public static byte[] toByteArray(int iSource, int iArrayLen) {
        byte[] bLocalArr = new byte[iArrayLen];
        for (int i = 0; (i < 4) && (i < iArrayLen); i++) {
            bLocalArr[i] = (byte) (iSource >> 8 * i & 0xFF);
        }
        byte temp;
        int len = bLocalArr.length;
        for (int i = 0; i < len / 2; i++) {
            temp = bLocalArr[i];
            bLocalArr[i] = bLocalArr[len - 1 - i];
            bLocalArr[len - 1 - i] = temp;
        }
        return bLocalArr;
    }

byte[] 轉 Long

     /**
     * byte[] 轉 Long
     * @return
     */
    public static long bytesToLong(byte[] value) {
        long ret = 0;
        for (int i = 0; i < value.length; i++) {
            ret += (long) (value[value.length - i - 1] & 0xFF) << (long) (i * 8);
        }
        return ret;
    }

Long 轉 byte[]

     /**
     * Long 轉 byte[]
     * @return
     */
    public static byte[] longTobytes(long val) {
        int length = 8;
        byte[] value = new byte[length];
        for (int i = 0; i < length; i++)
            value[length - i - 1] = (byte) (val >> i * 8);

        return value;
    }