Hex转化工具

package com.jquery.service.android.utils;


import android.util.Log;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * 字符串与16进制转换工具
 * @param str
 */

public class HexUtils {
    private static final int[] DEC = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15};
    private static final byte[] HEX = new byte[]{48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102};
    private static final char[] hex = "0123456789abcdef".toCharArray();
    private static String TAG = "HexUtils";

    public HexUtils() {
    }

    public static int getDec(int index) {
        try {
            return DEC[index - 48];
        } catch (ArrayIndexOutOfBoundsException var2) {
            return -1;
        }
    }

    public static byte getHex(int index) {
        return HEX[index];
    }

    public static String hexString2BinaryString(String hexString) {
        if (hexString == null || hexString.length() % 2 != 0)
            return null;
        String bString = "", tmp;
        for (int i = 0; i < hexString.length(); i++) {
            tmp = "0000" + Integer.toBinaryString(Integer.parseInt(hexString.substring(i, i + 1), 16));
            bString += tmp.substring(tmp.length() - 4);
        }
        return bString;
    }


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

    public static String toHexString(byte[] bytes) {
        if (null == bytes) {
            return null;
        } else {
            StringBuilder sb = new StringBuilder(bytes.length << 1);

            for (int i = 0; i < bytes.length; ++i) {
                sb.append(hex[(bytes[i] & 240) >> 4]).append(hex[bytes[i] & 15]);
            }

            return sb.toString();
        }
    }

    public static byte[] fromHexString(String input) {
        if (input == null) {
            return null;
        } else if ((input.length() & 1) == 1) {
            throw new IllegalArgumentException("The input must consist of an even number of hex digits");
        } else {
            char[] inputChars = input.toCharArray();
            byte[] result = new byte[input.length() >> 1];

            for (int i = 0; i < result.length; ++i) {
                int upperNibble = getDec(inputChars[2 * i]);
                int lowerNibble = getDec(inputChars[2 * i + 1]);
                if (upperNibble < 0 || lowerNibble < 0) {
                    throw new IllegalArgumentException("The input must consist only of hex digits");
                }

                result[i] = (byte) ((upperNibble << 4) + lowerNibble);
            }

            return result;
        }
    }

    public static String decodeFromHexString(String hexString) {
        return new String(fromHexString(hexString));
    }

    /**
     * 高低位交换
     *
     * @param data           被交换数据，长度为switchUnitSize的整数倍
     * @param switchUnitSize 交换单元字节数，2的倍数
     * @return
     */
    public static byte[] byteHighLowSwitch(byte[] data, int switchUnitSize) {
        if (data == null || data.length < switchUnitSize
                || (switchUnitSize < 2 && switchUnitSize % 2 != 0)
                || data.length % switchUnitSize != 0)
            return null;
        int switchUnitNum = data.length / switchUnitSize;
        int byteLen = switchUnitSize / 2;
        byte[] result = new byte[data.length];
        for (int i = 0; i < switchUnitNum; i++) {
            for (int j = 0; j < byteLen; j++) {
                result[(i + 1) * switchUnitSize - byteLen * 2 + j] = data[(i + 1) * switchUnitSize - byteLen + j];
                result[(i + 1) * switchUnitSize - byteLen + j] = data[(i + 1) * switchUnitSize - byteLen * 2 + j];
            }
        }
        return result;
    }

    public static byte[] byteReverse(byte[] data) {
        if (data == null) {
            return null;
        }
        byte[] result = new byte[data.length];
        for (int i = 0; i < data.length; i++) {
            result[i] = data[data.length - i - 1];
        }
        return result;
    }

    /**
     * 字节数组转换为ASCII码
     *
     * @param b
     * @return
     */
    public static String byteToAscii(byte[] b) {

        String s = new String(b);

        char[] chars = s.toCharArray(); //把字符中转换为字符数组

        String temp = "";

        for (int i = 0; i < chars.length; i++) {//输出结果

            temp = temp + chars[i];
        }
        try {
            //temp = new String(temp.getBytes("utf-8"), "utf-8");
            String temps = changeCharset(temp, US_ASCII, UTF_8);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return temp;
    }

    public static final String US_ASCII = "US-ASCII";
    /**
     * 8 位 UCS 转换格式
     */
    public static final String UTF_8 = "UTF-8";

    /**
     * 将Ascii转换成中文字符串
     */
    /**
     * 字符串编码转换的实现方法
     *
     * @param str        待转换编码的字符串
     * @param newCharset 目标编码
     * @return
     * @throws UnsupportedEncodingException
     */
    public String changeCharset(String str, String newCharset)
            throws UnsupportedEncodingException {
        if (str != null) {
            //用默认字符编码解码字符串。
            byte[] bs = str.getBytes();
            //用新的字符编码生成字符串
            return new String(bs, newCharset);
        }
        return null;
    }

    /**
     * 字符串编码转换的实现方法
     *
     * @param str        待转换编码的字符串
     * @param oldCharset 原编码
     * @param newCharset 目标编码
     * @return
     * @throws UnsupportedEncodingException
     */
    public static String changeCharset(String str, String oldCharset, String newCharset)
            throws UnsupportedEncodingException {
        if (str != null) {
            //用旧的字符编码解码字符串。解码可能会出现异常。
            byte[] bs = str.getBytes(oldCharset);
            //用新的字符编码生成字符串
            return new String(bs, newCharset);
        }
        return null;
    }


    /**
     * AscII码转换为字节数组
     *
     * @param str
     * @return
     */
    public static byte[] asciiToByte(String str) {
        try {
            byte[] tBytes = str.getBytes("US-ASCII");
            return tBytes;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static boolean byteArrayCompare(byte[] b1, byte[] b2) {
        if (null == b1 || null == b2) {
            return false;
        } else if (b1.length != b2.length) {
            return false;
        } else {
            for (int i = 0; i < b1.length; i++) {
                if (b1[i] != b2[i]) {
                    return false;
                }
            }
            return true;
        }
    }


    public static String byteArray2HexString(byte[] b, boolean flag) {
        StringBuffer buffer = new StringBuffer();
        int temp = 0;

        for (int i = 0; i < b.length; i++) {
            if (b[i] < 0) {
                temp = 256 + b[i];
            } else {
                temp = b[i];
            }

            String ts = Integer.toHexString(temp);
            if (ts.length() == 1) {
                if (flag) {
                    buffer.append("0" + ts + " ");
                } else {
                    buffer.append("0" + ts);
                }
            } else {
                if (flag) {
                    buffer.append(ts + " ");
                } else {
                    buffer.append(ts);
                }
            }
        }
        return buffer.toString();
    }

    /**
     * 十六进制字符串->字节数组
     *
     * @param hexString
     * @return
     */
    public static byte[] hexStringTobyteArray(String hexString) {
        int length = hexString.length();
        if (length % 2 != 0) {
            hexString = "0" + hexString;
            length = hexString.length();
        }
        byte[] b = new byte[length / 2];

//        BigInteger bigInteger = new BigInteger(hexString, 16);
//        byte[] bytes = toByteArray(bigInteger);
//        Log.e(TAG,"十六进制字符串->字节数组转换:"+bigInteger);
//        bytes=new byte[length / 2];
//        for (int i = 0; i < length / 2; i++) {
//            bytes[i] = (byte) ((int) Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 16));
//        }

        for (int i = 0; i < length / 2; i++) {
            //  BigInteger bigInteger = new BigInteger(hexString.substring(2 * i, 2 * i + 2), 16);
//            b[i] = (byte) ((BigInteger) bigInteger);
            //   b[i] = (byte) ((BigInteger) bigInteger);
            // b[i] = fromBigInteger(bigInteger,  length / 2);
            b[i] = (byte) ((int) Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 16));
        }


        return b;
    }



    public static byte[] toByteArray(BigInteger bi) {
        byte[] array = bi.toByteArray();
//        if (array[0] == 0) {
//            byte[] tmp = new byte[array.length - 1];
//            System.arraycopy(array, 1, tmp, 0, tmp.length);
//            array = tmp;
//        }
        byte[] tmp = new byte[array.length - 1];
        System.arraycopy(array, 1, tmp, 0, tmp.length);
        array = tmp;
        return array;
    }

    /**
     * 去掉16进制字符串前面的0X
     *
     * @param hexString
     * @return
     */
    public static String remove0x(String hexString) {
        if (hexString.toUpperCase().startsWith("0X")) {
            hexString = hexString.substring(2);
        }
        return hexString;
    }



    /**
     * IEEE754
     *
     * @param a
     * @return
     */
    public static byte[] floatToBytes(float a) {
        byte[] data = new byte[4];
        if (a == 0) {
            for (int i = 0; i < 4; i++) {
                data[i] = 0x00;
            }
            return data;
        }
        Integer[] intdata = {0, 0, 0, 0};
        a = Math.abs(a);
        // 首先将浮点数转化为二进制浮点数
        float floatpart = a % 1;
        int intpart = (int) (a / 1);

        System.out.println(intpart + " " + floatpart);
        // 将整数部分化为2进制,并转化为string类型
        String intString = "";
        String floatString = "";
        String result = "";
        String subResult = "";
        int zhishu = 0;
        if (intpart == 0) {
            intString += "0";
        }
        while (intpart != 0) {
            intString = intpart % 2 + intString;
            intpart = intpart / 2;
        }
        while (floatpart != 0) {
            floatpart *= 2;
            if (floatpart >= 1) {
                floatString += "1";
                floatpart -= 1;
            } else {
                floatString += "0";
            }

        }

        result = intString + floatString;
        System.out.println(intString + "." + floatString);
        intpart = (int) (a / 1);
        if (intpart > 0) {// 整数部分肯定有1，且以1开头..这样的话，小数点左移
            zhishu = intString.length() - 1;
        } else {// 整数位为0，右移
            for (int i = 0; i < floatString.length(); i++) {
                zhishu--;
                if (floatString.charAt(i) == '1') {
                    break;
                }
            }
            // while(floatString.charAt(index)){}
        }
        // 对指数进行移码操作

        if (zhishu >= 0) {
            subResult = result.substring(intString.length() - zhishu);
        } else {
            subResult = floatString.substring(-zhishu);
        }
        zhishu += 127;
        if (subResult.length() <= 7) {// 若长度

            for (int i = 0; i < 7; i++) {
                if (i < subResult.length()) {
                    intdata[1] = intdata[1] * 2 + subResult.charAt(i) - '0';
                } else {
                    intdata[1] *= 2;
                }

            }

            if (zhishu % 2 == 1) {// 如果质数是奇数，则需要在这个最前面加上一个‘1’
                intdata[1] += 128;
            }
            data[1] = intdata[1].byteValue();
        } else if (subResult.length() <= 15) {// 长度在（7,15）以内
            int i = 0;
            for (i = 0; i < 7; i++) {// 计算0-7位，最后加上第一位
                intdata[1] = intdata[1] * 2 + subResult.charAt(i) - '0';
            }
            if (zhishu % 2 == 1) {// 如果质数是奇数，则需要在这个最前面加上一个‘1’
                intdata[1] += 128;
            }
            data[1] = intdata[1].byteValue();

            for (i = 7; i < 15; i++) {// 计算8-15位
                if (i < subResult.length()) {
                    intdata[2] = intdata[2] * 2 + subResult.charAt(i) - '0';
                } else {
                    intdata[2] *= 2;
                }

            }
            data[2] = intdata[2].byteValue();
        } else {// 长度大于15
            int i = 0;
            for (i = 0; i < 7; i++) {// 计算0-7位，最后加上第一位
                intdata[1] = intdata[1] * 2 + subResult.charAt(i) - '0';
            }
            if (zhishu % 2 == 1) {// 如果质数是奇数，则需要在这个最前面加上一个‘1’
                intdata[1] += 128;
            }
            data[1] = intdata[1].byteValue();

            for (i = 7; i < 15; i++) {// 计算8-15位
                intdata[2] = intdata[2] * 2 + subResult.charAt(i) - '0';
            }
            data[2] = intdata[2].byteValue();

            for (i = 15; i < 23; i++) {// 计算8-15位
                if (i < subResult.length()) {
                    intdata[3] = intdata[3] * 2 + subResult.charAt(i) - '0';
                } else {
                    intdata[3] *= 2;
                }

            }
            data[3] = intdata[3].byteValue();
        }

        intdata[0] = zhishu / 2;
        if (a < 0) {
            intdata[0] += 128;
        }
        data[0] = intdata[0].byteValue();
        byte[] data2 = new byte[4];// 将数据转移，目的是倒换顺序
        for (int i = 0; i < 4; i++) {
            data2[i] = data[3 - i];
        }
        return data2;
    }

 /*   public static String ipV4(byte[] b) {
        String ip = "";
        for (int i = 0; i < b.length; i++) {
            int temp = 0;
            if (b[i] < 0)
                temp = 256 + b[i];
            else
                temp = b[i];
            ip = ip + temp + ".";
        }
        if (StringUtils.isNotBlank(ip)) {
            ip = ip.substring(0, ip.length() - 1);
        }
        return ip;
    }*/

    /**
     * Short Int转byte[]
     *
     * @param s
     * @return
     */
    public static byte[] shortToByteArray(short s) {
        byte[] shortBuf = new byte[2];
        for (int i = 0; i < 2; i++) {
            int offset = (shortBuf.length - 1 - i) * 8;
            shortBuf[i] = (byte) ((s >>> offset) & 0xFF);
        }
        return shortBuf;
    }

    /**
     * byte[]转Short Int
     *
     * @param b
     * @return
     */
    public static int byteArrayToShort(byte[] b) {
        return (b[0] << 8)
                + (b[1] & 0xFF);
    }

    /**
     * Object转double
     *
     * @param sma
     * @return
     */
    public static double objToDouble(Object sma) {
        double amount = 0.0;
        if (sma instanceof Integer) {
            amount = (Integer) sma / 1.0;
        } else if (sma instanceof String) {
            amount = Double.parseDouble((String) sma);
        } else {
            amount = (double) sma;
        }
        return amount;
    }

    /**
     * int转byte[]
     *
     * @param n
     * @return
     */
    public static byte[] intToBytes2(int n) {
        byte[] b = new byte[4];

        for (int i = 0; i < 4; i++) {
            b[i] = (byte) (n >> (24 - i * 8));

        }
        return b;
    }

    /**
     * byte[]转int
     *
     * @param b
     * @return
     */
    public static int byteToInt2(byte[] b) {
        int mask = 0xff;
        int temp = 0;
        int n = 0;
        for (int i = 0; i < b.length; i++) {
            n <<= 8;
            temp = b[i] & mask;
            n |= temp;
        }
        return n;
    }

    /**
     * int 转 hex ,高位在前
     *
     * @param inn int
     * @return hex
     */
    public static String IntToHexReversed(int inn) {
        return toHexString(byteReverse(intToBytes2(inn)));

    }

    /**
     * int 转 hex ,高位在前
     *
     * @param inn int
     * @return hex
     */
    public static String intToHex(int inn) {
        return toHexString(intToBytes2(inn));

    }

    /**
     * short 转 hex ,高位在前
     *
     * @param inn int
     * @return hex
     */
    public static String shortToHex(short inn) {
        return toHexString(shortToByteArray(inn));

    }

    /**
     * int 转 hex ,高位在前
     *
     * @param hex hex
     * @return ascii2 string
     */
    public static String hexString2Ascii(String hex) {

        return byteToAscii(hexStringTobyteArray(hex));
    }

    /**
     * ascii 转 hex ,高位在前
     *
     * @param asciiStr String
     * @return hex string
     */
    public static String asciiToHex(String asciiStr) {
        char[] chars = asciiStr.toCharArray();
        StringBuilder hex = new StringBuilder();
        for (char ch : chars) {
            hex.append(Integer.toHexString((int) ch));
        }
        return hex.toString();
    }


    /**
     * 将BCD码转成String
     *
     * @param b byte []
     * @return
     */
    public static String bcdToString(byte[] b) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < b.length; i++) {
            int h = ((b[i] & 0xff) >> 4) + 48;
            sb.append((char) h);
            int l = (b[i] & 0x0f) + 48;
            sb.append((char) l);
        }

        return sb.toString();
    }


    /**
     * @功能: BCD码转为10进制串(阿拉伯数据)
     * @参数: BCD码
     * @结果: 10进制串
     */
    public static String bcd2Str(byte[] bytes) {
        StringBuffer temp = new StringBuffer(bytes.length * 2);
        for (int i = 0; i < bytes.length; i++) {
            temp.append((byte) ((bytes[i] & 0xf0) >>> 4));
            temp.append((byte) (bytes[i] & 0x0f));
        }
        return temp.toString().substring(0, 1).equalsIgnoreCase("0") ? temp
                .toString().substring(1) : temp.toString();
    }

    public static short BcdToHex(short data) {
        short temp;

        temp = (short) ((data >> 4) * 10 + (data & 0x0f));
        return temp;
    }



    /**
     * 字符串转换为16进制字符串
     *
     * @param s
     * @return
     */
    public static String stringToHexString(String s) {
        String str = "";
        for (int i = 0; i < s.length(); i++) {
            int ch = (int) s.charAt(i);
            String s4 = Integer.toHexString(ch);
            str = str + s4;
        }
        return str;
    }

    /**
     * 16进制字符串转换为字符串
     *
     * @param s
     * @return
     */
    public static String hexStringToString(String s) {
        if (s == null || s.equals("")) {
            return null;
        }
        s = s.replace(" ", "");
        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, "gbk");
            new String();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return s;
    }

    public static String rev(String ox) {
        String s = ox.substring(2);
        byte b[] = s.getBytes();
        byte result[] = new byte[b.length];
        for (int i = b.length - 1, j = 0; i >= 0; i--, j++)
            result[j] = b[i];
        return new String(result);
    }

    /**
     * 10进制转16进制高位在前地位在后
     *
     * @param var0
     * @return
     */
    public static String lowHigh(int var0) {
        int var1 = 1;
        int var2 = var0 >> 8;
        int var3 = var0 & 255;
        String var4 = Integer.toHexString(var2);
        String var5 = Integer.toHexString(var3);
        if (var4.length() > 2) {
            do {
                if (var1 > 1) {
                    var2 >>= 8;
                }
                var4 = Integer.toHexString(var2 >> 8);
                var5 = var5 + Integer.toHexString(var2 & 255);
                ++var1;
            } while (var4.length() > 2);
        }
        if (var4.length() < 2) {
            var4 = "0" + var4;
        }
        if (var5.length() < 2) {
            var5 = "0" + var5;
        }
        return var5 + var4;
    }


    /**
     * 10进制的数转换为16进制字节，并高位在前，低位在后
     *
     * @param dec
     * @return
     */
    public static String decToHex(int dec) {
        String hex = "";
        while (dec != 0) {
            String h = Integer.toString(dec & 0xff, 16);
            if ((h.length() & 0x01) == 1) {
                h = '0' + h;
            }
            hex = hex + h;
            dec = dec >> 8;
        }
        return hex;
    }

    /**
     * 10进制的数转换为16进制字节，并高位在前，低位在后
     *
     * @param dec
     * @return
     */
    public static String decLongToHex(long dec) {
        String hex = "";
        while (dec != 0) {
            String h = Long.toString(dec & 0xff, 16);
            if ((h.length() & 0x01) == 1) {
                h = '0' + h;
            }
            hex = hex + h;
            dec = dec >> 8;
        }
        return hex;
    }

    public void test(String ox) {

        String temp = "94 01 00 00 60 10";
        List<String> list = Arrays.asList(ox.split(""));
        Collections.reverse(list);

        StringBuffer stringBuffer = new StringBuffer();
        for (String string : list) {
            stringBuffer.append(string);
            stringBuffer.append(" ");
        }
        temp = stringBuffer.toString();
        System.out.println(temp);//10 60 00 00 01 94

    }

    /**
     * 十六进制字符串转换成字符串
     *
     * @param hexStr
     * @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);
    }

    /**
     * 16进制转 字符串 低字节在前，高字节在后
     *
     * @param str
     * @return
     */
    public static String reverse(String str) {
        int length = str.length();
        if ((length & 1) == 1) {
            str = "0" + str;
            length = str.length();
        }
        String string = "";
        for (int i = length / 2 - 1; i >= 0; i--) {
            string += str.substring(2 * i, 2 * i + 2);
        }
        return string;
    }


    /**
     * long 转 hex ,高位在前
     *
     * @param inn int
     * @return hex
     */
    public static String LongToHexReversed(Long inn) {
        return toHexString(byteReverse(longToBytes2(inn)));

    }


    /**
     * long 转 hex ,高位在前
     *
     * @param inn int
     * @return hex
     */
    public static String longToHex(Long inn) {
        return toHexString(longToBytes2(inn));

    }

    /**
     * long转byte[]
     *
     * @param n
     * @return
     */
    public static byte[] longToBytes2(Long n) {
        byte[] b = new byte[4];

        for (int i = 0; i < 4; i++) {
            b[i] = (byte) (n >> (24 - i * 8));

        }
        return b;
    }

    /**
     * 十六进制字符串->字节数组
     *
     * @param hexString
     * @return
     */
    public static byte[] hexString2byteArray(String hexString) {
        int length = hexString.length();

        byte[] b = new byte[length / 2];

        for (int i = 0; i < length / 2; i++) {
            b[i] = (byte) ((int) Integer.valueOf(hexString.substring(2 * i,
                    2 * i + 2), 16));
        }

        return b;
    }

    /**
     * 16进制转10进制
     *
     * @param bytes
     * @return
     */
    public static String bytes2hex03(byte[] bytes) {
        final String HEX = "0123456789abcdef";
        StringBuilder sb = new StringBuilder(bytes.length * 2);
        for (byte b : bytes) {
            sb.append(HEX.charAt((b >> 4) & 0x0f));
            sb.append(HEX.charAt(b & 0x0f));
        }

        return sb.toString();
    }


    /**
     * 10进制转16进制
     *
     * @param num
     * @param totalLenght 需要的字符串总长度
     * @return
     */
    public String toHex(int num, int totalLenght) {
        String str = Integer.toHexString(num);
        str = splicingZero(str, totalLenght);
        return str;
    }

    public static String toHex(long num, int totalLenght) {
        String str = Long.toHexString(num);
        str = splicingZero(str, totalLenght);
        return str;
    }

    /**
     * 字符串前面补零操作
     *
     * @param str         字符串本体
     * @param totalLenght 需要的字符串总长度
     * @return
     */
    public static String splicingZero(String str, int totalLenght) {
        int strLenght = str.length();
        String strReturn = str;
        for (int i = 0; i < totalLenght - strLenght; i++) {
            strReturn = "0" + strReturn;
        }
        return strReturn;
    }


    /**
     * byte[]转十六进制
     *
     * @param bytes
     * @return
     */
    public String bytesTohex(byte[] bytes) {
        StringBuilder hex = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            byte b = bytes[i];
            boolean flag = false;
            if (b < 0) {
                flag = true;
            }
            int absB = Math.abs(b);
            if (flag) {
                absB = absB | 0x80;
            }
            System.out.println(absB & 0xFF);
            String tmp = Integer.toHexString(absB & 0xFF);
            if (tmp.length() == 1) { //转化的十六进制不足两位，需要补0
                hex.append("0");
            }
            hex.append(tmp.toLowerCase());
        }
        return hex.toString();
    }

    /**
     * 十六进制转byte[]
     *
     * @param hex
     * @return
     */
    public static byte[] hexTobytes(String hex) {
        byte[] bytes = new byte[hex.length() / 2];
        for (int i = 0; i < hex.length(); i = i + 2) {
            String subStr = hex.substring(i, i + 2);
            boolean flag = false;
            int intH = Integer.parseInt(subStr, 16);
            if (intH > 127) {
                flag = true;
            }
            if (intH == 128) {
                intH = -128;
            } else if (flag) {
                intH = 0 - (intH & 0x7F);
            }
            byte b = (byte) intH;
            bytes[i / 2] = b;
        }
        return bytes;
    }

    //10进制转16进制
    public static String IntToHex(long n) {
        char[] ch = new char[20];
        int nIndex = 0;
        while (true) {
            long m = n / 16;
            long k = n % 16;
            if (k == 15) {
                ch[nIndex] = 'f';
            } else if (k == 14) {
                ch[nIndex] = 'e';
            } else if (k == 13) {
                ch[nIndex] = 'd';
            } else if (k == 12) {
                ch[nIndex] = 'c';
            } else if (k == 11) {
                ch[nIndex] = 'b';
            } else if (k == 10) {
                ch[nIndex] = 'a';
            } else {
                ch[nIndex] = (char) ('0' + k);
            }
            nIndex++;
            if (m == 0) {
                break;
            }
            n = m;
        }
        StringBuffer sb = new StringBuffer();
        sb.append(ch, 0, nIndex);
        sb.reverse();
        String strHex = new String("0x");
        strHex += sb.toString();
        return strHex;
    }

    //16进制转10进制
    public static Long HexToInt(String strHex) {
        long nResult = 0;
        if (!IsHex(strHex)) {
            return nResult;
        }
        String str = strHex.toUpperCase();
        if (str.length() > 2) {
            if (str.charAt(0) == '0' && str.charAt(1) == 'X') {
                str = str.substring(2);
            }
        }
        int nLen = str.length();
        for (int i = 0; i < nLen; ++i) {
            char ch = str.charAt(nLen - i - 1);
            try {
                nResult += (GetHex(ch) * GetPower(16, i));
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return nResult;
    }

    //计算16进制对应的数值
    public static int GetHex(char ch) throws Exception {
        if (ch >= '0' && ch <= '9') {
            return (int) (ch - '0');
        }
        if (ch >= 'a' && ch <= 'f') {
            return (int) (ch - 'a' + 10);
        }
        if (ch >= 'A' && ch <= 'F') {
            return (int) (ch - 'A' + 10);
        }
        throw new Exception("error param");
    }

    //计算幂
    public static long GetPower(long nValue, long nCount) throws Exception {
        if (nCount < 0) {
            throw new Exception("nCount can't small than 1!");
        }
        if (nCount == 0) {
            return 1;
        }
        long nSum = 1;
        for (long i = 0; i < nCount; ++i) {
            nSum = nSum * nValue;
        }
        return nSum;
    }

    //判断是否是16进制数
    public static boolean IsHex(String strHex) {
        int i = 0;
        if (strHex.length() > 2) {
            if (strHex.charAt(0) == '0' && (strHex.charAt(1) == 'X' || strHex.charAt(1) == 'x')) {
                i = 2;
            }
        }
        for (; i < strHex.length(); ++i) {
            char ch = strHex.charAt(i);
            if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) {
                continue;
            }
            return false;
        }
        return true;
    }

    /**
     *      * 十六进制字符串校验(不够4个长度补齐0)
     *      * @param lockAddress
     *      * @return
     *      
     */
    public static String checkValidityHex(String hex, int hexLengh) {

        StringBuffer s1 = new StringBuffer(hex);
        int index;
        for (index = 2; index < s1.length(); index += 3) {
            s1.insert(index, ',');
        }
        String[] array = s1.toString().split(",");
        String[] swapOrder = (array);
        StringBuffer s2 = new StringBuffer();
        for (String str : swapOrder) {
            s2.append(str);
        }
        String s3 = s2.toString();
        if (s3.length() != 4 || s3.length() != 8) {
            int count = (hexLengh - s3.length());
            for (int i = 0; i < count; i++) {
                s3 = "0" + s3;
            }
        }
        return s3;

    }

    public int hexToIntArraged(String workVolumeDose) {
        byte[] workVolumeArray = hexStringTobyteArray(workVolumeDose);
        return byteToInt2(byteReverse(workVolumeArray));
    }

//    public int hexToIntArraged( String data) {
//        byte[] byteDataArray = HexUtils.hexStringTobyteArray(data);
//        return HexUtils.byteToInt2(byteReverse(byteDataArray));
//    }


    /**
     * 16进制高低位转换（低位在前高位在后） reverseHighToLowHex
     *
     * @param hex
     * @return
     */

    public static String reverseHighToLowHex(final String hex) {
        final char[] charArray = hex.toCharArray();
        final int length = charArray.length;
        final int times = length / 2;
        for (int c1i = 0; c1i < times; c1i += 2) {
            final int c2i = c1i + 1;
            final char c1 = charArray[c1i];
            final char c2 = charArray[c2i];
            final int c3i = length - c1i - 2;
            final int c4i = length - c1i - 1;
            charArray[c1i] = charArray[c3i];
            charArray[c2i] = charArray[c4i];
            charArray[c3i] = c1;
            charArray[c4i] = c2;
        }
        return new String(charArray);
    }

    /**
     * 16进制高低位转换（高位在前低位在后） reverseLowToHighHex
     *
     * @param hex
     * @return
     */
    public static String reverseLowToHighHex(final String hex) {
        final char[] charArray = hex.toCharArray();
        final int length = charArray.length;
        final int times = length / 2;
        for (int c1i = 0; c1i < times; c1i += 2) {
            final int c2i = c1i + 1;
            final char c1 = charArray[c1i];
            final char c2 = charArray[c2i];
            final int c3i = length - c1i - 2;
            final int c4i = length - c1i - 1;
//            charArray[c1i] = charArray[c3i];
//            charArray[c2i] = charArray[c4i];
//            charArray[c3i] = c2;
//            charArray[c4i] = c1;


            charArray[c4i] = charArray[c3i];
            charArray[c3i] = charArray[c4i];
            charArray[c2i] = c1;
            charArray[c1i] = c2;
        }
        return new String(charArray);
    }

    public static String lowHigh2(int var0) {
        int var1 = 1;
        int var2 = var0 >> 8;
        int var3 = var0 & 255;
        String var4 = Integer.toHexString(var2);
        String var5 = Integer.toHexString(var3);
        if (var4.length() > 2) {
            do {
                if (var1 > 1) {
                    var2 >>= 8;
                }
                var4 = Integer.toHexString(var2 >> 8);
                var5 = var5 + Integer.toHexString(var2 & 255);
                ++var1;
            } while (var4.length() > 2);
        }
        if (var4.length() < 2) {
            var4 = "0" + var4;
        }
        if (var5.length() < 2) {
            var5 = "0" + var5;
        }
        return var5 + var4;
    }

    /**
     * 数字参数返回(4字节、8字节都适用)
     *
     * @param hex
     * @return
     */
    public static int getHexDataToInt(String hex) {
        int digit = -1;
        int a;
        BigInteger bi;
        int length = hex.length();
        if (length == 4) {
            String str = hex.substring(2, 3);
            BigInteger data = new BigInteger(str, 16);
            digit = data.intValue();
        }

        String reverseLowToHighHex = reverseHighToLowHex(hex);
        if (length == 4 && digit >= 8) {
            //16进制转10进制
            bi = new BigInteger("ffff" + reverseLowToHighHex, 16);
        } else {
            //16进制转10进制
            bi = new BigInteger(reverseLowToHighHex, 16);
        }
        a = bi.intValue();
        return a;
    }

    /**
     * 设置数字参数
     *
     * @param num           数字
     * @param lenght        hex 长度  4或是8
     * @param magnification 放大倍数
     * @return
     */
    public static String setHexData(int num, int lenght, int magnification) {

        BigDecimal result = (new BigDecimal(num));
        BigDecimal results = result.multiply(BigDecimal.valueOf(magnification));
        Log.e(TAG, "setHexData results !=   " + results);

        //10进制转16进制
        String hex2 = Integer.toHexString((results.intValue()));
        Log.e(TAG, "setHexData hex2 !=   " + hex2);

        String checkValidityHex = checkValidityHex(hex2, lenght);
        Log.e(TAG, "setHexData checkValidityHex !=   " + checkValidityHex);
        if (checkValidityHex.length() > lenght) {
            checkValidityHex = checkValidityHex.substring(lenght);
        }
        String reverseHighToLowHex = reverseHighToLowHex(checkValidityHex);

        Log.e(TAG, "setHexData reverseHighToLowHex !=   " + reverseHighToLowHex);

        String data = "";
        if (lenght == 8) {
            int len = 8 - reverseHighToLowHex.length();
            for (int i = 0; i < len; i++) {
                reverseHighToLowHex += "0";
            }
        }
        return reverseHighToLowHex;
    }

    /**
     * 整数Hex设置
     *
     * @param portResult
     * @param magnification
     * @return
     */

    public static String setHexDataResult(String portResult, int magnification) {
        String data = "";
        data = HexUtils.decToHex(Integer.parseInt(portResult) * magnification);
        int len = 8 - portResult.length();
        for (int i = 0; i < len; i++) {
            data += "0";
        }
        return data;
    }

    /**
     * 强制转化成BigDecimal保证精度
     *
     * @param num           数字字符串
     * @param magnification 1*100的倍数
     * @return
     */

    public static BigDecimal setBigDecimal(String num, int magnification) {
        BigDecimal result = (new BigDecimal(num));
        Log.e(TAG, "results setBigDecimal !=   " + result);
        BigDecimal results = result.multiply(BigDecimal.valueOf(magnification));
        return results;
    }

}