Java⼗六进制与IEEE754浮点数互相转换，⽀持单双精度Java⼗六进制与IEEE754浮点数互相转换，⽀持单双精度
本⽂连接：
IEEE754Utils.java fon.power.spri
import java.math.BigDecimal;
import java.math.BigInteger;
/***
* IEE754 浮点数转换⼯具
* 单精度校验：47218100 = 41345.0、 47849A0D = 67892.1016
* 双精度校验：4721810047849A0D = 45442749783852262460186723560194048
*
* @author: 若⾮
* @date: 2021/9/10 8:58
*/
@Remind("校验：47218100 = 41345.0、 47849A0D = 67892.1016")
public class IEEE754Utils {
/**
* 字节数组转IEEE 754
*
* @param bytes 长度4或者8
* @author: 若⾮
* @date: 2021/9/10 16:57
*/
public static BigDecimal bytesToSingle(byte[] bytes) {
if (bytes.length > 8) {
throw new ArrayIndexOutOfBoundsException("转化失败，字节超出整型⼤⼩！");
}
String hex = new BigInteger(bytes).toString(16);
return hexToSingle(hex, bytes.length * 8);
}
/**
* 字节数组转IEEE 754
*
* @param hex
* @param bitLen 32或者64
* @author: 若⾮
* @date: 2021/9/10 16:57
*/
private static BigDecimal hexToSingle(String hex, int bitLen) {
if (StringUtils.isEmpty(hex)) {
return BigDecimal.valueOf(0);
}
if (bitLen == 32) {
int i = Integer.parseInt(hex, 16);
float v = Float.intBitsToFloat(i);
return new BigDecimal(v);
}
if (bitLen == 64) {
long l = Long.parseLong(hex, 16);
double d = Double.longBitsToDouble(l);
return new BigDecimal(d);
}
return BigDecimal.valueOf(0);
}
/**
* IEEE 754字符串转⼗六进制字符串
*
* @param f
* @author: 若⾮
* @date: 2021/9/10 16:57
*/
public static String singleToHex(float f) {
int i = Float.floatToIntBits(f);
String hex = HexString(i);
return hex;
}
/**
* IEEE 754字符串转⼗六进制字符串
*
* @param d
* @author: 若⾮
* @date: 2021/9/10 16:57
*/
public static String singleToHex(double d) {
long l = Double.doubleToRawLongBits(d);
String hex = HexString(l);
return hex;
}
/
/下⾯测⽅法是⽅便c++等没有类似功能的时候做参考
* ⼗六进制字符串转IEEE 754
*
* @author: 若⾮
* @date: 2021/9/10 16:57
*/
/*public static BigDecimal hexToSingle(String hex, int bitLen) {
if (StringUtils.isEmpty(hex) || bitLen != 32 && bitLen != 64) {
return BigDecimal.valueOf(0);
}
String binaryString = StringUtils.fillString(new BigInteger(hex, 16).toString(2), "0", bitLen, true);
/
/String binaryString = String.format("%32s", new BigInteger(hex, 16).toString(2)).replace(' ', '0');
int exponentBitLength = hex.length() == 8 ? 8 : 11;
int mantissaBitLength = (hex.length() * 4) - exponentBitLength - 1;
char s = binaryString.charAt(0);//符号位
String e = binaryString.substring(1, exponentBitLength + 1);
String m = binaryString.substring(exponentBitLength + 1);
Double bias = Math.pow(2, exponentBitLength - 1) - 1;
int exponent = Integer.valueOf(e, 2) - bias.intValue();
long mantissa = Long.valueOf(m, 2);
//BigDecimal bigDecimal = (new BigDecimal(1).add(new BigDecimal(mantissa).multiply(new BigDecimal(Math.pow(2, -mantissaBits))))).multiply(new BigDecimal(Math.pow(2, exponent)));        Double res = (1 + (mantissa * Math.pow(2, -mantissaBitLength))) * Math.pow(2, exponent);
BigDecimal bigDecimal = new BigDecimal(res);
if (s == '1') {
return new BigDecimal(0).subtract(bigDecimal);
}
return bigDecimal;
}*/
/**
* IEEE 754转⼗六进制字符串
*
* @author: 若⾮
* @date: 2021/9/10 16:57
*/
/*public static String singleToHex(float fv) {
String negative = "0";
if (fv < 0) {
negative = "1";
fv = fv * -1;
}
int thirty;
int integer = Float.valueOf(fv).intValue();
float decimal = fv - integer;
String rear; //0-22位存放的值
String medim = "";//23位到29位
String integerBinaryString = BinaryString(integer);
String decimalBinaryString = ConvertUtils.unsignedDecimalToBinary(decimal);
if (integerBinaryString.length() > 1) {
//左移 30为存1
thirty = 1;
int exponent = integerBinaryString.length() - 2;
rear = integerBinaryString.substring(1) + decimalBinaryString;
if (rear.length() > 23) {
rear = rear.substring(0, 23);
} else {
for (int i = rear.length(); i <= 22; i++) {
rear += "0";
}
}
medim = BinaryString(exponent);
medim = StringUtils.fillString(medim, "0", 7, true);
} else if ("1".equals(integerBinaryString)) {
//不需要移动位数 30位0  剩下的补1 指数部分 23-29位
//127-指数 23-29位正好七位最⼤值127
thirty = 0;
rear = integerBinaryString.substring(1) + decimalBinaryString;
if (rear.length() > 23) {
rear = rear.substring(0, 23);
} else {
rear = StringUtils.fillString(medim, "0", 22, true);
}
medim = "1111111";
} else {//0 0 1111101 100 1100 1100 1100 1100 1100
//右移 30位存0
thirty = 0;
int index = decimalBinaryString.indexOf("1");//到第⼀个为1的位置索引右移动的位数
int exponent = 127 - (index + 1);
rear = decimalBinaryString.substring(index + 1);
if (rear.length() > 23) {
rear = rear.substring(0, 23);
} else {
rear = StringUtils.fillString(medim, "0", 22, true);
}
medim = BinaryString(exponent);
bigdecimal转换为integermedim = StringUtils.fillString(medim, "0", 7, true);
}
String res = "" + negative + thirty + medim + rear;
StringBuilder sb = new StringBuilder();
if (res.length() == 32) {
for (int i = 0; i < 8; i++) {
String binary = res.substring(4 * i, 4 * i + 4);
sb.append(Constants.BIN_(binary));
}
String();
}*/
}
StringUtils.java
public static String fillString(String src, String c, int len, boolean left) { if (StringUtils.isEmpty(src) || len <= src.length()) {
return src;
}
int l = src.length();
for (int i = 0; i < len - l; i++) {
if (left) {
src = c + src;
} else {
src += c;
}
}
return src;
}
public static boolean isEmpty(Object content) {
return content == null || "".equals(content);
}