Fundamental Programming Structures in Java

Always construct BigDecimal objects from integers or strings. Avoid the constructor BigDecimal(double) that is inherently prone to roundoff. For example, new BigDecimal(0.1) has digits

0.1000000000000000055511151231257827021181583404541015625

Java has no programmable operator overloading. There was no way for the programmers of the BigInteger class to redefine the + and * operators to give the add and multiply operations of the BigInteger classes. The language designers did overload the + operator to denote concatenation of strings. They chose not to overload other operators, and they did not give Java programmers the opportunity to overload operators in their own classes.

In Java 19, the BigInteger class provides a parallelMultiply method that yields the same result as multiply but can potentially compute the result faster by using multiple processor cores. Use this method if you have to do a lot of multiplications and you know that your application does not need the CPU resources for other computations.

To run this program with a version prior to Java 25, add the line

import java.math.BigInteger;

to the top of the program, in addition to the general modifications described in the notes in Section 3.1 and Section 3.7.1.

Listing 3.6 BigIntegerDemo.java

/**
 * This program uses big numbers to compute the odds of winning the grand prize
 * in a lottery.
 */
void main() {
    IO.print("How many numbers do you need to draw? ");
    int k = Integer.parseInt(IO.readln());

    IO.print("What is the highest number you can draw? ");
    BigInteger n = new BigInteger(IO.readln());

    // Binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)

    BigInteger lotteryOdds = BigInteger.ONE;

    for (int i = 1; i <= k; i++)
        lotteryOdds = lotteryOdds
                .multiply(n.subtract(BigInteger.valueOf(i - 1)))
                .divide(BigInteger.valueOf(i));

    IO.println("Your odds are 1 in " + lotteryOdds + " Good luck!");
}

java.math.BigInteger1.1

• BigInteger add(BigInteger other)

• BigInteger subtract(BigInteger other)

• BigInteger multiply(BigInteger other)

• BigInteger divide(BigInteger other)

• BigInteger mod(BigInteger other)

• BigInteger pow(int exponent)

  return the sum, difference, product, quotient, remainder, and power of this big integer and other.

• BigInteger sqrt()9

  yields the square root of this BigInteger.

• int compareTo(BigInteger other)

  returns 0 if this big integer equals other, a negative result if this big integer is less than other, and a positive result otherwise.

• static BigInteger valueOf(long x)

  returns a big integer whose value equals x.

java.math.BigDecimal1.1

• BigDecimal(String digits)

  constructs a big decimal with the given digits.

• BigDecimal add(BigDecimal other)

• BigDecimal subtract(BigDecimal other)

• BigDecimal multiply(BigDecimal other)

• BigDecimal divide(BigDecimal other)5.0

• BigDecimal divide(BigDecimal other, RoundingMode mode)5.0

  return the sum, difference, product, or quotient of this big decimal and other. The first divide method throws an exception if the quotient does not have a finite decimal expansion. To obtain a rounded result, use the second method. The mode RoundingMode.HALF_UP is the rounding mode that you learned in school: round down the digits 0 to 4, round up the digits 5 to 9. It is appropriate for routine calculations. See the API documentation for other rounding modes.

• int compareTo(BigDecimal other)

  returns 0 if this big decimal equals other, a negative result if this big decimal is less than other, and a positive result otherwise.