谁是代码界3%的王者？- 第四题BigDecimal问题简单解读

java.math.BigDecimal#BigDecimal(java.lang.String)
  /**
     * Translates the string representation of a {@code BigDecimal}
     * into a {@code BigDecimal}.  The string representation consists
     * of an optional sign, {@code '+'} ( '\u002B') or
     * {@code '-'} ('\u002D'), followed by a sequence of
     * zero or more decimal digits ("the integer"), optionally
     * followed by a fraction, optionally followed by an exponent.
     *
     * 
The fraction consists of a decimal point followed by zero
     * or more decimal digits.  The string must contain at least one
     * digit in either the integer or the fraction.  The number formed
     * by the sign, the integer and the fraction is referred to as the
     * significand.
     *
     * 
The exponent consists of the character {@code 'e'}
     * ('\u0065') or {@code 'E'} ('\u0045')
     * followed by one or more decimal digits.  The value of the
     * exponent must lie between -{@link Integer#MAX_VALUE} ({@link
     * Integer#MIN_VALUE}+1) and {@link Integer#MAX_VALUE}, inclusive.
     *
     * 
More formally, the strings this constructor accepts are
     * described by the following grammar:
     * 
     * 
     * BigDecimalString:
     * Signopt Significand Exponentopt
     * Sign:
     * {@code +}
     * {@code -}
     * Significand:
     * IntegerPart {@code .} FractionPartopt
     * {@code .} FractionPart
     * IntegerPart
     * IntegerPart:
     * Digits
     * FractionPart:
     * Digits
     * Exponent:
     * ExponentIndicator SignedInteger
     * ExponentIndicator:
     * {@code e}
     * {@code E}
     * SignedInteger:
     * Signopt Digits
     * Digits:
     * Digit
     * Digits Digit
     * Digit:
     * any character for which {@link Character#isDigit}
     * returns {@code true}, including 0, 1, 2 ...
     * 
     * 
     *
     * 
The scale of the returned {@code BigDecimal} will be the
     * number of digits in the fraction, or zero if the string
     * contains no decimal point, subject to adjustment for any
     * exponent; if the string contains an exponent, the exponent is
     * subtracted from the scale.  The value of the resulting scale
     * must lie between {@code Integer.MIN_VALUE} and
     * {@code Integer.MAX_VALUE}, inclusive.
     *
     * 
The character-to-digit mapping is provided by {@link
     * java.lang.Character#digit} set to convert to radix 10.  The
     * String may not contain any extraneous characters (whitespace,
     * for example).
     *
     * 
Examples:
     * The value of the returned {@code BigDecimal} is equal to
     * significand × 10 exponent.
     * For each string on the left, the resulting representation
     * [{@code BigInteger}, {@code scale}] is shown on the right.
     * 
     * "0"            [0,0]
     * "0.00"         [0,2]
     * "123"          [123,0]
     * "-123"         [-123,0]
     * "1.23E3"       [123,-1]
     * "1.23E+3"      [123,-1]
     * "12.3E+7"      [123,-6]
     * "12.0"         [120,1]
     * "12.3"         [123,1]
     * "0.00123"      [123,5]
     * "-1.23E-12"    [-123,14]
     * "1234.5E-4"    [12345,5]
     * "0E+7"         [0,-7]
     * "-0"           [0,0]
     * 
     *
     * 
Note: For values other than {@code float} and
     * {@code double} NaN and ±Infinity, this constructor is
     * compatible with the values returned by {@link Float#toString}
     * and {@link Double#toString}.  This is generally the preferred
     * way to convert a {@code float} or {@code double} into a
     * BigDecimal, as it doesn't suffer from the unpredictability of
     * the {@link #BigDecimal(double)} constructor.
     *
     * @param val String representation of {@code BigDecimal}.
     *
     * @throws NumberFormatException if {@code val} is not a valid
     *         representation of a {@code BigDecimal}.
     */
    public BigDecimal(String val) {
        this(val.toCharArray(), 0, val.length());
    }
人家都怕你不仔细看给了你那么多示例，还专门给了一个note
This is generally the preferred way to convert a {@code float} or {@code double} into a BigDecimal, as it doesn't suffer from the unpredictability of the {@link #BigDecimal(double)} constructor.
此构造函数是float或double转到BigDecimal的推荐方式，因为该构造方法不会像BigDecimal(double)一样会有一些不可预测的情况。
它最终调用了java.math.BigDecimal#BigDecimal(char[], int, int) 感兴趣大家可以自己去看。
我们再看另外一个构造函数
java.math.BigDecimal#BigDecimal(double)
 /**
     * Translates a {@code double} into a {@code BigDecimal} which
     * is the exact decimal representation of the {@code double}'s
     * binary floating-point value.  The scale of the returned
     * {@code BigDecimal} is the smallest value such that
     * (10scale × val) is an integer.
     * 
     * Notes:
     * 
     * 
     * The results of this constructor can be somewhat unpredictable.
     * One might assume that writing {@code new BigDecimal(0.1)} in
     * Java creates a {@code BigDecimal} which is exactly equal to
     * 0.1 (an unscaled value of 1, with a scale of 1), but it is
     * actually equal to
     * 0.1000000000000000055511151231257827021181583404541015625.
     * This is because 0.1 cannot be represented exactly as a
     * {@code double} (or, for that matter, as a binary fraction of
     * any finite length).  Thus, the value that is being passed
     * in to the constructor is not exactly equal to 0.1,
     * appearances notwithstanding.
     *
     * 
     * The {@code String} constructor, on the other hand, is
     * perfectly predictable: writing {@code new BigDecimal("0.1")}
     * creates a {@code BigDecimal} which is exactly equal to
     * 0.1, as one would expect.  Therefore, it is generally
     * recommended that the {@linkplain #BigDecimal(String)
     * String constructor} be used in preference to this one.
     *
     * 
     * When a {@code double} must be used as a source for a
     * {@code BigDecimal}, note that this constructor provides an
     * exact conversion; it does not give the same result as
     * converting the {@code double} to a {@code String} using the
     * {@link Double#toString(double)} method and then using the
     * {@link #BigDecimal(String)} constructor.  To get that result,
     * use the {@code static} {@link #valueOf(double)} method.
     * 
     *
     * @param val {@code double} value to be converted to
     *        {@code BigDecimal}.
     * @throws NumberFormatException if {@code val} is infinite or NaN.
     */
    public BigDecimal(double val) {
        this(val,MathContext.UNLIMITED);
    }
专门提到
new BigDecimal(0.1)的结果是0.1000000000000000055511151231257827021181583404541015625.
This is because 0.1 cannot be represented exactly as a {@code double} (or, for that matter, as a binary fraction of any finite length). 
Thus, the value that is being passed in to the constructor is not exactly equal to 0.1, appearances notwithstanding.
这是因为double类型无法精确表示0.1。因此传入0.1参数到该构造方法其实并不精确等于0.1。
The {@code String} constructor, on the other hand, is perfectly predictable: writing {@code new BigDecimal("0.1")} creates a {@code BigDecimal} which is exactly equal to  0.1, as one would expect.  Therefore, it is generally recommended that the {@linkplain #BigDecimal(String String constructor} be used in preference to this one.
更推荐使用参数为String的构造方法，换句话说用BigDecimal("0.1")来构造完全等于0.1的BigDecimal。
因此，推荐带String参数的构造方法。
When a {@code double} must be used as a source for a {@code BigDecimal}, note that this constructor provides an exact conversion; it does not give the same result asconverting the {@code double} to a {@code String} using the {@link Double#toString(double)} method and then using the {@link #BigDecimal(String)} constructor.
如果必须把double作为构造方法的参数时，注意和new BigDecimal(Double.toString(0.1d))的结果是完全不同的。