Operator precedence table in java

Java Operators: Precedence and Associativity

A Java operator is a special symbol that performs specific operation on one, two, or three operands depending upon the type of the operator and returns a result.

Java provides a rich set of operators that are classified on two bases. First, on the basis of number of operands an operator performs upon. Second, on the type or nature of operation an operator performs.

By first classification, Java operators can be unary, binary, or ternary. Unary operators operate on one operand e.g., ++ , and — . Binary operators operator on two operands. All arithmetic operators are example of binary operators. Third, special type operator is ternary operator. Ternary operator operates on three operands. Java has only one ternary operator, which is also called conditional operator. It is a combination of two symbols ? and : .

Another classification is based on the type of operation they perform. On the basis of the type of operation operators can be classified in following categories:

Evaluation Order of an Expression

In Java when an expression is evaluated, there may be more than one operators involved in an expression. When more than one operator has to be evaluated in an expression Java interpreter has to decide which operator should be evaluated first. Java makes this decision on the basis of the precedence and the associativity of the operators.

Java Operators Precedence and Associativity

Java operators have two properties those are precedence, and associativity. Precedence is the priority order of an operator, if there are two or more operators in an expression then the operator of highest priority will be executed first then higher, and then high. For example, in expression 1 + 2 * 5, multiplication (*) operator will be processed first and then addition. It’s because multiplication has higher priority or precedence than addition.

Alternatively, you can say that when an operand is shared by two operators (2 in above example is shared by + and *) then higher priority operator picks the shared operand for processing. From above example you would have understood the role of precedence or priority in execution of operators. But, the situation may not be as straightforward every time as it is shown in above example. What if all operators in an expression have same priority? In that case the second property associated with an operator comes into play, which is associativity. Associativity tells the direction of execution of operators that can be either left to right or right to left. For example, in expression a = b = c = 8 the assignment operator is executed from right to left that means c will be assigned by 8, then b will be assigned by c, and finally a will be assigned by b. You can parenthesize this expression as (a = (b = (c = 8))) .

Note that, you can change the priority of a Java operator by enclosing the lower order priority operator in parentheses but not the associativity. For example, in expression (1 + 2) * 3 addition will be done first because parentheses has higher priority than multiplication operator.

Before discussing individual classes of operators, below table presents all Java operators from highest to lowest precedence along with their associativity.

Table 1: Java operators — precedence chart highest to lowest

Precedence	Operator	Description	Associativity
1	[] () .	array index method call member access	Left -> Right
2	++ — + — ~ !	pre or postfix increment pre or postfix decrement unary plus, minus bitwise NOT logical NOT	Right -> Left
3	(type cast) new	type cast object creation	Right -> Left
4	* / %	multiplication division modulus (remainder)	Left -> Right
5	+ — +	addition, subtraction string concatenation	Left -> Right
6	>> >>>	left shift signed right shift unsigned or zero-fill right shift	Left -> Right
7	< > >= instanceof	less than less than or equal to greater than greater than or equal to reference test	Left -> Right
8	== !=	equal to not equal to	Left -> Right
9	&	bitwise AND	Left -> Right
10	^	bitwise XOR	Left -> Right
11	|	bitwise OR	Left -> Right
12	&&	logical AND	Left -> Right
13	||	logical OR	Left -> Right
14	? :	conditional (ternary)	Right -> Left
15	= += -= *= /= %= &= ^= |= <>>= >>>=	assignment and short hand assignment operators	Right -> Left

Last Word

In this tutorial we talked of Java operators’ precedence and associativity. Hope you have enjoyed reading this tutorial. Please do write us if you have any suggestion/comment or come across any error on this page. Thanks for reading!

References

Источник

Operators

Now that you’ve learned how to declare and initialize variables, you probably want to know how to do something with them. Learning the operators of the Java programming language is a good place to start. Operators are special symbols that perform specific operations on one, two, or three operands, and then return a result.

As we explore the operators of the Java programming language, it may be helpful for you to know ahead of time which operators have the highest precedence. The operators in the following table are listed according to precedence order. The closer to the top of the table an operator appears, the higher its precedence. Operators with higher precedence are evaluated before operators with relatively lower precedence. Operators on the same line have equal precedence. When operators of equal precedence appear in the same expression, a rule must govern which is evaluated first. All binary operators except for the assignment operators are evaluated from left to right; assignment operators are evaluated right to left.

Operator Precedence

Operators	Precedence
postfix	expr++ expr—
unary	++expr —expr +expr —expr ~ !
multiplicative	* / %
additive	+ —
shift	> >>>
relational	< >= instanceof
equality	== !=
bitwise AND	&
bitwise exclusive OR	^
bitwise inclusive OR	|
logical AND	&&
logical OR	||
ternary	? :
assignment	= += -= *= /= %= &= ^= |= <>= >>>=

In general-purpose programming, certain operators tend to appear more frequently than others; for example, the assignment operator » = » is far more common than the unsigned right shift operator » >>> «. With that in mind, the following discussion focuses first on the operators that you’re most likely to use on a regular basis, and ends focusing on those that are less common. Each discussion is accompanied by sample code that you can compile and run. Studying its output will help reinforce what you’ve just learned.

Previous page: Questions and Exercises: Variables
Next page: Assignment, Arithmetic, and Unary Operators

Источник

Operator Precedence in Java

There exist many arithmetics and logical operators in Java like +, -, /, *, &, |, etc that can be applied in an expression. Operator precedence in java is a set of rules which tells the compiler the order in which the operators given in a particular expression are evaluated if there are multiple operators in a single expression.

Java Operator Precedence

During our primary schooling, we learned about the BODMAS rule which helps us to determine which operator to be solved first if many operators are there in a given equation. Similarly, we have the operator precedence in java which is a set of rules that tells us the precedence of different operators, and as per the rule operator with higher precedence is evaluated first. For example in the expression x * y — z the * operator will be evaluated before the — operator, because the * operator has higher precedence than the — operator. The precedence of each operator has been clearly defined which is also shown in the table given later in the article. Note that it is always possible to modify the result of an expression by placing parentheses in the original expression. For example — 20 / 2 * 5 will evaluate to 50 but if we want to get 2 as result we can modify the expression to 20 / (2 * 5) .

Operator Associativity — So we have seen that the operator with higher precedence is evaluated first. But if two operators in an expression are with the same precedence then the operator and operand are grouped according to their associativity. The associativity of each operator has also been clearly defined in the table given in the next section. For example — 50 / 2 / 5 will be treated as (50 / 2) / 2 because the / operator is left-to-right associative.

Java Operator Precedence Table

The following table well defines the precedence of operators in java. Here the operators present at top of the table have higher precedence while those who are placed lower in the table have lower precedence.

Operator	Description	Precedence	Associativity
() [] .	Parentheses Array Subscript Member Function	16	Left to Right
++ —	Unary Post Increment Unary Post Decrement	15	Right to Left
++ — + — ! ~	Unary Pre Increment Unary Pre Decrement Unary Addition Unary Subtraction Unary Logical Negation Unary Bitwise Complement	14	Right to Left
() new	Cast Object Creation	13	Right to Left
* / %	Multiplication Division Modulus	12	Left to Right
+ —	Addition Subtraction	11	Left to Right
>>	Bitwise Right Shift Bitwise Left Shift	10	Left to Right
> >= instanceof	Less than Less than or equal Greater than Greater than or equal Type Comparison	9	Left to Right
== !=	Equal to Not equal to	8	Left to right
&	Bitwise AND	7	Left to Right
^	Bitwise XOR	6	Left to Right
|	Bitwise OR	5	Left to Right
&&	Logical AND	4	Left to Right
||	Logical OR	3	Left to Right
?:	Ternary Conditional	2	Right to Left
= += -= *= /= %=	Assignment Addition Assignment Subtraction Assignment Multiplication Assignment Division Assignment Modulus Assignment	1	Right to Left

Examples of Operator Precedence in Java

Example 1

The precedence of * and / is greater than that of + operator hence they will be evaluated. Also, * and / are of the same precedence so they will be associated in left to right order. Therefore —
ans = x + y * z / 10

is equivalent to ans = x + ((y * z) / 10)

Example 2

The precedence of ++ and — is greater than that of -, and + operators. Hence, ans = x + —y — ++z

is equivalent to ans = x + (—y) — (++b)

Example 3

is equivalent to ans = (((++x) + (++y) + 5)

which will be solved like —

Practice Questions

Question 1

Evaluate the following expression — 20 + 12 — 15 * 2 / 2 / 5

Answer — 29

Explanation
Since the precedence of * and / is greater than that of + and — operators. 20 + 12 — 15 * 2 / 2 / 5 is equivalent to
20 + 12 — (((15 * 2) / 2) / 5) . 32 — ((30 / 2) / 5)
32 — (15 / 5)
32 — 3
29

Question 2

Evaluate the following expression — 10 | 8 + 12 — 5 * 4 / 10

Answer — 26

Explanation
Since the precedence of * and / is greater than that of ** |, + and — **operators. 10 | 8 + 12 — 5 * 4 / 10 is equivalent to
10 | (8 + 12 — ((5 * 4) / 10))
10 | (8 + 12 — (20 / 10))
10 | (8 + 12 — (20 / 10))
10 | (8 + 12 — 2) . 10 | 18 . 26

Question 3

Evaluate the following expression — 10 + ((15 — 20) * (2 / 2)) / 5

Answer — 9

Explanation
Since parentheses have the highest precedence among all the operators, expressions written inside them will be evaluated first.

10 + ((15 — 20) * (2 / 2)) / 5 . 10 + (-5 * 1) / 5
10 + -5 / 5
10 + (-1)
9

Question 4

Predict the output of the following code

Explanation
The precedence of the assignment operator = is the least, and equal to the operator ( == ) is left to right-associative.

x == y == z is equivalent to
(x == y) == z
(false == true) == false
false == false
true

Question 5

Predict the output of the following code

Explanation
The above code results in a compile-time error because Java parses the statement as ++(++x) and the term ++x increases the value by 1 and evaluates it to 6 now we will have ++6 which is illegal because the pre-increment operator in java can only be applied to a variable, not to a value.

Conclusion

• Operator precedence in java determines the order in which the operators given in a particular expression are evaluated if there are multiple operators in a single expression.
• Operators with higher precedence are evaluated before the operator(s) with lower precedence.
• If two operators have the same level of precedence then the tie is broken by their associativity.

Источник