![\"Java](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/01\/Operators-in-Java-DF.jpg\")
<\/a><\/p>\nJava Operators<\/h3>\n
Operators in Java are a special type of tokens in Java which, when coupled with entities such as variables or constants or datatypes, result in a specific operation such as addition, multiplication, or even shifting of bits.<\/p>\n
Java Operators are mainly of the following types:<\/strong><\/p>\n Java Arithmetic Operators are used to perform arithmetic operations. There are mainly 5 Arithmetic Operators in Java.<\/p>\n a. Addition(+) Java program to illustrate Arithmetic Operators:<\/strong><\/p>\n Output:<\/strong><\/p>\n Java Logical Operators, as the name suggests, perform logical operations on the two operands. There are primarily two types of logical operators<\/p>\n Java Logical AND checks whether the two conditions on either side of the expression is true. If both the expressions are true then it returns false.<\/p>\n This checks whether either of the two conditions in the expression is true. If any one of the expressions is true, it evaluates to true. However, if none of the conditions are true, then it returns false. One thing to note is that if the first expression is already true, it doesn’t check the second expression and returns true.<\/p>\n Java program to illustrate Logical Operators in Java:<\/strong><\/p>\n Output:<\/strong><\/p>\n As the name represents, Unary means one. This operator works with only one operand. Below are the following types of unary operators in Java. Let\u2019s learn the operations that will be performed on a single operand. These are the types of Unary operators:<\/p>\n 1.<\/strong> Unary plus Operator The Unary plus operator converts byte, short, and character datatype values into integer values. However, it is redundant since an explicit conversion of a character to an integer can also be done. Characters when converted to integers, return their ASCII value.<\/p>\n The unary negative operator works by adding a minus (-) to a value, which means a positive value will become negative, and a negative value will get converted to a positive value.<\/p>\n Java increment operator is used for increasing the value of a variable by one. However, there are a few concepts linked with the increment operator.<\/p>\n Java decrement operator is just the opposite of the increment operator. It decreases the value of the variable by 1.<\/p>\n Java logical NOT operator flips the value of a Boolean value. It is denoted by a !.<\/p>\n Java program to understand the concept of Unary Operators:<\/strong><\/p>\n Output:<\/strong><\/p>\n Java Assignment operators are used to assign values to the variables on the left side of the equals sign. The associativity is from right to left. Meaning that the values on the right are assigned to the values on the left. The right-hand side has to be a constant or a defined variable.<\/p>\n There are the following types of assignment operators:<\/strong><\/p>\n 1.<\/b> += This returns left=left+right An example of a Java assignment operator:<\/strong><\/p>\n Output:<\/strong><\/p>\n Java ternary operator minimizes and mimics the if-else statement. It consists of a condition followed by a question mark(?). It contains two expressions separated by a colon(:). If the condition evaluates to true, then the first expression is executed, the second expression is executed.<\/p>\n Syntax of the ternary operator in Java:<\/strong> Java program to evaluate the ternary operator:<\/strong><\/p>\n Output:<\/strong><\/p>\n Java Relational Operators are used to check the relation between values or variables. The output of relational operators is always a Boolean value. Relational operators are used in if conditions and for loop constraints.<\/p>\n Some relational operators are:<\/strong><\/p>\n a.<\/strong> <(Less than) -returns true if the left entity is less than the right entity Program to implement Java relational operators:<\/strong><\/p>\n Output:<\/strong><\/p>\n Java Bitwise operators are generally used to perform operations on bits of data. The individual bits of a number are considered in the calculation and not the entire number itself. There are the following types of bitwise operators:<\/p>\n a.<\/strong> AND(&) Java program to understand the Bitwise Operators:<\/strong><\/p>\n Output:<\/strong><\/p>\n Java Shift Operators are also a part of bitwise operators. There are the following types of shift operators.<\/p>\n a. Left Shift-<\/strong> Shifts the bits of the number two places to the left and fills the voids with 0\u2019s. Example program in Java to understand shift operators:<\/strong><\/p>\n Output:<\/strong><\/p>\n This is a type-check operator. Hence, it checks whether a particular object is an instance of a certain class or not. Java program to test the instanceOf Operator:<\/strong><\/p>\n Output:<\/strong><\/p>\n Precedence<\/strong> of operators defines which operator will be executed first if both operators are mentioned in a single expression.<\/p>\n Example in the expression – a+b*c. Here, the compiler will read it as (a + (b*c)).<\/p>\n Association<\/strong> is the method by which the compiler decides which expression to evaluate first if the operators are of the same precedence.<\/p>\n For example, the expression a=b=c=100 will be evaluated by the compiler as (a=(b=(c=100)))<\/p>\n The association groups the expressions. However, some operators do not have an order of association. These are called non-associative operators. Associative is of two types, namely left-to-right and right-to-left.<\/p>\n A table with the operator precedences in Java is mentioned below<\/strong>:<\/p>\n In conclusion, we did learn a lot about Java operators and their types. A good knowledge of operators and when to use them would allow us to develop our programming skills to a great extent. Therefore, it’s critical to take into account the operators’ potential effects on performance when selecting them.<\/p>\n However, in comparison to other operators, some may be computationally more expensive. In certain situations, repeated division might prove more efficient than the modulo operator (%). By keeping these performance considerations in mind, you can write optimized Java code<\/p>\n","protected":false},"excerpt":{"rendered":" Java Operators are of prime importance in Java. Without operators, we wouldn’t be able to perform logical and arithmetic calculations in our programs. Thus, having operators is an integral part of a programming language....<\/p>\n","protected":false},"author":5,"featured_media":78492,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[32],"tags":[7625,20701,9287,15084,20702],"class_list":["post-6438","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-operators-list","tag-java-operators-with-example","tag-operators-in-java","tag-types-of-operators-in-java","tag-what-are-java-operators"],"yoast_head":"\n\n
Arithmetic Operators in Java<\/h3>\n
\nb. Multiplication(*)
\nc. Subtraction(-)
\nd. Division(\/)
\ne. Modulo(%)<\/p>\n\n
package com.dataflair.operators;\r\nimport java.io. * ;\r\npublic class ArithmeticOperator {\r\n public static void main(String[] args) throws IOException {\r\n int add,\r\n sub,\r\n mul,\r\n div,\r\n mod;\r\n int num1 = 5,\r\n num2 = 8;\r\n add = num1 + num2;\r\n sub = num1 - num2;\r\n mul = num1 * num2;\r\n div = num1 \/ num2;\r\n mod = num2 % num1;\r\n System.out.println(\"Addition num1+num2 \" + add);\r\n System.out.println(\"Subtraction num1-num2 \" + sub);\r\n System.out.println(\"Multiplication num1*num2 \" + mul);\r\n System.out.println(\"Division num1\/num2 \" + div);\r\n System.out.println(\"Modulus num2%num1 \" + mod);\r\n }\r\n}<\/pre>\n
\nSubtraction num1-num2 -3
\nMultiplication num1*num2 40
\nDivision num1\/num2 0
\nModulus num2%num1 3<\/div>\nLogical Operators in Java<\/h3>\n
1. Logical AND in Java<\/h4>\n
2. Logical OR in Java<\/h4>\n
package com.dataflair.operators;\r\nimport java.io. * ;\r\nimport java.util. * ;\r\npublic class LogicalOperator {\r\n public static void main(String[] args) throws IOException {\r\n Scanner sc = new Scanner(System. in );\r\n String uname;\r\n String course;\r\n System.out.println(\"Enter the username\");\r\n System.out.println(\"Enter the course\");\r\n uname = sc.next();\r\n course = sc.next();\r\n if (uname.equals(\"DataFlair\") && course.equals(\"Java\")) {\r\n System.out.println(\"Your course is going on at DataFlair\");\r\n }\r\n System.out.println(\"Enter the username\");\r\n System.out.println(\"Enter the course\");\r\n uname = sc.next();\r\n course = sc.next();\r\n if (uname.equals(\"DataFlair\") || course.equals(\"Python\")) {\r\n System.out.println(\"You are either studying at Dataflair or studying python\");\r\n }\r\n\r\n }\r\n}<\/pre>\n
\nEnter the course
\nDataFlair
\nJava
\nYour course is going on at DataFlair
\nEnter the username
\nEnter the course
\nDataFlair
\nRuby
\nYou are either studying at Dataflair or studying Python<\/div>\nUnary Operator in Java<\/h3>\n
\n2.<\/strong> Unary minus Operator
\n3.<\/strong> Increment Operator
\n4.<\/strong> Decrement Operator
\n5.<\/strong> Logical Not Operator<\/p>\n1. Unary plus operator in Java<\/h4>\n
2. Unary Negative Operator in Java<\/h4>\n
3. Increment Operator in Java<\/h4>\n
\n
4. Decrement Operator in Java<\/h4>\n
\n
5. Logical Not Operator in Java<\/h4>\n
package com.dataflair.operators;\r\nimport java.io. * ;\r\nimport java.util. * ;\r\nclass UnaryOperator {\r\n public static void main(String[] args) throws IOException {\r\n int num1 = 10,\r\n num2 = 5,\r\n res;\r\n int num3 = 1;\r\n boolean flag = true;\r\n char character = 'a';\r\n\r\n res = +character; \/\/The unary + converts the character into a integer value\r\n System.out.println(\"The + operator on character transforms it to ASCII value \" + res);\r\n num3 = -num3;\r\n System.out.println(\"The - operator on num1 positive value \" + num3);\r\n res = num1++; \/\/First res=num1 then num1++ executed\r\n System.out.println(\"The res=num1++ returned value of \" + res);\r\n res = ++num1; \/\/First num1=num1+1 then res=num1\r\n System.out.println(\"The res=++num1 returned num1 value of \" + res);\r\n res = num2--; \/\/First res=num2 then num2=num2-1 executed\r\n System.out.println(\"The res=num2-- returned value of \" + res);\r\n res = --num2; \/\/First num2=num2-1 then res=num2 executed\r\n System.out.println(\"The res=--num2 returned num1 value of \" + res);\r\n \/\/Learning about NOT operator\r\n System.out.println(\"The NOT operator returns num1 value of \" + !flag);\r\n\r\n }\r\n}<\/pre>\n
\nThe – operator on num1 positive value -1
\nThe res=num1++ returned value of 10
\nThe res=++num1 returned num1 value of 12
\nThe res=num2– returned value of 5
\nThe res= –num2 returned num1 value of 3
\nThe NOT operator returns num1 value of false<\/div>\nAssignment Operators in Java<\/h3>\n
\n2.<\/strong> -= This returns left=left-right
\n3.<\/strong> *= This returns left=left*right
\n4.<\/strong> \/= This returns left=left\/right
\n5.<\/strong> %=This returns left=left%right<\/p>\npackage com.dataflair.operators;\r\nimport java.io. * ;\r\nimport java.util. * ;\r\npublic class AssignmentOperator {\r\n public static void main(String[] args) throws IOException {\r\n int num1 = 10,\r\n num2 = 5,\r\n result;\r\n num1 += 5; \/\/action of num1=num1+ 5\r\n System.out.println(\"The output of num1+=5 is \" + num1);\r\n num1 -= 5; \/\/action of num1=num1+ 5\r\n System.out.println(\"The output of num1-=5 is \" + num1);\r\n num1 *= 5; \/\/action of num1=num1+ 5\r\n System.out.println(\"The output of num1*=5 is \" + num1);\r\n num1 \/= 5; \/\/action of num1=num1+ 5\r\n System.out.println(\"The output of num1\/=5 is \" + num1);\r\n num1 %= 5; \/\/action of num1=num1+ 5\r\n System.out.println(\"The output of num1%=5 is \" + num1);\r\n }\r\n}<\/pre>\n
\nThe output of num1-=5 is 10
\nThe output of num1*=5 is 50
\nThe output of num1\/=5 is 10
\nThe output of num1%=5 is 0<\/div>\nTernary Operators in Java<\/h3>\n
\n(Condition)?(expression 1):(expression 2);<\/p>\npackage com.dataflair.operators;\r\nimport java.io. * ;\r\nimport java.util. * ;\r\npublic class TernaryOperator {\r\n public static void main(String[] args) throws IOException {\r\n int num1 = 10,\r\n num2 = 5,\r\n result;\r\n String result = (num1 == 10) ? \"num1 has value of 10\": \"num1 does not have value of 10\";\r\n System.out.println(s); \/\/the value of s is printed\r\n result = (num2 == 10) ? \"num2 has value of 10\": \"num2 does not have value of 10\";\r\n System.out.println(result); \/\/the value of result is printed\r\n\r\n }\r\n\r\n}<\/pre>\n
\nnum2 does not have value of 10<\/div>\nRelational Operators in Java<\/h3>\n
\nb.<\/strong> >(Greater than)- returns true if the left entity is greater than the right entity.
\nc.<\/strong> <=(Less than or equal to)- returns true if the left entity is smaller than or equal to the right entity.
\nd.<\/strong> >=(Greater than or equal to)- returns true if the left variable is greater than or equal to the right entity
\ne.<\/strong> ==(equals to) – returns true if the left and the right entities are equal
\nf. <\/strong><\/span>!=(not equals to) – returns true if the left and right entities are not equal.<\/p>\npackage com.dataflair.operators;\r\nimport java.io. * ;\r\nimport java.util. * ;\r\npublic class RelationalOperator {\r\n public static void main(String[] args) throws IOException {\r\n int num1 = 10,\r\n num2 = 5,\r\n e;\r\n System.out.println(\"The values of num1 and num2 are \" + num1 + \" \" + num2 + \" respectively\");\r\n System.out.println(\"The value returned when num1>num2 is checked \" + (num1 > num2));\r\n System.out.println(\"The value returned when num1<num2 is checked \" + (num1 < num2));\r\n System.out.println(\"The value returned when num1>=num2 is checked \" + (num1 >= num2));\r\n System.out.println(\"The value returned when num1<=num2 is checked \" + (num1 <= num2));\r\n System.out.println(\"The value returned when num1==num2 is checked \" + (num1 == num2));\r\n System.out.println(\"The value returned when num1!=num2 is checked \" + (num1 != num2));\r\n\r\n }\r\n\r\n}<\/pre>\n
\nThe value returned when num1>num2 is checked true
\nThe value returned when num1<num2 is checked false
\nThe value returned when num1>=num2 is checked true
\nThe value returned when num1<=num2 is checked false
\nThe value returned when num1==num2 is checked false
\nThe value returned when num1!=num2 is checked true<\/div>\nBitwise Operators in Java<\/h3>\n
\nb.<\/strong> OR(|)
\nc.<\/strong> XOR(^)
\nd.<\/strong> COMPLEMENT(~)<\/p>\npackage com.dataflair.operators;\r\nimport java.io. * ;\r\nimport java.util. * ;\r\npublic class BitwiseOperator {\r\n public static void main(String[] args) throws IOException {\r\n int num1 = 10,\r\n num2 = 5,\r\n e;\r\n \/\/num1=10 1010\r\n \/\/num2=5 0101\r\n\r\n System.out.println(\"The result after performing num1&num2 \" + (num1 & num2));\r\n System.out.println(\"The result after performing num1|num2 \" + (num1 | num2));\r\n System.out.println(\"The result after performing num1^num2 \" + (num1 ^ num2));\r\n System.out.println(\"The result after performing ~num2 \" + (~num2));\r\n\r\n }\r\n\r\n}<\/pre>\n
\nThe result after performing num1|num2 15
\nThe result after performing num1^num2 15
\nThe result after performing ~num2 -6<\/div>\nShift Operators in Java<\/h3>\n
\nb. Right Shift-<\/strong> Shifts the bits of the number two places to the right and fills the voids with 0\u2019s. The sign of the number decides the value of the left bit.
\nc. Unsigned Right Shift-<\/strong> It is also the same as the right shift; however, it changes the leftmost digit\u2019s value to 0.<\/p>\npackage com.dataflair.operators;\r\nimport java.io. * ;\r\nimport java.util. * ;\r\npublic class ShiftOperator {\r\n public static void main(String[] args) throws IOException {\r\n int num1 = 10,\r\n num2 = 5,\r\n e;\r\n \/\/num1=10 1010\r\n \/\/num2=5 0101\r\n System.out.println(\"The result after performing left shift \" + (num1 << 2));\r\n System.out.println(\"The result after performing right signed shift \" + (num1 >> 2));\r\n System.out.println(\"The result after performing right unsigned shift \" + (num1 >>> 2));\r\n\r\n }\r\n\r\n}<\/pre>\n
\nThe result after performing right signed shift 2
\nThe result after performing right unsigned shift 2<\/div>\ninstanceOf Operator in Java<\/h3>\n
\nIt returns true if the object is a member of the class and false if not.<\/p>\npackage com.dataflair.operators;\r\nimport java.io. * ;\r\nimport java.util. * ;\r\npublic class InstanceOperator {\r\n public static void main(String[] args) throws IOException {\r\n InstanceOperator ob = new InstanceOperator();\r\n System.out.println(\"Is ob an instance of InstanceOperator class? \" + (ob instanceof InstanceOperator));\r\n\r\n }\r\n}<\/pre>\nJava Operators Precedence and Association<\/h3>\n
\n\n
\n Level<\/b><\/td>\n Operator<\/b><\/td>\n Description<\/b><\/td>\n Associativity<\/b><\/td>\n<\/tr>\n \n 1<\/td>\n =,+=,-=,*=,\/=,%=,&=,^=,|=,<<=,>>=,>>>=<\/td>\n Basic assignment Operators<\/td>\n Right to left<\/td>\n<\/tr>\n \n 2<\/td>\n ?:<\/td>\n ternary<\/td>\n Right to left<\/td>\n<\/tr>\n \n 3<\/td>\n ||<\/td>\n Logical OR<\/td>\n Left to right<\/td>\n<\/tr>\n \n 4<\/td>\n &&<\/td>\n Logical AND<\/td>\n Left to Right<\/td>\n<\/tr>\n \n 5<\/td>\n |<\/td>\n bitwise OR<\/td>\n left to right<\/td>\n<\/tr>\n \n 6<\/td>\n ^<\/td>\n bitwise XOR<\/td>\n left to right<\/td>\n<\/tr>\n \n 7<\/td>\n &<\/td>\n bitwise AND<\/td>\n left to right<\/td>\n<\/tr>\n \n 8<\/td>\n ==,!=<\/td>\n equality operator<\/td>\n left to right<\/td>\n<\/tr>\n \n 9<\/td>\n <,<=,>,>=,instanceof<\/td>\n relational<\/td>\n not associative<\/td>\n<\/tr>\n \n 10<\/td>\n <<,>>,>>><\/td>\n shift<\/td>\n left to right<\/td>\n<\/tr>\n \n 11<\/td>\n +,-<\/td>\n additive<\/td>\n left to right<\/td>\n<\/tr>\n \n 12<\/td>\n *,\/,%<\/td>\n multiplicative<\/td>\n left to right<\/td>\n<\/tr>\n \n 13<\/td>\n (), new<\/td>\n object creation<\/td>\n right to left<\/td>\n<\/tr>\n \n 14<\/td>\n ++,–,+,-,!,~<\/span><\/td>\n pre-increment,pre- decrement,plus,minus,NOT,bitwise NOT<\/td>\n right to left<\/td>\n<\/tr>\n \n 15<\/td>\n ++,–<\/span><\/td>\n unary post increment,unary post decrement<\/td>\n not associative<\/td>\n<\/tr>\n \n 16<\/td>\n [ ], . , ()<\/td>\n access array element,object member,parentheses<\/td>\n left to right<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Summary<\/h3>\n