###
Mathematical operators

The basic mathematical operators are the same as the ones available in most programming languages: addition (**+**), subtraction (**-**), division (**/**), multiplication (*****) and modulus (**%**, which produces the remainder from integer division). Integer division truncates, rather than rounds, the result.

Java also uses a shorthand notation to perform an operation and an assignment at the same time. This is denoted by an operator followed by an equal sign, and is consistent with all the operators in the language (whenever it makes sense). For example, to add 4 to the variable **x** and assign the result** **to **x**, use: **x += 4**.

This example shows the use of the mathematical operators:

//: c03:MathOps.java
// Demonstrates the mathematical operators.
import com.bruceeckel.simpletest.*;
import java.util.*;
public class MathOps {
static Test monitor = new Test();
// Shorthand to print a string and an int:
static void printInt(String s, int i) {
System.out.println(s + " = " + i);
}
// Shorthand to print a string and a float:
static void printFloat(String s, float f) {
System.out.println(s + " = " + f);
}
public static void main(String[] args) {
// Create a random number generator,
// seeds with current time by default:
Random rand = new Random();
int i, j, k;
// Choose value from 1 to 100:
j = rand.nextInt(100) + 1;
k = rand.nextInt(100) + 1;
printInt("j", j); printInt("k", k);
i = j + k; printInt("j + k", i);
i = j - k; printInt("j - k", i);
i = k / j; printInt("k / j", i);
i = k * j; printInt("k * j", i);
i = k % j; printInt("k % j", i);
j %= k; printInt("j %= k", j);
// Floating-point number tests:
float u,v,w; // applies to doubles, too
v = rand.nextFloat();
w = rand.nextFloat();
printFloat("v", v); printFloat("w", w);
u = v + w; printFloat("v + w", u);
u = v - w; printFloat("v - w", u);
u = v * w; printFloat("v * w", u);
u = v / w; printFloat("v / w", u);
// the following also works for
// char, byte, short, int, long,
// and double:
u += v; printFloat("u += v", u);
u -= v; printFloat("u -= v", u);
u *= v; printFloat("u *= v", u);
u /= v; printFloat("u /= v", u);
monitor.expect(new String[] {
"%% j = -?\\d+",
"%% k = -?\\d+",
"%% j \\+ k = -?\\d+",
"%% j - k = -?\\d+",
"%% k / j = -?\\d+",
"%% k \\* j = -?\\d+",
"%% k % j = -?\\d+",
"%% j %= k = -?\\d+",
"%% v = -?\\d+\\.\\d+(E-?\\d)?",
"%% w = -?\\d+\\.\\d+(E-?\\d)?",
"%% v \\+ w = -?\\d+\\.\\d+(E-?\\d)??",
"%% v - w = -?\\d+\\.\\d+(E-?\\d)??",
"%% v \\* w = -?\\d+\\.\\d+(E-?\\d)??",
"%% v / w = -?\\d+\\.\\d+(E-?\\d)??",
"%% u \\+= v = -?\\d+\\.\\d+(E-?\\d)??",
"%% u -= v = -?\\d+\\.\\d+(E-?\\d)??",
"%% u \\*= v = -?\\d+\\.\\d+(E-?\\d)??",
"%% u /= v = -?\\d+\\.\\d+(E-?\\d)??"
});
}
} ///:~

The first thing you will see are some shorthand methods for printing: the **printInt( )** prints a **String** followed by an **int** and the **printFloat( )** prints a **String** followed by a **float**.

To generate numbers, the program first creates a **Random** object. Because no arguments are passed during creation, Java uses the current time as a seed for the random number generator. The program generates a number of different types of random numbers with the **Random** object simply by calling the methods: **nextInt( )** and** nextFloat( )** (you can also call **nextLong( ) **or** nextDouble( )**).

The modulus operator, when used with the result of the random number generator, limits the result to an upper bound of the operand minus 1 (99 in this case).

####
Regular expressions

Since random numbers are used to generate the output for this program, the **expect( )** statement can’t just show literal output as it did before, since the output will vary from one run to the next. To solve this problem, *regular expressions*, a new feature introduced in Java JDK 1.4 (but an old feature in languages like Perl and Python) will be used inside the **expect( )** statement. Although coverage of this intensely powerful tool doesn’t occur until Chapter 12, to understand these statements you’ll need an introduction to regular expressions. Here, you’ll learn just enough to read the **expect( )** statements, but if you want a full description, look up **java.util.regex.Pattern** in the downloadable JDK documentation.

A regular expression is a way to describe strings in general terms, so that you can say: “If a string has these things in it, then it matches what I’m looking for.” For example, to say that a number might or might not be preceded by a minus sign, you put in the minus sign followed by a question mark, like this:

-?

To describe an integer, you say that it’s one or more digits. In regular expressions, a digit is ‘**\d**’, but in a Java **String** you have to “escape” the backslash by putting in a second backslash: ‘**\\d**’. To indicate “one or more of the preceding expression” in regular expressions, you use the ‘**+**’. So to say “possibly a minus sign, followed by one or more digits,” you write:

-?\\d+

Which you can see in the first lines of the **expect( )** statement in the preceding code.

One thing that is *not* part of the regular expression syntax is the ‘**%%**’ (note the space included for readability) at the beginning of the lines in the **expect( )** statement. This is a flag used by **simpletest** to indicate that the rest of the line is a regular expression. So you won’t see it in normal regular expressions, only in **simpletest expect( )** statements.

Any other characters that are not special characters to regular expression searches are treated as exact matches. So in the first line:

%% j = -?\\d+

The ‘j = ’ is matched exactly. However, in the third line, the ‘+’ in ‘j + k’ must be escaped because it is a special regular expression character, as is ‘*’. The rest of the lines should be understandable from this introduction. Later in the book, when additional features of regular expressions are used inside **expect( )** statements, they will be explained.

####
Unary minus and plus operators

The unary minus (-)and unary plus (+) are the same operators as binary minus and plus. The compiler figures out which use is intended by the way you write the expression. For instance, the statement

x = -a;

has an obvious meaning. The compiler is able to figure out:

x = a * -b;

but the reader might get confused, so it is clearer to say:

x = a * (-b);

Unary minus inverts the sign on the data. Unary plus provides symmetry with unary minus, although it doesn’t have any effect.