{"id":76246,"date":"2020-02-11T10:20:18","date_gmt":"2020-02-11T04:50:18","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=76246"},"modified":"2020-02-11T10:20:18","modified_gmt":"2020-02-11T04:50:18","slug":"java-operators","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/java-operators\/","title":{"rendered":"Java Operators and its 8 Types that you should know about!"},"content":{"rendered":"

Now as you are familiar with the declaration and initialization of variables in Java<\/strong><\/em>, you might be eager to know how to perform with them. In this tutorial, we will learn the various operators in Java which we can further use accordingly for our need\/purpose.<\/p>\n

In computer programming, an operator is a special symbol that is used to perform operations on the variables and values. The operators<\/strong> represent the operations (specific tasks) and the objects\/variables of the operations are known as operands<\/strong>.<\/p>\n

Types of Operators in Java<\/h3>\n

Java comes with a rich set of operators, which comprises of many kinds of operators such as arithmetic, relational, and logical and many other types of operators<\/em>. Let us discuss each of them in detail.<\/p>\n

1. Arithmetic Operators in Java<\/h4>\n

Arithmetic operators are used to perform mathematical expressions or arithmetic calculations in the same way we use them in algebra.<\/p>\n

Java provides operators for five basic arithmetic calculations: addition, subtraction, multiplication, division, and the remainder which are +, -, *, \/, and %<\/strong> respectively. Each of these is a binary<\/strong> operator that is, it requires two values (operands)<\/em> to perform calculations.<\/p>\n

We will discuss each type of Arithmetic operators in detail:<\/p>\n

\"types<\/a><\/p>\n

1.1. Addition Operator (+)<\/h5>\n

The arithmetic binary operator (+) adds the values of its operands and the result is the sum of values of its two operands. Its operands can be of integer type (int, short, byte, long, double)<\/em> or float type (float and double)<\/em>.<\/p>\n

For example:<\/strong><\/p>\n

4 + 20; results in 24. \/\/adding two values.\n\nnum1 + 5; (where num1 = 5) results in 10. \/\/adding a variable with a value.\nnum1 + num2; (where num1 = 6, num2 = 8) results in 14. \/\/adding two variables<\/pre>\n
1.2. Subtraction Operator (-)<\/h5>\n
The – operator subtracts the second operand from the first. The operators may be of integer or float types.<\/p>\n
For example:<\/strong><\/p>\n
10 - 3; \/\/results in 7.\n\nint num1 = 80;\nint num2 = 15;\nint result;\nnum2 - 9; \/\/results in 6.\nresult = num1 - num2; \/\/stores 65 in result variable.<\/pre>\n
1.3. Multiplication Operator (*)<\/h5>\n
The multiplication operator (*) multiplies the values of its operands. The values may be of integer or float types.<\/p>\n
For example:<\/strong><\/p>\n
2.5 * 1.5; \/\/results in 3.75 \n\nint num1,num2;\nnum1 = 4,num2 = 6; \nnum1 * num2; \/\/results in 24.<\/pre>\n
1.4. Division Operator (\/)<\/h5>\n
The division operator \/ divides its first operand by the second. Here, the operands may be of both integer or float types.<\/p>\n
For example:<\/strong><\/p>\n
100\/5; \/\/evaluates to 20.\n\nfloat num1 = 16.2;\nnum1 \/ 2; \/\/evaluates to 8.1\n\nfloat num2 = 2.5;\nnum1 \/ num2; \/\/evaluates to 6.4<\/pre>\n
1.5. Modulus Operator (%)<\/h5>\n
The modulus operator % finds the modulus of its first operator relative to the second. That is, it produces the remainder of the division of the first operand by the second.<\/p>\n
For example:<\/strong><\/p>\n
20 % 3; \/\/evaluates to 2, since 3 * 6 = 18 and remainder is 2\n\n-5 % -2; \/\/evaluates to 1.\n\nfloat num1 = 7.6, num2 = 2.9;\nnum1 % num2; \/\/evaluates to 1.8<\/pre>\n
Operator + with Strings<\/h5>\n
We have used the operator \u2018+\u2019 with numbers. When we use + with the number, the result is also a number. In Java, we can also use the + operator for concatenating 2 strings.<\/p>\n
For example:<\/strong><\/p>\n
\u201c5\u201d + \u201c6\u201d; \/\/results into \u201c56\u201d\n\n\u201c20\u201d + \u201c ,Sector A\u201d; \/\/results into \u201c20 ,Sector A\u201d\n\n\u201cAbc\u201d + \u201c123\u201d; \/\/results into \u201cAbc 123\u201d\n\n5 + \u201cxyz\u201d; \/\/results into \u201c5xyz\u201d\n(Java would internally convert 5 into \u201c5\u201d first and then concatenate it with \u201cxyz\u201d).<\/pre>\n
Code Snippet to illustrate the concept of Arithmetic operators:<\/strong><\/p>\n
package com.TechVidvan.Operators;\npublic class ArithmeticOperators\n{\n  public static void main(String[] args)\n  {\n    int operand1 = 100, operand2 = 20;\n    String stringName1 = \"TechVidvan\u2019s\", stringName2 = \" Java Tutorial\";\n\n    \/\/ using + operator with strings will concatenate the 2 strings\n    System.out.println(\"Welcome to \" +stringName1 +stringName2);\n\n    \/\/ using addition + operator\n    System.out.println(\"Adding(+) two operands: \"+(operand1 + operand2));\n    \/\/ using subtraction - operator\n    System.out.println(\"Subtracting(-) two operands: \"+(operand1 - operand2));\n    \/\/ using multiplication * operator\n    System.out.println(\"Multiplying(*) two operands: \"+(operand1 * operand2));\n    \/\/ using division \/ operator\n    System.out.println(\"Dividing(\/) two operands: \"+(operand1 \/ operand2));\n    \/\/ using modulus % operator\n    System.out.println(\"Modulus(%) of two operands: \"+(operand1 % operand2));\n  }\n}<\/pre>\n
Output:<\/strong><\/p>\n
Welcome to TechVidvan’s Java Tutorial
\nAdding(+) two operands: 120
\nSubtracting(-) two operands: 80
\nMultiplying(*) two operands: 2000
\nDividing(\/) two operands: 5
\nModulus(%) of two operands: 0<\/div>\n
2. Unary Operators in Java<\/h4>\n
The operators that act on one operand are called Unary Operators. They are of 2 types:<\/p>\n
2.1. Unary +<\/h5>\n
The operator unary \u2018+\u2019 precedes an operand. The operand of the unary + operator must have an arithmetic type and the result is the value of the argument itself.<\/p>\n
For example:<\/strong><\/p>\n
If number1 = 5 then +number1 means 5.
\nIf number2 = -4 then +number1 means -4.<\/p>\n
2.2. Unary –<\/h5>\n
The operator unary – precedes an operand. The operand of the unary – must be of an arithmetic type and the result is the negation of the value of the operand. This operator changes the sign of the operand\u2019s value.<\/p>\n
For example:<\/strong><\/p>\n
If number1 = 5 then -number1 means -5.
\nIf number2 = 0 then -number1 means 0.
\nIf number3 = -7 then -number3 means 7.<\/p>\n
2.3. Increment\/Decrement operators ( ++\/– )<\/h5>\n
Java includes two useful operators which are generally not found in other computer languages (except C and C++). These are the increment (++) and decrement (- -) operators. The ++ operator adds 1 to its operand while – – operator subtracts 1. In other words, we can say,<\/p>\n
num = num + 1;<\/pre>\n
is same as<\/p>\n
++num ; or num++;<\/pre>\n
and,<\/p>\n
num = num - 1;<\/pre>\n
is same as<\/p>\n
--num ; or num-- ;<\/pre>\n
However, both the increment and decrement operators come in two categories\/varieties:<\/strong> They can either precede<\/strong> or follow<\/strong> the operand.<\/p>\n
The prefix<\/strong> version, in which the operator comes before the operand, as in-
\nPre-Increment ( ++operand )<\/strong> and Pre-Decrement ( – -operand ):<\/strong><\/p>\n
When an increment or decrement operator precedes its operand (prefix form)<\/em>, then Java performs the increment or decrement operation before using the value of the operand.<\/p>\n
For example:<\/strong><\/p>\n
int count = 3,sum=0;
\nsum = sum + (++count); \/\/will result in the value of sum to 4.<\/p>\n
Principal:<\/strong> The pre-increment or pre-decrement operators follow the change-then-use<\/strong> rule that is, they first change the value of their operand, then use the new value in evaluating an expression.<\/p>\n
And, in the postfix<\/strong> version, the operator comes after the operand, as in-
\nPost-Increment ( operand++ )<\/strong> and Post-Decrement ( operand – – ):<\/strong><\/p>\n
When an increment or decrement operator follows its operand (prefix form), then Java first uses the value of the operand before performing the increment or decrement operation on the value of the operand.<\/p>\n
 For example:<\/strong>
\nint count = 3,sum=0;
\nsum = sum + (count++); \/\/will result in the value of sum to 3.<\/p>\n
Principal:<\/strong> The post-increment or post-decrement operators follow the use-then-change<\/strong> rule that is, they first use the value of their operand in evaluating the expression, then change the value of the operand.<\/p>\n
Code Snippet to understand the increment\/decrement operators:<\/strong><\/p>\n
package com.TechVidvan.Operators;\npublic class UnaryOperators\n{\n  \/\/ Java program to illustrate unary operators\n  public static void main(String[] args)\n  {\n    int num1 = 10, num2 = 20, num3 = 30, num4 = 40, result;\n\n    \/\/using pre-increment operator\n    result = ++num1;\n    System.out.println(\"Value of pre incremented value of num1: \" +result);\n\n    \/\/using post increment operator\n    result = num2++;\n    System.out.println(\"Value of post incremented value of num2: \" +result);\n\n    \/\/using pre-decrement operator\n    result = --num3;\n    System.out.println(\"Value of pre decremented value of num3: \" + result);\n\n    \/\/using post-decrement operator\n    result = num4--;\n    System.out.println(\"Value of post decremented value of num4: \" +result);\n  }\n}<\/pre>\n
Output:<\/strong><\/p>\n
Value of pre incremented value of num1: 11
\nValue of post incremented value of num2: 20
\nValue of pre decremented value of num3: 29
\nValue of post decremented value of num4: 40<\/div>\n
3. Relational Operators in Java<\/h4>\n
The term \u2018relational\u2019<\/em> in the relational operator refers to the relationships that values or operands can have with one another. Thus, the relational operators determine the relation among the operands. Java provides 6 relational operators for comparing numbers and characters.<\/p>\n
But, relational operators do not work with strings. After the comparison, they return the result in boolean datatype. If the comparison is true, the relational operator results in true, otherwise false. They are extensively used in looping as well as conditional if-else statements.<\/p>\n
The general syntax<\/strong> of the relational operator is,<\/p>\n
variable_name relation_operator value;<\/pre>\n
The six relational operators are:\"types<\/a><\/p>\n
3.1. Equal to (==) Operator<\/h5>\n
It returns true if the left-hand side is equal to the right-hand side, otherwise false.<\/p>\n
3.2. Not Equal to (!=) Operator<\/h5>\n
It returns true if the left-hand side is not equal to the right-hand side, otherwise false.<\/p>\n
3.3. Less Than (<) Operator<\/h5>\n
It returns true if the left-hand side is less than the right-hand side, otherwise false.<\/p>\n
3.4. Less Than or Equal to (<=) Operator<\/h5>\n
It returns true if the left-hand side is less than or equal to the right-hand side, otherwise false.<\/p>\n
3.5. Greater Than (>) Operator<\/h5>\n
It returns true if the left-hand side is greater than the right-hand side, otherwise false.<\/p>\n
3.6. Greater Than or Equal to (>=) Operator<\/h5>\n
It returns true if the left-hand side is greater than or equal to the right-hand side, otherwise false.<\/p>\n
The below table illustrates the relational operations on p and q. Here p and q are of the int<\/strong> data type.<\/p>\n
\"relational<\/a><\/p>\n
4. Logical Operators in Java<\/h4>\n
Logical operators are also known as conditional operators. These operators are used for evaluating one or more boolean expression, for complex decision-making. They also return a boolean value (true or false).<\/p>\n
There are three types of logical or conditional operators in Java are && (Logical-AND), || (Logical-OR)<\/strong> and ! (Logical NOT).<\/strong>\"types<\/a><\/p>\n
In this, && (Logical-AND)<\/strong> and || (Logical-OR)<\/strong> operators are the binary<\/strong> logical operators that work on two operands or expressions, while ! (Logical NOT)<\/strong> is a unary<\/strong> logical operator which works on single operand or expression.<\/p>\n
Let\u2019s discuss each of them in detail<\/p>\n
4.1. The Logical AND Operator (&&)<\/h5>\n
The logical AND operator (&&) combines two expressions (operands) into one expression. The resulting expression evaluates to true only if both of its expressions (operands) are true. Following are the examples of && operator –<\/p>\n
(5==3) && (4==4) \/\/results into false because first expression is false.<\/pre>\n
(4==4) && (7==7) \/\/results into true because both expressions are true.<\/pre>\n
1 < 8 && 4 > 2 \/\/results into true because both expressions are true.<\/pre>\n
4 > 6 && 5 < 2 \/\/results into false because both expressions are false.<\/pre>\n
4.2. The Logical OR Operator ( || )<\/h5>\n
The logical OR operator (||) also combines two expressions (operands) into one expression. The resulting expression evaluates to true if either of its expressions (operands) evaluates to true.<\/p>\n
Following are the examples of || operator:<\/strong><\/p>\n
(6==3) || (4==4) \/\/results into true because second expression is true.<\/pre>\n
(4==4) || (7==7) \/\/results into true because both expressions are true.<\/pre>\n
6 < 9 || 4 < 2 \/\/results into false because both expressions are false.<\/pre>\n
4 < 6 || 5 < 2 \/\/results into true because first expression is true.<\/pre>\n
4.3. The Logical NOT Operator ( ! )<\/h5>\n
The logical NOT operator, which is written as ! <\/strong>, is a unary operator that works on a single operand or expression. The Logical NOT operator (!) negates or reverses the truth value of its operand.<\/p>\n
That is if the expression is true, then !expression is false and vice-versa. The following are the examples of ! operator-<\/p>\n
! (9 != 0) \/\/results into false because 9 is non-zero(i.e., true).<\/pre>\n
! (6 > 2) \/\/results into false because the expression 6 > 2 is true.<\/pre>\n
! (4 > 10) \/\/results into true because the expression 4 > 10 is false.<\/pre>\n
Code Snippet to understand the Logical operators:<\/strong><\/p>\n
package com.TechVidvan.Operators;\npublic class LogicalOperators\n{\n  \/\/ Java program to illustrate Logical operators\n  public static void main(String[] args)\n  {\n    int age = 19;\n    String nationality = \"Indian\";\n    int country_code = 22;\n\n    \/\/Using Logical AND (&&) operator\n    if(age >=18 && nationality.equals(\"Indian\"))\n    {\n      System.out.println(\"You are eligible for voting\");\n    }\n\n    \/\/Using Logical OR(||) operator\n    if(age>=18 && (nationality.equals(\"Indian\") || country_code==1))\n    {\n      System.out.println(\"You are eligible for voting\");\n    }\n\n    \/\/Using Logical NOT(!) operator\n    if(country_code != 1)\n    {\n      System.out.println(\"You are NOT eligible for voting!!\");\n    }\n  }\n}<\/pre>\n
Output:<\/strong><\/p>\n
You are eligible for voting
\nYou are eligible for voting
\nYou are NOT eligible for voting!!<\/div>\n
5. Bitwise Operators in Java<\/h4>\n
The Bitwise operators manipulate the individual bits of a number. The bitwise operators work with the integer types that is, byte, short, int, and long types<\/em>. Java provides 4 bitwise operators:\"types<\/a><\/p>\n
The following table shows the 4 operations that Java programming language provides to perform bitwise functions on their operands:<\/em><\/p>\n\n\n\n\n\n\n\n
Operator<\/i><\/b><\/td>\nUse<\/i><\/b><\/td>\nOperation<\/i><\/b><\/td>\n<\/tr>\n
&<\/td>\nop1 & op2<\/span><\/td>\nBitwise AND<\/span><\/td>\n<\/tr>\n
|<\/b><\/td>\nOp1 | op2<\/span><\/td>\nBitwise OR<\/span><\/td>\n<\/tr>\n
^<\/b><\/td>\nop1 ^ op2<\/span><\/td>\nBitwise XOR<\/span><\/td>\n<\/tr>\n
~<\/b><\/td>\n~op2<\/span><\/td>\nBitwise Complement<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
The bitwise operations calculate each bit of their results by comparing the corresponding bits of the two operands on the basis of these 3 rules:<\/p>\n