The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available.
SeeDev.java for updated tutorials taking advantage of the latest releases.
SeeJava Language Changes for a summary of updated language features in Java SE 9 and subsequent releases.
SeeJDK Release Notes for information about new features, enhancements, and removed or deprecated options for all JDK releases.

Assignment, Arithmetic, and Unary Operators

The Simple Assignment Operator

One of the most common operators that you'll encounter is the simple assignment operator "=". You saw this operator in the Bicycle class; it assigns the value on its right to the operand on its left:

 int cadence = 0; int speed = 0; int gear = 1;

This operator can also be used on objects to assignobject references, as discussed inCreating Objects.

The Arithmetic Operators

The Java programming language provides operators that perform addition, subtraction, multiplication, and division. There's a good chance you'll recognize them by their counterparts in basic mathematics. The only symbol that might look new to you is "%", which divides one operand by another and returns the remainder as its result.

The following program,ArithmeticDemo, tests the arithmetic operators.

class ArithmeticDemo {    public static void main (String[] args) {        int result = 1 + 2;        // result is now 3        System.out.println("1 + 2 = " + result);        int original_result = result;        result = result - 1;        // result is now 2        System.out.println(original_result + " - 1 = " + result);        original_result = result;        result = result * 2;        // result is now 4        System.out.println(original_result + " * 2 = " + result);        original_result = result;        result = result / 2;        // result is now 2        System.out.println(original_result + " / 2 = " + result);        original_result = result;        result = result + 8;        // result is now 10        System.out.println(original_result + " + 8 = " + result);        original_result = result;        result = result % 7;        // result is now 3        System.out.println(original_result + " % 7 = " + result);    }}

This program prints the following:

1 + 2 = 33 - 1 = 22 * 2 = 44 / 2 = 22 + 8 = 1010 % 7 = 3

You can also combine the arithmetic operators with the simple assignment operator to createcompound assignments. For example,x+=1; andx=x+1; both increment the value ofx by 1.

The+ operator can also be used for concatenating (joining) two strings together, as shown in the followingConcatDemo program:

class ConcatDemo {    public static void main(String[] args){        String firstString = "This is";        String secondString = " a concatenated string.";        String thirdString = firstString+secondString;        System.out.println(thirdString);    }}

By the end of this program, the variablethirdString contains "This is a concatenated string.", which gets printed to standard output.

The Unary Operators

The unary operators require only one operand; they perform various operations such as incrementing/decrementing a value by one, negating an expression, or inverting the value of a boolean.

The following program,UnaryDemo, tests the unary operators:

class UnaryDemo {    public static void main(String[] args) {        int result = +1;        // result is now 1        System.out.println(result);        result--;        // result is now 0        System.out.println(result);        result++;        // result is now 1        System.out.println(result);        result = -result;        // result is now -1        System.out.println(result);        boolean success = false;        // false        System.out.println(success);        // true        System.out.println(!success);    }}

The increment/decrement operators can be applied before (prefix) or after (postfix) the operand. The coderesult++; and++result; will both end inresult being incremented by one. The only difference is that the prefix version (++result) evaluates to the incremented value, whereas the postfix version (result++) evaluates to the original value. If you are just performing a simple increment/decrement, it doesn't really matter which version you choose. But if you use this operator in part of a larger expression, the one that you choose may make a significant difference.

The following program,PrePostDemo, illustrates the prefix/postfix unary increment operator:

class PrePostDemo {    public static void main(String[] args){        int i = 3;        i++;        // prints 4        System.out.println(i);        ++i;           // prints 5        System.out.println(i);        // prints 6        System.out.println(++i);        // prints 6        System.out.println(i++);        // prints 7        System.out.println(i);    }}