Previous   Next

Operators

The usual arithmetic operators +* / are used in Java for addition, subtraction, multiplication, and division. The / operator denotes integer division if both arguments are integers, and floating-point division otherwise. Integer remainder (that is, the mod function) is denoted by %. For example, / 2 is 7, % 2 is 1, and / 2 is 7.5. Note that integer division by 0 raises an exception, whereas floating-point division by 0 yields an infinite or NaN result. You can use the arithmetic operators in your variable initializations:

```int n = 5;
int a = 2 * n; // a is 10
```

There is a convenient shortcut for using binary arithmetic operators in an assignment. For example,

```x += 4;
```

is equivalent to

```x = x + 4;
```

(In general, place the operator to the left of the = sign, such as *= or %=.)

 One of the stated goals of the Java coding language is portability. A computation should yield the same results no matter on which virtual machine it executes. For arithmetic computations with floating-point numbers, it is surprisingly difficult to achieve this portability. The double type uses 64 bits to store a numeric value, but some processors use 80 bit floating-point registers. These registers yield added precision in intermediate steps of a computation. For example, consider the computation: ```double w = x * y / z; ``` Many Intel processors compute x * y and leave the result in an 80-bit register, then divide by z and finally truncate the result back to 64 bits. That can yield a more accurate result, and it can avoid exponent overflow. But the result may be different from a computation that uses 64 bits throughout. For that reason, the initial specification of the Java virtual machine mandated that all intermediate computations must be truncated. The numeric community hated it. Not only can the truncated computations cause overflow, they are actually slower than the more precise computations because the truncation operations take time. For that reason, the Java coding language was updated to recognize the conflicting demands for optimum performance and perfect reproducibility. By default, virtual machine designers are now permitted to use extended precision for intermediate computations. However, methods tagged with the strictfp keyword must use strict floating-point operations that yield reproducible results. For example, you can tag main as ```public static strictfp void main(String[] args) ``` Then all instructions inside the main method use strict floating-point computations. If you tag a class as strictfp, then all of its methods use strict floating-point computations. The gory details are very much tied to the behavior of the Intel processors. In default mode, intermediate results are allowed to use an extended exponent, but not an extended mantissa. (The Intel chips support truncation of the mantissa without loss of performance.) Therefore, the only difference between default and strict mode is that strict computations may overflow when default computations don't. If your eyes glazed over when reading this note, don't worry. For most programmers, this issue is not important. Floating-point overflow isn't a problem that one encounters for most common programs. We don't use the strictfp keyword in this tutorial.

Increment and Decrement Operators

Programmers, of course, know that one of the most common operations with a numeric variable is to add or subtract 1. Java, following in the footsteps of C and C++, has both increment and decrement operators: x++ adds 1 to the current value of the variable x, and x-- subtracts 1 from it. For example, the code

```int n = 12;
n++;
```

changes n to 13. Because these operators change the value of a variable, they cannot be applied to numbers themselves. For example, 4++ is not a legal statement. There are actually two forms of these operators; you have seen the "postfix" form of the operator that is placed after the operand. There is also a prefix form, ++n. Both change the value of the variable by 1. The difference between the two only appears when they are used inside expressions. The prefix form does the addition first; the postfix form evaluates to the old value of the variable.

```int m = 7;
int n = 7;
int a = 2 * ++m; // now a is 16, m is 8
int b = 2 * n++; // now b is 14, n is 8
```

We recommend against using ++ inside other expressions as this often leads to confusing code and annoying bugs. (Of course, while it is true that the ++ operator gives the C++ language its name, it also led to the first joke about the language. C++ haters point out that even the name of the language contains a bug: "After all, it should really be called ++C, since we only want to use a language after it has been improved.")

Relational and boolean Operators

Java has the full complement of relational operators. To test for equality you use a double equal sign, ==. For example, the value of

```3 == 7
```

is false. Use a != for inequality. For example, the value of

```3 != 7
```

is true. Finally, you have the usual < (less than), > (greater than), <= (less than or equal), and >= (greater than or equal) operators. Java, following C++, uses && for the logical "and" operator and || for the logical "or" operator. As you can easily remember from the != operator, the exclamation point ! is the logical negation operator. The && and || operators are evaluated in "short circuit" fashion. This means that when you have an expression like:

```A && B
```

once the truth value of the expression A has been determined to be false, the value for the expression B is not calculated. For example, in the expression

```x != 0 && 1 / x > x + y // no division by 0
```

the second part is never evaluated if x equals zero. Thus, 1 / x is not computed if x is zero, and no divide-by-zero error can occur. Similarly, if A evaluates to be true, then the value of A || B is automatically true, without evaluating B. Finally, Java supports the ternary ?: operator that is occasionally useful. The expression

```condition ? e1 : e2
```

evaluates to e1 if the condition is true, to e2 otherwise. For example,

```x < y ? x : y
```

gives the smaller of x and y.

Bitwise Operators

When working with any of the integer types, you have operators that can work directly with the bits that make up the integers. This means that you can use masking techniques to get at individual bits in a number. The bitwise operators are:

```& ("and") | ("or") ^ ("xor") ~ ("not")
```

These operators work on bit patterns. For example, if n is an integer variable, then

```int fourthBitFromRight = (n & 8) / 8;
```

gives you a one if the fourth bit from the right in the binary representation of n is one, and a zero if not. Using & with the appropriate power of two lets you mask out all but a single bit.

 When applied to boolean values, the & and | operators yield a boolean value. These operators are similar to the && and || operators, except that the & and | operators are not evaluated in "short-circuit" fashion. That is, both arguments are first evaluated before computing the result.
There are also >> and << operators, which shift a bit pattern to the right or left. These operators are often convenient when you need to build up bit patterns to do bit masking:
```int fourthBitFromRight = (n & (1 << 3)) >> 3;
```

Finally, there is even a >>> operator that fills the top bits with zero, whereas >> extends the sign bit into the top bits. There is no <<< operator.

 The right hand side argument of the shift operators is reduced modulo 32 (unless the left hand side is a long in which case the right hand side is reduced modulo 64). For example, the value of 1 << 35 is the same as 1 << 3 or 8.
 In C/C++, there is no guarantee as to whether >> performs an arithmetic shift (extending the sign bit) or a logical shift (filling in with zeroes). Implementors are free to choose whatever is more efficient. That means the C/C++ >> operator is really only defined for non-negative numbers. Java removes that ambiguity.

Mathematical Functions and Constants

The Math class contains an assortment of mathematical functions that you may occasionally need, depending on the kind of coding that you do. To take the square root of a number, you use the sqrt method:

```double x = 4;
double y = Math.sqrt(x);
System.out.println(y); // prints 2.0
```

 There is a subtle difference between the println method and the sqrt method. The println method operates on an object, System.out, and has a second parameter, namely y, the value to be printed. (Recall that out is an object defined in the System class that represents the standard output device.) But the sqrt method in the Math class does not operate on any object. It has a single parameter, x, the number of which to extract the square root. Such a method is called a static method. You will learn more about static methods in .
The Java coding language has no operator for raising a quantity to a power: you must use the pow method in the Math class. The statement
```double y = Math.pow(x, a);
```

sets y to be x raised to the power a (xa). The pow method has parameters that are both of type double, and it returns a double as well. The Math class supplies the usual trigonometric functions

```Math.sin Math.cos Math.tan Math.atan Math.atan2
```

and the exponential function and its inverse, the natural log:

```Math.exp Math.log
```

Finally, there are two constants

```Math.PI Math.E
```

that denote the closest possible approximations to the mathematical constants p and e.

 The functions in the Math class use the routines in the computer's floating-point unit for fastest performance. If completely predictable results are more important than fast performance, use the StrictMath class instead. It implements the algorithms from the "Freely Distributable Math Library" fdlibm, guaranteeing identical results on all platforms. See http://www.netlib.org/fdlibm/index.html for the source of these algorithms. (Where fdlibm provides more than one definition for a function, the StrictMath class follows the IEEE 754 version whose name starts with an "e".)

Conversions Between Numeric Types

It is often necessary to convert from one numeric type to another. Screenshot-1 shows the legal conversions:

Screenshot-1. Legal conversions between numeric types

The six solid arrows in Screenshot-1 denote conversions without information loss. The three dotted arrows denote conversions that may lose precision. For example, a large integer such as 123456789 has more digits than the float type can represent. When converting it to a float, the resulting value has the correct magnitude, but it loses some precision.

```int n = 123456789;
float f = n; // f is 1.23456792E8
```

When combining two values with a binary operator (such as n + f where n is an integer and f is a floating-point value), both operands are converted to a common type before the operation is carried out.

• If any of the operands is of type double, the other one will be converted to a double.
• Otherwise, if any of the operands is of type float, the other one will be converted to a float.
• Otherwise, if any of the operands is of type long, the other one will be converted to a long.
• Otherwise, both operands will be converted to an int.

Casts

In the preceding section, you saw that int values are automatically converted to double values when necessary. On the other hand, there are obviously times when you want to consider a double as an integer. Numeric conversions are possible in Java, but of course information may be lost. Conversions where loss of information is possible are done by means of casts. The syntax for casting is to give the target type in parentheses, followed by the variable name. For example:

```double x = 9.997;
int nx = (int)x;
```

Then, the variable nx has the value 9, as casting a floating-point value to an integer discards the fractional part. If you want to round a floating-point number to the nearest integer (which is the more useful operation in most cases), use the Math.round method:

```double x = 9.997;
int nx = (int)Math.round(x);
```

Now the variable nx has the value 10. You still need to use the cast (int) when you call round. The reason is that the return value of the round method is a long, and a long can only be assigned to an int with an explicit cast since there is the possibility of information loss.

 If you try to cast a number of one type to another that is out of the range for the target type, the result will be a truncated number that has a different value. For example, (byte)300 is actually 44. It is, therefore, a good idea to explicitly test that the value is in the correct range before you perform a cast.
 You cannot cast between boolean values and any numeric type. This prevents common errors. In the rare case that you want to convert a boolean value to a number, you can use a conditional expression such as b ? 1 : 0.

Parentheses and Operator Hierarchy

As in all coding languages, you are best off using parentheses to indicate the order in which you want operations to be carried out. However, in Java the hierarchy of operations is as shown in Table 3-4.

Table 3-4. Operator precedence

Operators

Associativity

[] . () (method call)

left to right

! ~ ++ -- + (unary) (unary) () (cast) new

right to left

* / %

left to right

+ -

left to right

<< >> >>>

left to right

< <= > >= instanceof

left to right

== !=

left to right

&

left to right

^

left to right

|

left to right

&&

left to right

||

left to right

?:

left to right

= += -= *= /= %= &= |= ^= <<= >>= >>>=

right to left

If no parentheses are used, operations are performed in the hierarchical order indicated. Operators on the same level are processed from left to right, except for those that are right associative, as indicated in the table.
 Unlike C or C++, Java does not have a comma operator. However, you can use a comma-separated list of expressions in the first and third slot of a for statement.

 Previous   Next