Java Basics - Java Examples in a Nutshell - page 17

rather than a primitive value, so you can't simply use the * operator to multiply
BigInteger objects. Use the multiply() method instead.
Example 1−10: Factorial4.java
package com.davidflanagan.examples.basics;
// Import some other classes we'll use in this example.
// Once we import a class, we don't have to type its full name.
import java.math.BigInteger; // Import BigInteger from java.math package
import java.util.*; // Import all classes (including ArrayList) from java.util
/**
* This version of the program uses arbitrary precision integers, so it does
* not have an upper-bound on the values it can compute. It uses an ArrayList
* object to cache computed values instead of a fixed-size array. An ArrayList
* is like an array, but can grow to any size. The factorial() method is
* declared "synchronized" so that it can be safely used in multi-threaded
* programs. Look up java.math.BigInteger and java.util.ArrayList while
* studying this class. Prior to Java 1.2, use Vector instead of ArrayList
**/
public class Factorial4 {
protected static ArrayList table = new ArrayList(); // create cache
static { // Initialize the first element of the cache with !0 = 1.
table.add(BigInteger.valueOf(1));
}
/** The factorial() method, using BigIntegers cached in a ArrayList */
public static synchronized BigInteger factorial(int x) {
if (x<0) throw new IllegalArgumentException("x must be non-negative.");
for(int size = table.size(); size <= x; size++) {
BigInteger lastfact = (BigInteger)table.get(size-1);
BigInteger nextfact = lastfact.multiply(BigInteger.valueOf(size));
table.add(nextfact);
}
return (BigInteger) table.get(x);
}
/**
* A simple main() method that we can use as a standalone test program
* for our factorial() method.
**/
public static void main(String[] args) {
for(int i = 0; i <= 50; i++)
System.out.println(i + "! = " + factorial(i));
}
}
Handling Exceptions
Example 1-11 shows a program that uses the Integer.parseInt() method to con-
vert a string specified on the command line to a number. The program then com-
putes and prints the factorial of that number, using the Factorial4.factorial()
method defined in Example 1-10. That much is simple; it takes only two lines of
code. The rest of the example is concerned with exception handling, or, in other
words, taking care of all of the things that can go wrong. You use the try/catch
statement in Java for exception handling. The try clause encloses a block of code