Java 16進制相關的部分基礎操作方法

沒什麼特殊引用類，有需要的朋友（可能通訊用的多一點）可以單個方法自行拿過去使用；

另外推薦一個很厲害大神參與的開源項目，主要是包含一些常用的工具類，本菜鳥使用過部分方法，覺得很好用，用興趣的大佬可以去它 官網 詳細瞭解

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.3.5</version>
</dependency>

    /**
     * 求16進制數組和
     * @param hexdata
     * @return
     */
    public static String makeCheckSum(String hexdata) {
        if (hexdata == null || hexdata.equals("")) {
            return "00";
        }
        hexdata = hexdata.replaceAll(" ", "");
        int total = 0;
        int len = hexdata.length();
        if (len % 2 != 0) {
            return "00";
        }
        int num = 0;
        while (num < len) {
            String s = hexdata.substring(num, num + 2);
            total += Integer.parseInt(s, 16);
            num = num + 2;
        }
        return hexInt(total);
    }

    public static String hexInt(int total) {
        int a = total / 256;
        int b = total % 256;
        if (a > 255) {
            return hexInt(a) + format(b);
        }
        return format(a) + format(b);
    }

    public static String format(int dec) {
        String hexa = Integer.toHexString(dec);
        int len = hexa.length();
        if (len < 2) {
            hexa = "0" + hexa;
        }
        return hexa;
    }

    /**
     * 16進制字符串轉2進制字符串
     * @param hexStr
     * @return
     */
    public static String hexStringToBinary(String hexStr) {
        return Integer.toBinaryString(Integer.valueOf(hexStr, 16));
    }

    /**
     * 2進制字符串轉16進制字符串
     * @param binStr
     * @return
     */
    public static String binaryToHexString(String binStr) {
        if (binStr == null || binStr.equals("") || binStr.length() % 8 != 0)
            return null;
        StringBuffer tmp = new StringBuffer();
        int iTmp = 0;
        for (int i = 0; i < binStr.length(); i += 4) {
            iTmp = 0;
            for (int j = 0; j < 4; j++) {
                iTmp += Integer.parseInt(binStr.substring(i + j, i + j + 1)) << (4 - j - 1);
            }
            tmp.append(Integer.toHexString(iTmp));
        }
        return tmp.toString();
    }

    /**
     * 異或運算
     * @param anotherBinary 二進制後的值
     * @param thisBinary 二進制後的值
     * @return
     */
    public static String xor(String anotherBinary, String thisBinary) {
        String result = "";
        //判斷是否爲8位二進制，否則左補零
        anotherBinary = StringUtils.repairZero(anotherBinary, 8);
        thisBinary = StringUtils.repairZero(thisBinary, 8);
        //異或運算
        for (int i = 0; i < anotherBinary.length(); i++) {
            //如果相同位置數相同，則補0，否則補1
            if (thisBinary.charAt(i) == anotherBinary.charAt(i))
                result += "0";
            else {
                result += "1";
            }
        }
        return Integer.toHexString(Integer.parseInt(result, 2));
    }

    /**
     * 獲取16進制，低位在前高位在後的數據
     * @param var0
     * @return
     */
    public static String lowHigh(int var0, String splitStr) {
        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;
        }
        // 允許空格拼接
        if (splitStr != null) {
            return var5 + splitStr + var4;
        } else {
            return var5 + var4;
        }
    }