Java – Basic Operators of the Language

Basic Operators of the LanguageJava provides a rich set of operators for manipulating variables. All Java operators can be divided into the following groups:

  • arithmetic operators;
  • comparison operators;
  • bitwise operators;
  • logical operators;
  • assignment operators;
  • other operators.
Basic Operators of the Language

Arithmetic operators

Arithmetic Operators – Used in mathematical expressions in the same way they are used in algebra. Suppose integer variable A is 10 and variable B is 20. The following table lists the arithmetic operators in Java:

OperatorDescriptionExample
+Adds values ​​on either side of the operatorA + B will give 30
Subtracts the right-hand operand from the left-hand operandA – B will give -10
*Multiplies values ​​on either side of the operatorA * B will give 200
/The division operator divides the left operand by the right operandB / A will give 2
%Divides the left operand by the right operand and returns the remainderB% A will give 0
++Increment – increases the value of the operand by 1B ++ will give 21
Decrement – decreases the value of the operand by 1B– will give 19

Example

The following simple example shows programmatically arithmetic operators. Copy and paste the following java code into the test.java file, compile and run this program:

public class Test {

   public static void main (String args []) {
      int a = 10;
      int b = 20;
      int c = 25;
      int d = 25;
      System.out.println ("a + b =" + (a + b));
      System.out.println ("a - b =" + (a - b));
      System.out.println ("a * b =" + (a * b));
      System.out.println ("b / a =" + (b / a));
      System.out.println ("b% a =" + (b% a));
      System.out.println ("c% a =" + (c% a));
      System.out.println ("a ++ =" + (a ++));
      System.out.println ("b-- =" + (a--));
      // Check the difference in d ++ and ++ d
      System.out.println ("d ++ =" + (d ++));
      System.out.println ("++ d =" + (++ d));
   }
}

This will produce the following output:

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
b--   = 11
d++   = 25
++d   = 27

Comparison Operators

The following comparison operators are supported in the Java language. Suppose variable A is 10 and variable B is 20. The following table lists the relational or comparison operators in Java:

OperatorDescriptionExample
==Checks if the values ​​of two operands are equal or not, if yes, then the condition becomes true(A == B) – not correct
! =Checks if the values ​​of two operands are equal or not, if the values ​​are not equal, then the condition becomes true(A! = B) – value is true
>Checks if the value of the left operand is greater than the value of the right operand, if yes, then the condition becomes true(A> B) – not correct
<Checks if the value of the left operand is less than the value of the right operand, if yes, then the condition becomes true(A <B) – value is true
> =Checks if the value of the left operand is greater than or equal to the value of the right operand, if yes, then the condition becomes true(A> = B) – values ​​are not correct
<=Checks if the value of the left operand is less than or equal to the value of the right operand, if yes, then the condition becomes true(A <= B) – value is true

Example

The following simple example shows programmatically the comparison operators in Java. Copy and paste the following java code into the test.java file, compile and run this program:

public class Test {

  public static void main(String args[]) {
     int a = 10;
     int b = 20;
     System.out.println("a == b = " + (a == b) );
     System.out.println("a != b = " + (a != b) );
     System.out.println("a > b = " + (a > b) );
     System.out.println("a < b = " + (a < b) );
     System.out.println("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
  }
} 

You will get the following output:

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

Bitwise operators

Java defines several bitwise operators that can be applied to integer types: int, long, short, char, and byte. In Java, the bitwise operator works on bits and performs the operation bit by bit. Suppose if a = 60; and b = 13; then in binary they will be as follows:

a = 0011 1100
b = 0000 1101
—————–
a & b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
~ a = 1100 0011

Suppose the integer variable A is 60 and the variable B is 13. The following table lists the bitwise operators in Java:

OperatorDescriptionExample
& (bitwise and)The binary AND operator copies a bit into the result if it exists in both operands.(A & B) will give 12, which is 0000 1100
| (bitwise or)The binary OR operator copies a bit if it exists in any of the operands.(A | B) will give 61 which is 0011 1101
^ (bitwise boolean or)The binary XOR operator copies a bit if it is set in one operand, but not in both.(A ^ B) will give 49 which is 0011 0001
~ (bitwise complement)Binary’s complement operator and has the effect of “flipping” bits.(~ A) will give -61, which is the complement form of 1100 0011 in binary notation
<< (shift left)Binary left shift operator. The value of the left operands is moved left by the number of bits specified by the right operand.A << 2 will give 240 which is 1111 0000
>> (shift right)Binary right shift operator. The value of the right operands is moved right by the number of bits specified by the left operand.A >> 2 will give 15 which is 1111
>>> (zero shift right)Zero right shift operator. The value of the left operands is moved right by the number of bits specified by the right operand, and the shifted values ​​are filled with zeros.A >>> 2 will give 15 which is 0000 1111

Example

The following simple example shows programmatically bitwise operators in Java. Copy and paste the following java code into the test.java file, compile and run this program:

public class Test {

  public static void main(String args[]) {
     int a = 60;	/* 60 = 0011 1100 */  
     int b = 13;	/* 13 = 0000 1101 */
     int c = 0;

     c = a & b;       /* 12 = 0000 1100 */ 
     System.out.println("a & b = " + c );

     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c );

     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c );

     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );

     c = a << 2;     /* 240 = 1111 0000 */
     System.out.println("a << 2 = " + c );

     c = a >> 2;     /* 215 = 1111 */
     System.out.println("a >> 2  = " + c );

     c = a >>> 2;     /* 215 = 0000 1111 */
     System.out.println("a >>> 2 = " + c );
  }
} 

You will get the following output:

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 15
a >>> 15

Logical operators

Suppose boolean variable A is true and variable B holds false. The following table lists the logical operators in Java:

OperatorDescriptionExample
&&The logical operator “AND” is called. If both operands are non-zero, then the condition becomes true(A && B) – false
||The logical operator “OR” is called. If either of the two operands is non-zero, then the condition becomes true(A || B) – true
!The logical operator “NOT” is called. Usage changes the logical state of its operand. If the condition is true, then the logical “NOT” operator will do false! (A && B) – true

Example

The following simple example shows programmatically logical operators in Java. Copy and paste the following java code into the test.java file, compile and run this program:

public class Test {

  public static void main(String args[]) {
     boolean a = true;	
     boolean b = false;	

     System.out.println("a && b = " + (a&&b));

     System.out.println("a || b = " + (a||b) );

     System.out.println("!(a && b) = " + !(a && b));
  }
} 

This will produce the following output:

a && b = false
a || b = true
!(a && b) = true

Assignment operators

The following assignment operators are supported by the Java language:

OperatorDescriptionExample
=Simple assignment operator, assigns values ​​from the right side of the operands to the left sideC = A + B, will assign the value of A + B to C
+ =The “Append” assignment operator, it assigns the left operand the values ​​of the rightC + = A, equivalent to C = C + A
– =The assignment operator “Subtraction”, it subtracts the left operand from the right operandC – = A, equivalent to C = C – A
* =The assignment operator “Multiplication”, it multiplies the right operand by the left operandC * = A is equivalent to C = C * A
/ =The assignment operator “Division”, it divides the left operand by the right operandC / = A is equivalent to C = C / A
% =The assignment operator “Module”, it takes a module using two operands and assigns its result to the left operandC% = A, equivalent to C = C% A
<< =Left shift assignment operatorC << = 2, it’s like C = C << 2
>> =Shift right assignment operatorC >> = 2, it’s like C = C >> 2
& =Bitwise AND assignment operatorC & = 2, it’s like C = C & 2
^ =Bitwise exclusive “OR” assignment operator (“XOR”)C ^ = 2, it’s like C = C ^ 2
| =Bitwise OR (OR) assignment operatorC | = 2, it’s like C = C | 2

Example

The following simple example shows programmatically logical operators in Java. Copy and paste the following java code into the test.java file, compile and run this program:

public class Test {

  public static void main(String args[]) {
     int a = 10;	
     int b = 20;
     int c = 0;

     c = a + b;
     System.out.println("c = a + b = " + c );

     c += a ;
     System.out.println("c += a  = " + c );

     c -= a ;
     System.out.println("c -= a = " + c );

     c *= a ;
     System.out.println("c *= a = " + c );

     a = 10;
     c = 15;
     c /= a ;
     System.out.println("c /= a = " + c );

     a = 10;
     c = 15;
     c %= a ;
     System.out.println("c %= a  = " + c );

     c <<= 2 ;
     System.out.println("c <<= 2 = " + c );

     c >>= 2 ;
     System.out.println("c >>= 2 = " + c );

     c >>= 2 ;
     System.out.println("c >>= a = " + c );

     c &= a ;
     System.out.println("c &= 2  = " + c );
  
     c ^= a ;
     System.out.println("c ^= a   = " + c );

     c |= a ;
     System.out.println("c |= a   = " + c );
  }
}

You will get the following output:

c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10

Other operators

There are several other operators supported by the Java language.

Ternary operator or conditional operator (? 🙂

Ternary operator is an operator that consists of three operands and is used to evaluate expressions of type boolean. The ternary operator in Java is also known as the conditional operator. This. The purpose of a ternary operator or conditional operator is to decide what value should be assigned to a variable. The operator is written as:

variable x = (expression)? if true: if false

Example

Below is an example:

public class Test {
 
    public static void main (String args []) {
       int a, b;
       a = 10;
       b = (a == 1)? 20:30;
       System.out.println ("Value b:" + b);
 
       b = (a == 10)? 20:30;
       System.out.println ("Value b:" + b);
    }
}

You will get the following output:

public class Test {
 
    public static void main (String args []) {
       int a, b;
       a = 10;
       b = (a == 1)? 20:30;
       System.out.println ("Value b:" + b);
 
       b = (a == 10)? 20:30;
       System.out.println ("Value b:" + b);
    }
}

You will get the following output:

B value: 30
B value: 20

Instanceof operator

Operator instanceof – Checks if an object is of a specific type (class type or interface type) and is used only for variables of the referenced object. The instanceof operator is written as:

(Reference object variable) instanceof (interface class / type)

Examples of

If the referenced object variable on the left side of the statement passes the test for the class / interface type on the right side, the result is true. Below is an example and description of the instanceof operator:

public class Test {
 
    public static void main (String args []) {
       String name = "Oleg";
       // The following will return true because the type is String
       boolean result = name instanceof String;
       System.out.println (result);
    }
}

You will get the following output:

true

This operator will still return true if the object being compared is type compatible for the assignment right. Another example follows:

class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String args[]){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );
   }
}

You will get the following output:

true

Operator precedence in Java

Operator precedence determines the grouping of terms in an expression. This affects how the expression is evaluated. Some operators have higher priority than others; for example the multiplication operator has higher precedence than the addition operator:

For example, x = 7 + 3 * 2. Here x is assigned the value 13, not 20, because the “*” operator has a higher precedence than “+”, so first “3 * 2” is multiplied and then “7” is added “.

In the table, the operators with the highest priority are placed at the top and the priority level is lowered towards the bottom of the table. In an expression, high precedence operators in Java will be evaluated from left to right.

CategoryOperatorAssociativity
Postfix() []. (dot)From left to right
Unary++ – -! ~From right to left
Multiplicative* /%From left to right
Additive+ –From left to right
Shift>> >>> <<From left to right
Relational>> = <<=From left to right
Equality==! =From left to right
Bitwise “AND” (“AND”)&From left to right
Bitwise exclusive “OR” (“XOR”)^From left to right
Bitwise “OR” (“OR”)|From left to right
Logical “AND”&&From left to right
Logical “OR” (“OR”)||From left to right
Conditional?:From right to left
Assignment= + = – = * = / =% = >> = << = & = ^ = | =From right to left
Comma,From left to right