## Introduction

In mathematics an *expression* is of the form **y = 2x + 8**. In Java, an expression is quite similar. It is a properly formed sequence of variables, constants, methods, special symbols, and *operators*. In this tutorial we will see how operators and expressions are used to solve complex problems in Java.

Java has several operator groups. We will cover the most common groups: *Arithmetic*, *Relational*, *Boolean* *Logical*, and *Assignment*. Other groups include *Bitwise* and *Ternary* (?) operators. There are a few differences, but most operators will be familiar if you have experience with another programming language. Many are derived from common mathematical operations.

## Arithmetic Operators

The Java Arithmetic operators perform common math operations, and are shown in the following table.

Operator |
Operation |
Example |

+ | Addition | x + y |

– | Subtraction | x – y |

* | Multiplication | x * y |

/ | Division | x / y |

% | Modulus | x % y |

++ | Increment | x++ |

— | Decrement | x- – |

+= | Addition Assignment | x += y |

-= | Subtraction Assignment | x -= y |

*= | Multiplication Assignment | x *= y |

/= | Division Assignment | x /= y |

%= | Modulus Assignment | x %= y |

The modulus operator, “**%**“, returns the remainder of a division; for example, **3 / 2 = 1**, with a remainder of **1**.

1 |
z = 3 % 2; // z now equals 1. |

The increment operator, “**++**“, automatically adds **1** and stores the result into the original variable. The statement “**x++;**” is equivalent to “**x = x + 1;**“. It is commonly used in **for** loops and indexing arrays.

1 2 |
int x = 7; x++; // x now equals 8. Same as x = x + 1; |

The decrement operator, “

“, automatically subtracts **--****1** and stores the result into the original variable. The statement “

” is equivalent to “**x--;****x = x – 1;**“. It is commonly used in **for** loops which count down (eg. counting down from 10 to 1) as the following program does.

1 2 3 4 5 6 7 |
class Test { public static void main(String args[]) { for (int x = 10; x > 0; x--) { System.out.println("Countdown is " + x); } } } |

The Addition, Subtraction, Multiplication, and Modulus Assignment statements may look odd at first, but they are really just a shorthand way of using the more familiar statements. For example, the following two statements are equivalent, but the second one requires less typing.

1 2 |
x = x + y; x += y; |

### Relational Operators

The Java Relational operators compare two values for equality or ordering, and are shown in the following table.

Operator |
Operation |
Example |

== | Equal to | if (n == 10) { |

!= | Not equal to | if (n != 10) { |

> | Greater than | if (n > 10) { |

< | Less than | if (n < 10) { |

>= | Greater than or equal to | if (n >= 10) { |

<= | Less than or equal to | if (n <= 10) { |

These operations always return a **boolean** value, and are most frequently used in expressions that control the **if** statement or Java’s looping statements such as **while** and **for**. The following code fragments demonstrate how they are used.

1 2 3 4 5 |
while (done == false) { while (moreToDo == true) { while (speed <= maxSpeed) { if (inventory > itemsOrdered) { for (int speed = 0; speed <= maxSpeed; speed++) { |

### Boolean Logical

The Java Boolean Logical operators operate only on **boolean** operands. They all combine two boolean values to form a resultant boolean value. The operators are shown in the following table.

Operator |
Operation |
Example |

! | Logical unary NOT | if (!done) { |

& | Logical AND | if ( (a < 5) & (b > 10) ) { |

| | Logical OR | if ( (a < 5) | (b > 10) ) { |

&& | Short-circuit AND | if ( (a < 5) && (b > 10) ) { |

|| | Short-circuit OR | if ( (a < 5) || (b > 10) ) { |

== | Equal to | if (a == 5) { |

The Boolean Logical operators are often described in a **Truth Table**. A Truth Table works similar to a multiplication table – select values for **A** and **B**, then go across the table to the appropriate column, and read the resultant value. For example, if **A** is **true** and **B** is **false**, then **A & B** is **false**. Similarly, if **A** is **true**, then** !**A (ie., NOT **A**) returns **false** because the opposite of **true** is **false**.

A |
B |
A & B |
A | B |
!A |

true |
true |
true | true | false |

true |
false |
false | true | false |

false |
true |
false | true | true |

false |
false |
false | false | true |

The **&** and **|** operators evaluate both sides of the argument before deciding on the result. The **&&** and **||** operators are called short-circuit operators because they avoid the evaluation of right-hand operands if it need not be performed. For example, in the snippet below if the value of **cost** is greater than **$9.99** , then the Java VM will not need to evaluate the right side of the expression (ie. is **InInventory ==** **true**) because the condition has already been satisfied. This saves a little bit of computer processing time.

1 |
if ( (cost > 9.99) || (inInventory == true) ) { |

It is common practice to use the short-circuit forms in cases involving Boolean logic.

### Assignment Operator

Java has only one Assignment operator: the **equal sign**.

Operator |
Operation |
Example |

= | Assigns to | area = width * height; |

## Expressions

We briefly touched on expressions in Tutorial 2, and will now discuss them in detail.

Expressions will be evaluated according to the rules of precedence, where all operations of higher precedence are performed before those of lower precedence. Operations contained within parenthesis are performed first, and if necessary parenthesis can be nested to ensure the proper order or for clarity. Operations of equal precedence are performed from left to right.

The order of precedence is:

- inside parenthesis
- multiplication, division
- addition, subtraction

As an example, consider:

**(6.0 * Math.cos(45.0)) + x * y – a / d**

The compiler scans the expression from left to right, looking for the highest precedence operator. It then determines a value for **Math.cos(pi)** and multiplies it by **6**. The intermediate result is 3.15. The expression is scanned again from left to right. Values for **x * y** and **a / d** are determined on this scan. Finally, it is scanned again from left to right, and the addition and subtraction operations are performed.

We can write and run a Java program that performs operations on the above expression.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
/* Program5a is a program that demonstrates operators and the evaluation of expressions. */ class Program5a{ public static void main(String args[]) { double r, x, y, a, d; r = 0.0; x = 3.0; y = 4.0; a = 1.0; d = 2.0; r = (6.0 * Math.cos(45.0)) + x * y - a / d; System.out.println("The answer is " + r); } } |

You can use a calculator to confirm this result; just be sure to use **radians** instead of **degrees** when performing the **cos()** operation.

Consider the expression:

1 |
x / y + z |

Java evaluates this as:

1 2 3 |
x --- + z y |

rather than as:

1 2 3 |
x --- y + z |

You can use parenthesis to ensure the proper order or for clarity depending upon what you want to do.

**(x / y) + z**

** x / (y + z)**

An expression may also be a String or string variable.

1 2 3 4 |
String doe = "do"; String ray = "ray"; String me = "me"; String song = doe + " " + ray + " " + me + " " + "fa so la te do"; |

## Examples of Using Operators and Expressions in Java

Here is a variety of examples of valid Java statements which use operators and expressions.

1 2 3 4 |
a = r * c + x / y; x = (a + b - c) / d; e = (2 * (a + b)) / (c + (d * 3)); fullName = firstName + " " + lastName; |

An example of a fairly long and complex expression that you can enter and run is in the Java Snippet Evaluate a Polynomial.

## Summary

In this tutorial we learned how operators are used to create complex expressions to do useful work such as mathematical calculations and String manipulation.

## Next Lesson

Next we will move on to **Simple Console Input/Output** which will enable us to enter values for variables at runtime and to display the results on the user’s screen.