16进制转10进制负值问题解决方案

java 16进制转10进制时，直接转正值没有问题，负值会转出一个很大的值，本来应该是-5，转出的结果可能会是65286这样的值，针对这个问题，在网上各种查询得到的方法试过都不对，最终结合案例和自己的笨办法得到的结果是对的，代码如下：

Float value = 0f;
String converHexStr = "FF5E";//16进制字符串
String decStr = HexadecimalUtils.hexToDecStr(converHexStr);//直接转10进制
value = Float.parseFloat(decStr);
if(value >= 32768){
    //此处为负值，需要十六进制转二进制、取反、末尾补位，在转回16进制，在转10进制
    decStr = HexadecimalUtils.negativeHexToDecStr(converHexStr);
    value = Float.parseFloat(decStr);
    value = value * (-1);
}

public class HexadecimalUtils {

    /**
     * 十六进制数据转换为十进制字符串数
     *
     * @param hex
     * @return
     */
    public static String hexToDecStr(String hex) {
        BigInteger data = new BigInteger(hex,16);
        return data.toString(10);
    }

     /**
     * 十六进制数据转换为十进制字符串数 负值
     *
     * @param hex
     * @return
     */
    public static String negativeHexToDecStr(String hex) {
        //1.16进制转2进制
        String bytes = HexadecimalUtils.hexStr2byte(hex);
        //2. 取反
        String byteStr = HexadecimalUtils.reverseByte(bytes);
        //3. 末位加一
        String byteS = HexadecimalUtils.byteEndAdd1(byteStr);
        //二进制转十六进制
        String hexStr = HexadecimalUtils.binaryString2hexString(byteS);
        //十六进制转十进制
        String decStr = HexadecimalUtils.hexToDecStr(hexStr);
        return decStr;//翻转返回
    }

    /**
     * @description TODO
     * 十六进制字符串转二进制字符串
     */
    public static String hexStr2byte(String hex){
        StringBuffer sbuf = new StringBuffer();
        for(int i = 0; i < hex.length(); i++){
            String bin = Integer.toBinaryString(Integer.parseInt(hex.substring(i,i+1),16));
            if(i > 0){
                bin = "0000" + bin;
                bin=bin.substring(bin.length()-4);
            }
            sbuf.append(bin);
        }
        return sbuf.toString();
    }

    /**
     * @description TODO
     * 二进制字节数组取反
     */
    public static String reverseByte(String bytestr){
        byte[] bytes = HexadecimalUtils.byteStr2byte(bytestr);
        String byteRever = "";
        for(int i = 0; i < bytes.length; i++){
            if(bytes[i] == 0){
                byteRever += "1";
            }else{
                byteRever += "0";
            }
        }
        return byteRever;
    }

    /**
     * @description TODO
     * 二进制末位加一
     */
    public static String byteEndAdd1(String byteStr){
        byte[] bytes = HexadecimalUtils.byteStr2byte(byteStr);
        String byteS = "";
        boolean end = false;
        for(int i = bytes.length - 1; i >= 0; i--){
            if(!end){
                if(bytes[i] + 1 == 2){
                    byteS = "0" + byteS;
                }else {
                    byteS = "1" + byteS;
                    end = true;
                }
            }else{
                byteS = bytes[i] + byteS;
            }
        }
        return byteS;
    }


    /**
     * @description TODO
     * 二进制字符串转16进制字符串
     */
    public static String binaryString2hexString(String bString) {
        if (bString == null || bString.equals("") || bString.length() % 8 != 0)
            return null;
        StringBuffer tmp=new StringBuffer();
        int iTmp = 0;
        for (int i = 0; i < bString.length(); i += 4) {
            iTmp = 0;
            for (int j = 0; j < 4; j++) {
                iTmp += Integer.parseInt(bString.substring(i + j, i + j + 1)) << (4 - j - 1);
            }
            tmp.append(Integer.toHexString(iTmp));
        }
        return tmp.toString();
    }

    /**
     * 16进制字符串转为16进制字节数组
     * @param hex 16进制的字符串
     * @return
     */
    public static byte[] hexStringToHexBytes(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;
        }
    }

    /**
     * @description TODO
     * 16进制字节数组转浮点
     */
    public static Float byte2float(byte[] b, int index) {
        int l;
        l = b[index + 0];
        l &= 0xff;
        l |= ((long) b[index + 1] << 8);
        l &= 0xffff;
        l |= ((long) b[index + 2] << 16);
        l &= 0xffffff;
        l |= ((long) b[index + 3] << 24);
        return Float.intBitsToFloat(l);
    }


}

再记录一条踩过的坑，16进制转浮点的方法：

// 16进制字符串转16进制字节数组
byte[] b = HexadecimalUtils.hexStringToHexBytes(converHexStr);
// 16 进制字节数组转浮点
float value = HexadecimalUtils.byte2float(b,0);

调用方法见上面工具类。