IN THIS CHAPTER

Dealing with operators, such as +, –, *, and /

Creating finely crafted expressions

Incrementing and decrementing

Accepting an assignment

Using the Math class

Formatting your numbers

Seeing strange things that can happen with numbers

In Book 2, Chapter 2, you discover the various primitive numeric types that are supported by Java. In this chapter, you build on that knowledge by doing basic operations with numbers. Much of this chapter focuses on the complex topic of expressions, which combine numbers with operators to perform calculations. This chapter also covers performing advanced calculations using the Math class and techniques for formatting numbers when you display them. In addition, you find out why Java’s math operations sometimes produce results you may not expect.

Working with Arithmetic Operators

An operator is a special symbol or keyword that’s used to designate a mathematical operation or some other type of operation that can be performed on one or more values, called operands. In all, Java has about 40 operators. This chapter focuses on the operators that do arithmetic. These arithmetic operators — seven of them in all, summarized in Table 3-1 — perform basic arithmetic operations, such as addition, subtraction, multiplication, and division.

The following section of code can help clarify how these operators work for int types:

int a = 32, b = 5;
int c = a + b; // c is 37
int d = a - b; // d is 27
int e = a * b; // e is 160
int f = a / b; // f is 5 (32 / 5 is 6 remainder 2)
int g = a % b; // g is 2 (32 / 5 is 6 remainder 2)
a++; // a is now 33
b--; // b is now 4

Notice that for division, the result is truncated. Thus 32 / 5 returns 6, not 6.4. For more information about integer division, see the section “Dividing Integers,” later in this chapter.

Here’s how the operators work for double values:

double x = 5.5, y = 2.0;
double m = x + y; // m is 7.5
double n = x - y; // n is 3.5
double o = x * y; // o is 11.0
double p = x / y; // p is 2.75
double q = x % y; // q is 1.5
x++; // x is now 6.5
y--; // y is now 1.0

When you divide two int values, the result is an integer value, even if you assign it to a double variable. For example:

int a = 21, b = 6;
double answer = a / b; // answer = 3.0

If that’s not what you want, you can cast one of the operands to a double before performing the division. (Casting an operand means converting its value from one data type to another.) Here’s how:

int a = 21, b = 6;
double answer = (double)a / b; // answer = 3.5

The moral of the story is that if you want to divide int values and get an accurate double result, you must cast at least one of the int values to a double.

Here are a few additional things to think about tonight as you lie awake pondering the wonder of Java’s arithmetic operators:

• In algebra, you can write a number right next to a variable to imply multiplication. In this case, 4x means “four times x.” Not so in Java. The following statement doesn’t compile:

  int x;
y = 4x; // error, this line won't compile

• The remainder operator (%) is also called a modulus operator. It returns the remainder when the first operand is divided by the second operand. The remainder operator is often used to determine whether one number is evenly divisible by another, in which case the result is zero. For more information, see the next section, “Dividing Integers.”

• All operators, including the arithmetic variety, are treated as separators in Java. As a result, any use of white space in an expression is optional. Thus the following two statements are equivalent:

  a = ( (x + 4) * 7 ) / (y * x);
a=((x+4)*7)/(y*x);

  Just remember that a little bit of white space never hurt anyone, and sometimes it helps make Java a little more readable.

Dividing Integers

When you divide one integer into another, the result is always another integer. Any remainder is simply discarded, and the answer is not rounded up. 5 / 4 gives the result 1, for example, and 3 / 4 gives the result 0. If you want to know that 5 / 4 is actually 1.25 or that 3 / 4 is actually 0.75, you need to use floats or doubles instead of integers.

If you need to know what the remainder is when you divide two integers, use the remainder operator (%). Suppose that you have a certain number of marbles to give away and a certain number of children to give them to. The program in Listing 3-1 lets you enter the number of marbles and the number of children. Then it calculates the number of marbles to give to each child and the number of marbles you have left over.

The remainder operator is also called the modulus operator.

Here’s a sample of the console output for this program, where the number of marbles entered is 93 and the number of children is 5:

Welcome to the marble divvy-upper.
Number of marbles: 93
Number of children: 5
Give each child 18 marbles.
You will have 3 marbles left over.

LISTING 3-1 A Program That Divvies Up Marbles

import java.util.Scanner; →1
public class MarblesApp
{
static Scanner sc = new Scanner(System.in); →5
public static void main(String[] args)
{
// declarations →9
int numberOfMarbles;
int numberOfChildren;
int marblesPerChild;
int marblesLeftOver;

// get the input data →15
System.out.println("Welcome to the marble divvy-upper.");
System.out.print("Number of marbles: ");
numberOfMarbles = sc.nextInt();
System.out.print("Number of children: ");
numberOfChildren = sc.nextInt();
// calculate the results
marblesPerChild = numberOfMarbles / numberOfChildren; →23

marblesLeftOver = numberOfMarbles % numberOfChildren; →24

// print the results →26
System.out.println("Give each child " +
marblesPerChild + " marbles.");
System.out.println("You will have " +
marblesLeftOver + " marbles left over.");
}
}

The following paragraphs describe the key lines in this program:

1. →1 Imports the java.util.Scanner class so that the program can use it to get input from the user.
2. →5 Creates the Scanner object and assigns it to a class variable so that it can be used in any method in the class.
3. →9–13 Declare the local variables used by the program.
4. →15-20 Get the input from the user.
5. →23 Calculates the number of marbles to give to each child by using integer division, which discards the remainder.
6. →24 Calculates the number of marbles left over.
7. →26–31 Print the results.

It’s probably obvious if you think about it, but you should realize that if you use integer division to divide a by b, the result times b plus the remainder equals a. In other words:

int a = 29; // any value will do
int b = 3; // any value will do
int c = a / b;
int d = a % b;
int e = (c * b) + d; // e will always equal a

Combining Operators

You can combine operators to form complicated expressions. When you do, the order in which the operations are carried out is determined by the precedence of each operator in the expression. The order of precedence for the arithmetic operators is

• Increment (++) and decrement (--) operators are evaluated first.
• Next, sign operators (+ or -) are applied.
• Then multiplication (*), division (/), and remainder (%) operators are evaluated.
• Finally, addition (+) and subtraction (-) operators are applied.

In the expression a + b * c, for example, multiplication has a higher precedence than addition. Thus b is multiplied by c first. Then the result of that multiplication is added to a.

If an expression includes two or more operators at the same order of precedence, the operators are evaluated left to right. Thus, in the expression a * b / c, a is multiplied by b and then the result is divided by c.

If you want, you can use parentheses to change the order in which operations are performed. Operations within parentheses are always performed before operations that aren’t in parentheses. Thus, in the expression (a + b) * c, a is added to b first. Then the result is multiplied by c.

If an expression has two or more sets of parentheses, the operations in the innermost set are performed first. In the expression (a * (b + c)) / d, b is added to c. Then the result is multiplied by a. Finally, that result is divided by d.

Apart from the increment and decrement operators, these precedence rules and the use of parentheses are the same as they are for basic algebra. So if you were paying attention in the eighth grade, precedence should make sense.

With double or float values, changing the left to right order for operators with the same precedence doesn’t affect the result. With integer types, however, it can make a huge difference if division is involved. Consider these statements:

int a = 5, b = 6, c = 7;
int d1 = a * b / c; // d1 is 4
int d2 = a * (b / c); // d2 is 0

This difference occurs because integer division always returns an integer result, which is a truncated version of the actual result. Thus, in the first expression, a is first multiplied by b, giving a result of 30. Then this result is divided by c. Truncating the answer gives a result of 4. But in the second expression, b is first divided by c, which gives a truncated result of 0. Then this result is multiplied by a, giving a final answer of 0.

Using the Unary Plus and Minus Operators

The unary plus and minus operators let you change the sign of an operand. Note that the actual operator used for these operations is the same as the binary addition and subtraction operators. The compiler figures out whether you mean to use the binary or the unary version of these operators by examining the expression.

The unary minus operator doesn’t necessarily make an operand have a negative value. Instead, it changes whatever sign the operand has to start with. Thus, if the operand starts with a positive value, the unary minus operator changes it to negative. But if the operand starts with a negative value, the unary minus operator makes it positive. The following examples illustrate this point:

int a = 5; // a is 5
int b = -a; // b is -5
int c = -b; // c is +5

Interestingly enough, the unary plus operator doesn’t actually do anything. For example:

int a = -5; // a is -5
int b = +a; // b is -5
a = 5; // a is now 5
int c = +a; // c is 5

Notice that if a starts out positive, +a is also positive. But if a starts out negative, +a is still negative. Thus the unary plus operator has no effect. I guess Java provides the unary plus operator out of a need for balance.

You can also use these operators with more complex expressions, like this:

int a = 3, b = 4, c = 5;
int d = a * -(b + c); // d is -27

Here, b is added to c, giving a result of 9. Then the unary minus operator is applied, giving a result of -9. Finally, -9 is multiplied by a, giving a result of -27.

Using Increment and Decrement Operators

One of the most common operations in computer programming is adding or subtracting 1 from a variable. Adding 1 to a variable is called incrementing the variable. Subtracting 1 is called decrementing. The traditional way to increment a variable is this:

a = a + 1;

Here the expression a + 1 is calculated, and the result is assigned to the variable a.

Java provides an easier way to do this type of calculation: the increment (++) and decrement (--) operators. These unary operators apply to a single variable. Thus, to increment the variable a, you can code just this:

a++;

Note that an expression that uses an increment or decrement operator is a statement by itself. That’s because the increment or decrement operator is also a type of assignment operator, as it changes the value of the variable it applies to.

You can use the increment and decrement operators only on variables — not on numeric literals or other expressions. Java doesn’t allow the following expressions, for example:

a = b * 5++; // can't increment the number 5
a = (b * 5)++; // can't increment the expression (b * 5)

Note that you can use an increment or decrement operator in an assignment statement. Here’s an example:

int a = 5;
int b = a--; // both a and b are set to 4

When the second statement is executed, the expression a-- is evaluated first, so a is set to 4. Then the new value of a is assigned to b. Thus both a and b are set to 4.

The increment and decrement operators are unusual because they are unary operators that can be placed either before (prefix) or after (postfix)the variable they apply to. Whether you place the operator before or after the variable can have a major effect on how an expression is evaluated. If you place an increment or decrement operator before its variable, the operator is applied before the rest of the expression is evaluated. As a result, the incremented value of the variable is used in the expression. By contrast, if you place the operator after the variable, the operator is applied after the expression is evaluated. Thus the original value of the variable is used in the expression.

Confused yet? A simple example can clear things up. First, consider these statements with an expression that uses a postfix increment:

int a = 5;
int b = 3;
int c = a * b++; // c is set to 15

When the expression in the third statement is evaluated, the original value of b — 3 — is used in the multiplication. Thus c is set to 15. Then b is incremented to 4.

Now consider this version, with a prefix increment:

int a = 5;
int b = 3;
int c = a * ++b; // c is set to 20

This time, b is incremented before the multiplication is performed, so c is set to 20. Either way, b ends up set to 4.

Similarly, consider this example:

int a = 5;
int b = --a; // b is set to 5, a is set to 4.

This example is similar to an earlier example, but this time the prefix increment operator is used. When the second statement is executed, the value of a is assigned to b. Then a is decremented. As a result, b is set to 5, and a is set to 4.

Because the increment and decrement operators can be confusing when used with other operators in an expression, I suggest that you use them alone. Whenever you’re tempted to incorporate an increment or decrement operator into a larger expression, pull the increment or decrement out of the expression, and make it a separate statement either before or after the expression. In other words, code

b++;
c = a * b;

instead of

c = a * ++b;

In the first version, it’s crystal-clear that b is incremented before the multiplication is done.

Using the Assignment Operator

The standard assignment operator (=) is used to assign the result of an expression to a variable. In its simplest form, you code it like this:

variable = expression;

Here’s an example:

int a = (b * c) / 4;

You’ve already seen plenty of examples of assignment statements like this one, so I won’t belabor this point any further. I do want to point out — just for the record — that you cannot code an arithmetic expression on the left side of an equal sign. Thus the following statement doesn’t compile:

int a;
a + 3 = (b * c);

In the rest of this section, I point out some unusual ways in which you can use the assignment operator. I don’t recommend that you actually use any of these techniques, as they’re rarely necessary and almost always confusing, but knowing about them can shed light on how Java expressions work and sometimes can help you find sneaky problems in your code.

The key to understanding the rest of this section is realizing that in Java, assignments are expressions, not statements. In other words, a = 5 is an assignment expression, not an assignment statement. It becomes an assignment statement only when you add a semicolon to the end.

The result of an assignment expression is the value that’s assigned to the variable. The result of the expression a = 5, for example, is 5. Likewise, the result of the expression a = (b + c) * d is the result of the expression (b + c) * d.

The implication is that you can use assignment expressions in the middle of other expressions. The following example is legal:

int a;
int b;
a = (b = 3) * 2; // a is 6, b is 3

As in any expression, the part of the expression inside the parentheses is evaluated first. Thus, b is assigned the value 3. Then the multiplication is performed, and the result (6) is assigned to the variable a.

Now consider a more complicated case:

int a;
int b = 2;
a = (b = 3) * b; // a is 9, b is 3

What’s happening here is that the expression in the parentheses is evaluated first, which means that b is set to 3 before the multiplication is performed.

The parentheses are important in the previous example because without parentheses, the assignment operator is the last operator to be evaluated in Java’s order of precedence. Consider one more example:

int a;
int b = 2;
a = b = 3 * b; // a is 6, b is 6

This time, the multiplication 3 * b is performed first, giving a result of 6. Then this result is assigned to b. Finally, the result of that assignment expression (6) is assigned to a.

Incidentally, the following expression is also legal:

a = b = c = 3;

This expression assigns the value 3 to all three variables. Although this code seems pretty harmless, you’re better off just writing three assignment statements. (You might guess that clumping the assignments together is more efficient than writing them on three lines, but you’d be wrong. These three assignments require the same number of bytecode instructions either way.)

Using Compound Assignment Operators

A compound assignment operator is an operator that performs a calculation and an assignment at the same time. All of Java’s binary arithmetic operators (that is, the ones that work on two operands) have equivalent compound assignment operators, which Table 3-2 lists.

The statement

a += 10;

is equivalent to

a = a + 10;

Also, the statement

z *=2;

is equivalent to

z = z * 2;

To prevent confusion, use compound assignment expressions by themselves, not in combination with other expressions. Consider these statements:

int a = 2;
int b = 3;
a *= b + 1;

Is a set to 7 or 8?

In other words, is the third statement equivalent to

a = a * b + 1; // This would give 7 as the result

or

a = a * (b + 1); // This would give 8 as the result

At first glance, you might expect the answer to be 7, because multiplication has a higher precedence than addition. But assignment has the lowest precedence of all, and the multiplication here is performed as part of the assignment. As a result, the addition is performed before the multiplication — and the answer is 8. (Gotcha!)

Using the Math Class

Java’s built-in operators are useful, but they don’t come anywhere near providing all the mathematical needs of most Java programmers. That’s where the Math class comes in. It includes a bevy of built-in methods that perform a wide variety of mathematical calculations, from basic functions such as calculating an absolute value or a square root to trigonometry functions such as sin and cos (sine and cosine), to practical functions such as rounding numbers or generating random numbers.

I was going to make a joke here about how you’d have to take a math class to fully appreciate the Math class; or how you’d better stay away from the Math class if you didn’t do so well in math class; or how if you’re on the football team, maybe you can get someone to do the Math class for you. But these jokes seemed too easy, so I decided not to make them.

All the methods of the Math class are declared as static methods, which means you can use them by specifying the class name Math followed by a period and a method name. Here’s a statement that calculates the square root of a number stored in a variable named y:

double x = Math.sqrt(y);

The Math class is contained in the java.lang package, which is automatically available to all Java programs. As a result, you don’t have to provide an import statement to use the Math class.

The following sections describe the most useful methods of the Math class.

Formatting Numbers

Most of the programs you’ve seen so far have used the System.out.println or System.out.print method to print the values of variables that contain numbers. When you pass a numeric variable to one of these methods, the variable’s value is converted to a string before it’s printed. The exact format used to represent the value isn’t very pretty: Large values are printed without any commas, and all the decimal digits for double or float values are printed whether you want them to be or not.

In many cases, you want to format your numbers before you print them — to add commas to large values and limit the number of decimal places printed, for example. Or, if a number represents a monetary amount, you may want to add a dollar sign (or whatever currency symbol is appropriate for your locale). To do that, you can use the NumberFormat class. Table 3-6 lists the NumberFormat class methods.

Like many aspects of Java, the procedure for using the NumberFormat class is a little awkward. It’s designed to be efficient for applications that need to format a lot of numbers, but it’s overkill for most applications.

The procedure for using the NumberFormat class to format numbers takes a little getting used to. First, you must call one of the static getXxxInstance methods to create a NumberFormat object that can format numbers in a particular way. Then, if you want, you can call the setMinimumFractionDigits or setMaximumFractionDigits method to set the number of decimal digits to be displayed. Finally, you call that object’s format method to actually format a number.

Note that the NumberFormat class is in the java.text package, so you must include the following import statement at the beginning of any class that uses NumberFormat:

import java.text.NumberFormat;

Here’s an example that uses the NumberFormat class to format a double value as currency:

double salesTax = 2.425;
NumberFormat cf = NumberFormat.getCurrencyInstance();
System.out.println(cf.format(salesTax));

When you run this code, the following line is printed to the console:

$2.43

Note that the currency format rounds the value from 2.425 to 2.43.

Here’s an example that formats a number by using the general number format, with exactly three decimal places:

double x = 19923.3288;
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMinimumFractionDigits(3);
nf.setMaximumFractionDigits(3);
System.out.println(nf.format(x));

When you run this code, the following line is printed:

19,923.329

Here the number is formatted with a comma and the value is rounded to three places.

Here’s an example that uses the percentage format:

double grade = .92;
NumberFormat pf = NumberFormat.getPercentInstance();
System.out.println(pf.format(grade));

When you run this code, the following line is printed:

92%

If your program formats several numbers, consider creating the NumberFormat object as a class variable. That way, the NumberFormat object is created when the program starts. Then you can use the NumberFormat object from any method in the program’s class. Listing 3-6 is a simple example that shows how this process works. When this program is run, the following output is produced:

My allowance: $5.00
Cost of Paint Ball Gun: $69.95

Here the cf variable is created as a class variable. Then both the print MyAllowance and printCostOfPaintBallGun methods can use it in lines 19 and 27.

LISTING 3-6 A Program That Uses a NumberFormat Class Variable

import java.text.NumberFormat;

public class NumberFormatClassApp
{

static NumberFormat cf = →6
NumberFormat.getCurrencyInstance();

public static void main(String[] args)
{
printMyAllowance();
printCostOfPaintBallGun();
}

public static void printMyAllowance()
{
double myAllowance = 5.00;
cf = NumberFormat.getCurrencyInstance();
System.out.println("My allowance: " →19
+ cf.format(myAllowance));
}

public static void printCostOfPaintBallGun()
{
double costOfPaintBallGun = 69.95;
cf = NumberFormat.getCurrencyInstance();
System.out.println("Cost of Paint Ball Gun: " →27
+ cf.format(costOfPaintBallGun));
}
}

Recognizing Weird Things about Java Math

Believe it or not, computers — even the most powerful ones — have certain limitations when it comes to performing math calculations. These limitations are usually insignificant, but sometimes they sneak up and bite you. The following sections describe the things you need to watch out for when doing math in Java.