Basics of Java Operators

In this post, you will learn to:

• Describe an operator and explain its purpose.
• Identify and explain the use of Assignment, Arithmetic, and Unary operators.
• Identify and explain the use of Equality, Relational, and Conditional operators.
• Identify and explain the use of Bitwise and Bit Shift operators.
• Explain operator precedence.
• Explain operator associativity.

Purpose

All programming languages provide some mechanism for performing various operations on the data stored in variables. The simplest form of operations involves arithmetic (like adding, dividing, or comparing between two or more variables). A set of symbols is used to indicate the kind of operation to be performed on data. These symbols are called operators.

Consider the expression:

Z = X + Y

The + symbol in the statement is called the operator and the operation performed is addition. This operation is performed on the two variables X and Y, which are called operands. The combination of both the operator and the operands, Z = X + Y, is known as an Expression.

Java provides several categories of operators and they are as follows:

• Arithmetic
• Relational
• Logical
• Assignment
• Bitwise
• Bit Shift

Assignment Operator

The basic assignment operator is a single equal to sign, ‘=’. This operator is used to assign the value on its right to the operand on its left. Assigning values to more than one variable can be done at a time. In other words, it allows you to create a chain of assignments.

Consider the following statements:

int balance = 3456;
char gender = 'M';

In the statements, the values 3456 and M are assigned to the variables namely, balance and gender. In addition to the basic assignment operator, there are combined operators that allow you to use a value in an expression, and then set its value to the result of that expression.

X = 3;
X += 5;

The second statement stores the value 8, the meaning of the statement is that X = X + 5. The following code demonstrates the use of different assignment operators.

Code Snippet:

x = 10;      // Assigns the value 10 to variable x
x += 5;      // Increments the value of x by 5
x -= 5;      // Decrements the value of x by 5
x *= 5;      // Multiplies the value of x by 5
x /= 2;      // Divides the value of x by 2
x %= 2;      // Divides the value of x by 2 and the remainder is returned

Arithmetic Operator

Arithmetic operators manipulate numeric data and perform common arithmetic operations on the data.Operands of the arithmetic operators must be of numeric type. Boolean operands cannot be used, but character operands are allowed. The operators mentioned here are binary in nature: that is, these operate on two operands, such as X+Y. Here, + is a binary operator operating on X and Y.

The table below lists the arithmetic operators.

The following code demonstrates the arithmetic operators.

Code Snippet:

x = 2 + 3;     // Returns 5
y = 8 – 5;     // Returns 3
x = 5 * 2;     // Returns 10
x = 5/2;       // Returns 2
y = 10 % 3;    // Returns 1

Unary Operator

Unary operators require only one operand. They perform various operations, such as incrementing/ decrementing the value of a variable by 1, negating an expression, or inverting the value of a boolean.

The table below lists the unary operators.

The ++ and — operators can be applied before (prefix) or after (postfix) the operand. The statements ++variable and variable++ both result in incrementing the variable value by 1. The only difference is that the prefix version (++variable) will increment the value before evaluating, whereas the postfix version (variable++) will first evaluate and then increment the original value.

The following code demonstrates the unary operators.

Code Snippet:

int i=5;
int j=i++;   // i=6, j=5
int k=++i;   //i=6,k=6
i = - i ;    //now i is -6
boolean result = false;    //result is false
result = !result;     //now result is true

Equality and Relational Operators

Equality and relational operators test the relationship between two operands. An expression involving relational operators always evaluates to a boolean value (that is, either true or false).

The table below lists the various relational operators.

The following code demonstrates the relational operators.

Code Snippet:

int value1 = 10;
int value2 = 20;
value1 == value2;      //returns false
value1 != value2;      //returns true
value1 > value2;    //returns false
value1 < value2;    //returns true
value1 <= value2;   //returns true

Conditional Operators

Conditional operators (&& and ||) work on two boolean expressions. These operators exhibit short-circuiting behavior, which means that the second operand is evaluated only if needed.

The table below lists the two conditional operators.

Ternary operator (?:) is another type of conditional operator; it accepts three operands. The syntax for the usage of ternary operator is as follows:

expression1 ? expression2 : expression3

where,
expression1: is a boolean condition that returns a true or false value
expression2: is the value returned if expression1 evaluates true
expression3: is the value returned if expression1 evaluates false.

The following code demonstrates the conditional operators.

Code Snippet:

int first = 10;
int second = 20;
(first == 30) && (second == 20 );    //returns false
(first == 30) || (second == 20 );    //returns true
(second > first) ? "second number is greater" : "first number greater or equal";     //returns "second number is greater"

Bitwise and Bit Shift Operators

Bitwise operators work on binary representations of data. These operators are used to change individual bits in an operand. Bitwise shift operators are used to move all the bits in the operand left or right a given number of times.

The table below lists the various bitwise operators.

The following code demonstrates the bitwise operators.

Code Snippet:

int x = 23;
int y = 12;
//23 = 10111 , 12 = 01100
(x & y)    // returns 4 , i.e, 4 = 00100
(x | y)    //returns 31, i.e 31 = 11111
(x ^ y)    //returns 27, i.e 31 = 11011
int a = 43;
int b = 1;
//43 = 010011 , 1 = 000001
(a >> b)    // returns 21 , i.e, 21 = 0010101
(a << b)    //returns 86 , i.e, 86 = 1010110

Operator Precedence

Expressions that are written generally consist of several operators. The rules of precedence decide the order in which each operator is evaluated in any given expression.

The table below shows the order of precedence of operators, from highest to lowest in which operators are evaluated in Java.

Parentheses are used to change the order in which an expression is evaluated. Any part of an expression enclosed in parentheses is evaluated first. The following code demonstrates the precedence of operators in an expression.

Code Snippet:

2*3+4/2 > 3 && 3<5 || 10<9

The evaluation is as shown:

1. (2*3+4/2) > 3 && 3<5 || 10<9
First the arithmetic operators are evaluated.

2.((2*3)+(4/2)) > 3 && 3<5 || 10<9
Division and Multiplication are evaluated before addition and subtraction.

3. (6+2) >3 && 3<5 || 10<9

4. (8 >3) && [3<5] || [10<9]
Next to be evaluated are the relational operators all of which have the same precedence. These are therefore evaluated from left to right.

5. (True && True) || False
The last to be evaluated are the logical operators. && takes precedence over ||.

6. True || False

7. True

Operator Associativity

When two operators with the same precedence appear in an expression, the expression is evaluated,according to its associativity. For example, in Java the – operator has left-associativity and x – y – z is interpreted as (x – y) – z, and = has right-associativity and x = y = z is interpreted as x = (y = z).

The table below shows the Java operators and their associativity.

The following code demonstrates the associativity of operators in an expression.

Code Snippet:
Consider the following expression:

2+10+4-5*(7-1)

1. According to the rules of operator precedence, the ‘*’ has higher precedence than any other operator in the equation. Since 7-1 is enclosed in parenthesis, it is evaluated first.

2+10+4-5*6

2. Next, ‘*’ is the operator with the highest precedence. Since there are no more parentheses, it is evaluated according to the rules.

2+10+4-30

3. As ‘+’ and ‘-‘ have the same precedence, the left associativity works out.

12+4-30

4. Finally, the expression is evaluated from left to right.

16 – 30

The result is -14.