1. 浮点数二进制表示法

IEEE 754标准：
float单精度浮点数为32位：符号位 1bit、指数8bits、尾数23bits。
double双精度浮点数为64位：符号位 1bit、指数11bits、尾数52bits。
归一化

10进制转2进制方法：
求和ai*2i，整数部分短除，小数部分短乘

1. 浮点数的陷阱

以4位尾数，1位指数为例

2.1 不能精准比较
0.6==0.6 废话当然相等

0.2*3 != 0.6
0.2=0011 奇进偶舍=010=0.25
0.2*2=0.4  0
0.4*2=0.8  0
0.8*2=1.6  1
0.6*2=1.2  1

0.6=1001奇进偶舍=100=0.5

2.2 不满足交换律
(a+b)+c != a+(b+c)
(3 + 0.125) + 0.125 != 3 + (0.125 + 0.125)

3=1100
0.125=0010
3+0.125=3.125=11001奇进偶舍=1100=3
(3+0.125) + 0.125 = 3 + 0.125 = 3

0.125+0.125=0.25=0100
3+0.25=1100 + 0100=1101=3.25

2.3 不满足结合律
(a+b)c != ac + b*c
(0.125+0.125)0.5 != 0.1250.5 + 0.125*0.5
左边等于0.125，右边等于0

1. java语言BigDecimal与数据库decimal是否能解决精度精确计算问题？

理论上能，坑很多，非常不建议以这种方式解决精度问题。即使java ok了，oc和js怎么办？
强烈建议取最小单位规格化成整数存储和运算，例如金额用分，土地面积用厘做单位。

3.1 BigDecimal的存储格式
实际是定点存储，即完全作为整数存，再附加一个小数点位置对应的负指数，因此才不丢精度。
但是要非常注意，必须使用String初始化BigDecimal才可能不丢精度，
所有算数运算也要通过BigDecimal操作才行，只要有中间值涉及到浮点数就会丢精度。

Java(JDK8)的 java.math.BigDecimal

public class BigDecimal extends Number implements Comparable {
    private final BigInteger intVal;
    
    private final int scale;
    
    public BigDecimal(char[] in,int offset,int len,MathContext mc) {
        ......
        char coeff[] = new char[len];
        for (; len > 0; offset++,len--) {
            c = in[offset];
            ......
            if (dot)
                ++scl;
            ......
        }
        ......
        rb = new BigInteger(coeff,isneg ? -1 : 1,prec);
        ......
        this.scale = scl;
        this.intVal = rb;
    }
}

public class BigInteger extends Number implements Comparable {
    final int[] mag;

    BigInteger(char[] val,int sign,int len) {
        int numWords;
        if (len < 10) {
            numWords = 1;
        } else {
            long numBits = ((numDigits * bitsPerDigit[10]) >>> 10) + 1;
            if (numBits + 31 >= (1L << 32)) {
                reportOverflow();
            }
            numWords = (int) (numBits + 31) >>> 5;
        }
        int[] magnitude = new int[numWords];
        ......
 

整数也有坑
大整数的精度丢失和浮点数本质上是一样的，尾数位最大是52位，因此JS中能精确表示的最大整数是Math.pow(2.53),十进制即为9007199254740992
大于9007199254740992可能会丢失精度
900719929007199254740992 1000000000....000000000//共计53个0
900719929007199254740992 + 1 1000000000....000000001//共计52个0
900719929007199254740992 + 2 1000000000....000000010//共计51个0

实际上
900719929007199254740992 + 1 丢失
900719929007199254740992 + 2 未丢失
900719929007199254740992 + 3 丢失
900719929007199254740992 + 4 未丢失