自己日常开发时遇到此类进制数据转换问题，总是要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));
}*/
}