Java实现进制之间转换的工具类

自己日常开发时遇到此类进制数据转换问题，总是要google回顾一下，麻烦又挺浪费时间的（我这人比较懒，哈哈哈哈~），所以临时起意，总结归纳一下进制之间互转换的方法，方便以后开发查找；
目前归纳的转换方法并不多，以后会继续补充更新！
不多啰嗦，代码如下：

package com.sbp.util;

import java.math.BigInteger;


/*import org.junit.Test;*/

/**
 * @Description 数据格式处理、转换
 * @author Liangjw
 * @date: 2021年3月13日 下午2:07:23
 * @version 1.0
 */
public class DataTransform {

    /**
     * 将十六进制的字符串转换成字节数组
     * @param hexString
     * @return
     */
    public static byte[] hexStrToBinaryStr(String hexString) {
        if (hexString == null || "".equals(hexString)) {
            return null;
        }
        hexString = hexString.replaceAll(" ", "");
 
        int len = hexString.length();
        int index = 0;
 
        byte[] bytes = new byte[len / 2];
 
        while (index < len) {
            String sub = hexString.substring(index, index + 2);
            bytes[index/2] = (byte)Integer.parseInt(sub,16);
            index += 2;
        }
        return bytes;
    }
    
    /**
    * @function 将16进制的字符串转换为16进制int数组
    * @author Liangjw
    * @time 2021年4月8日16:53:45
    * @param hexString 16进制的字符串
    * @return 返回int数组
    */
    public static int[] hexStrToHexIntArray(String hexString) {
        hexString = hexString.replace(" ", "");
        // 如果长度不是偶数，就在后面添加空格
        if ((hexString.length() % 2) != 0) {
            hexString += " ";
        }
        // 定义一个数组,长度是待转换数组长度的一半
        int[] returnBytes = new int[hexString.length() / 2];
        for (int i = 0; i < returnBytes.length; i++) {
            returnBytes[i] = (0xff & Integer.parseInt(hexString.substring(i * 2, i * 2 + 2), 16));
        }
        return returnBytes;
    }
    
    /**
     * 将字节数组转换成十六进制的字符串
     * @return
     */
    public static String binaryToHexString(byte[] bytes) {
        String hexStr = "0123456789ABCDEF";
        String result = "";
        String hex = "";
        for (byte b : bytes) {
            hex = String.valueOf(hexStr.charAt((b & 0xF0) >> 4));
            hex += String.valueOf(hexStr.charAt(b & 0x0F));
            result += hex + " ";
        }
        return result;
    }
    
    /**
     * @function 将十六进制的字符串转换成二进制的字符串
     * @author Liangjw
     * @time 2021年4月1日17:38:36
     * @param hexString 16进制字符串
     * @return  4位二进制字符串
     */
    public static String hexStrToBinaryStr2(String hexString) {
 
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        StringBuffer sb = new StringBuffer();
        // 将每一个十六进制字符分别转换成一个四位的二进制字符
        for (int i = 0; i < hexString.length(); i++) {
            String indexStr = hexString.substring(i, i + 1);
            String binaryStr = Integer.toBinaryString(Integer.parseInt(indexStr, 16));
            while (binaryStr.length() < 4) {
                binaryStr = "0" + binaryStr;
            }
            sb.append(binaryStr);
        }
        return sb.toString();
    }
    
    /**
     * @function 二进制字符串转换为十六进制字符串
     * @author Liangjw
     * @time 2021年4月1日17:39:34
     * 二进制字符串位数必须满足是4的倍数
     * 
     * @param binaryStr 四位的二进制字符串
     * @return 一位的十六进制字符串
     */
    public static String binaryStrToHexStr(String binaryStr) {
 
        if (binaryStr == null || binaryStr.equals("") || binaryStr.length() % 4 != 0) {
            return null;
        }
 
        StringBuffer sbs = new StringBuffer();
        // 二进制字符串是4的倍数，所以四位二进制转换成一位十六进制
        for (int i = 0; i < binaryStr.length() / 4; i++) {
            String subStr = binaryStr.substring(i * 4, i * 4 + 4);
            String hexStr = Integer.toHexString(Integer.parseInt(subStr, 2));
            sbs.append(hexStr);
        }
 
        return sbs.toString();
    }
    
    /**
     * @function 十六进制转负数
     * @author Liangjw
     * @time 2021年4月8日17:16:48
     * @param num
     */
    public static String parseHex8(String num) {
        if (num.length() != 8) {
            throw new NumberFormatException("Wrong length: " + num.length() + ", must be 4.");
        }
        BigInteger in = new BigInteger(num,16);
        double in2 = in.doubleValue();
        return in2+"";
    }
    
    /**
     * @function 整数二进制相加
     * @author Liangjw
     * @time 2021年4月8日17:17:39
     * @param b1
     * @param b2
     */
    public static String add(String b1, String b2) {
          int len1 = b1.length();
          int len2 = b2.length();
          String s1 = b1;
          String s2 = b2;
          StringBuffer sb1 = new StringBuffer();
          //先将位数较少的二进制高位补零
          if(len1 > len2) {
              for(int i = 0; i < (len1 - len2); i++) {
                  sb1.append(0);
              }
              sb1.append(b2);
              s1 = b1;
              s2 = sb1.toString();
          } else if(len1 < len2) {
              for(int j = 0; j < (len2 - len1); j++) {
                  sb1.append(0);
              }
              sb1.append(b1);
              s1 = sb1.toString();
              s2 = b2;
          }
          //进位
          int flag = 0;
          StringBuffer sb2 = new StringBuffer();
          for(int z = s1.length() - 1; z >= 0; z--) {
              //字符’0’的对应的ASCII十进制是48
              //分情况判断
              if((s1.charAt(z) - 48) == 0 && (s2.charAt(z) - 48) == 0) {
                  sb2.append(flag);
                  flag = 0;
                  continue;
              }
              if(((s1.charAt(z) - 48) == 0 && (s2.charAt(z) - 48) == 1 && flag == 0) || ((s1.charAt(z) - 48) == 1 && (s2.charAt(z) - 48) == 0 && flag == 0)) {
                  sb2.append(1);
                  flag = 0;
                  continue;
              }
              if(((s1.charAt(z) - 48) == 0 && (s2.charAt(z) - 48) == 1 && flag == 1) || ((s1.charAt(z) - 48) == 1 && (s2.charAt(z) - 48) == 0 && flag == 1)) {
                  sb2.append(0);
                  flag = 1;
                  continue;
              }
              if((s1.charAt(z) - 48) == 1 && (s2.charAt(z) - 48) == 1 && flag == 0) {
                  sb2.append(0);
                  flag = 1;
                  continue;
              }
              if((s1.charAt(z) - 48) == 1 && (s2.charAt(z) - 48) == 1 && flag == 1) {
                  sb2.append(1);
                  flag = 1;
              }
              
          }
          if(flag == 1) {
              sb2.append(flag);
          }
          //倒置
          sb2.reverse();
          return sb2.toString();
          
      }
    
    /**
      * 
      * @function 除首位（符号位）之外，二进制取反
      * 注：函数实现过程，如果是负数，则先把符号位转为0，当做正数处理
      * @author Liangjw
      * @date 2021年4月2日下午6:42:18  
      * @param hex2
      * @return
      * String
     */
    public static String reverseHex2(String hex2) {
        //除了符号位，其余取反
        String hex2_firstChar = hex2.substring(0, 1);
        if("1".equals(hex2_firstChar)) { //如果符号位为1，表示是负数，那么先把符号位转为0，当做正数处理，注：后台返回值时在前面加上“-”负号便可
            hex2_firstChar = "0";
        }
        hex2 = hex2.substring(1,hex2.length());
        String hex2_temp = "";
        for (int i = 0; i < hex2.length(); i++) {
            if('0' == hex2.charAt(i)) {
                hex2_temp = hex2_temp + "1";
            }else {
                hex2_temp = hex2_temp + "0";
            }
        }
        return hex2_firstChar + hex2_temp;//返回：符号位+其余取反位
    }    
    
    /*@Test
    public static void main(String[] args) {
        String opera = DataTransform.hexStrToBinaryStr2("FF1DE66C".substring(0, 1)).substring(0, 1);
        System.out.println("二进制字符首位字符：" + opera);
        System.out.println("十六进制字符转成二进制字符:" + hexStrToBinaryStr2("FF1DE66C"));
        System.out.println("8位的十六进制字符分别转换成10进制字符:" + parseHex8("FF1DE66C"));
        System.out.println("FFB48FDF的二进制格式:" + hexStrToBinaryStr2("FF1DE66C"));
        System.out.println("FFB48FDF的二进制取反:" + reverseHex2(hexStrToBinaryStr2("FF1DE66C")));
        System.out.println("求FFB48FDF的原码（二进制取反+1）" + add(reverseHex2(hexStrToBinaryStr2("FF1DE66C")),"1"));
        System.out.println("二进制字符串转16进制字符串："+binaryStrToHexStr(add(reverseHex2(hexStrToBinaryStr2("FF1DE66C")),"1").substring(8)));
        
        System.out.println("----------------------------------------------");
        String init_pull = DataTransform.add(DataTransform.reverseHex2(DataTransform.hexStrToBinaryStr2("FFF5")),"1").substring(1);
        System.out.println("拉力值二进制：" + init_pull);
        double pull = Long.parseLong(init_pull, 2) * 0.1;//转为10进制
        System.out.println("拉力值：" + "-" + String.valueOf(pull * 0.1));
    }*/
}