BigDecimal 了解更多

我就是我 2022-01-06 01:07 190阅读 0赞

简单技术使用

## 数据初始化 ##

//数字初始化
    BigDecimal numA = new BigDecimal(1234.567);
    BigDecimal numB = new BigDecimal(0.123);
    
    //字符初始化
    BigDecimal stringA = new BigDecimal("1234.567");
    BigDecimal stringB = new BigDecimal("0.123");

## 数据基本运算 ##

System.out.println("加："+stringA.add(stringB));
    System.out.println("减："+stringA.subtract(stringB));
    System.out.println("乘："+stringA.multiply(stringB));
    System.out.println("除："+stringA.divide(stringB));
    System.out.println("绝对值："+stringA.abs());

## 源码阅读【谢谢谷歌百度翻译大大】 ##

数字初始化
 /**
 * 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
 * <tt>(10scale × val)</tt> is an integer.
 * 
 * Notes:
 * <ol>
 * <li>
 * 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.
 *
 * <li>
 * 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)
 * <tt>String</tt> constructor} be used in preference to this one.
 【*** string的构造方法可预测，满足我们的开发预期，提供了精确转换结果 ***】
 * <li>
 * 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.
 * </ol>
 *
 * @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);
 }

字符初始化
 /**
 * Translates the string representation of a {@code BigDecimal}
 * into a {@code BigDecimal}. The string representation consists
 * of an optional sign, {@code '+'} (<tt> '\u002B'</tt>) or
 * {@code '-'} (<tt>'\u002D'</tt>), 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'}
 * (<tt>'\u0065'</tt>) or {@code 'E'} (<tt>'\u0045'</tt>)
 * 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:
 * <blockquote>
 * <dl>
 * <dt>BigDecimalString:
 * <dd>Signopt Significand Exponentopt
 * <dt>Sign:
 * <dd>{@code +}
 * <dd>{@code -}
 * <dt>Significand:
 * <dd>IntegerPart {@code .} FractionPartopt
 * <dd>{@code .} FractionPart
 * <dd>IntegerPart
 * <dt>IntegerPart:
 * <dd>Digits
 * <dt>FractionPart:
 * <dd>Digits
 * <dt>Exponent:
 * <dd>ExponentIndicator SignedInteger
 * <dt>ExponentIndicator:
 * <dd>{@code e}
 * <dd>{@code E}
 * <dt>SignedInteger:
 * <dd>Signopt Digits
 * <dt>Digits:
 * <dd>Digit
 * <dd>Digits Digit
 * <dt>Digit:
 * <dd>any character for which {@link Character#isDigit}
 * returns {@code true}, including 0, 1, 2 ...
 * </dl>
 * </blockquote>
 *
 * 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.
 * <pre>
 * "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]
 * </pre>
 *
 * 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());
 }