YouTip

Bitwise Operators

Java defines bitwise operators, which can be applied to the integer types, long, short, char, and byte.

Bitwise operators work on bits and perform bit-by-bit operation. Assume if a = 60 and b = 13; now in binary format 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

The following table lists the bitwise operators. Assume integer variable A holds 60 and variable B holds 13 then:

Example

The following simple example program demonstrates the bitwise operators. Copy and paste the following Java program and save it as Test.java file, then compile and run this program:

Test.java File Code:

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;          /* 15 = 1111 */
     System.out.println("a >> 2 = " + c );

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

This will produce the following result:

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

Logical Operators

The following table lists the logical operators. Assume Boolean variables A holds true and variable B holds false then:

Example

The following simple example program demonstrates the logical operators. Copy and paste the following Java program and save it as Test.java file, then compile and run this program:

Example

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 result:

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

Short-circuit Logical Operators

When using the logical AND operator, the result is true only if both operands are true. However, if the first operand evaluates to false, the result is guaranteed to be false, so the second operand is not evaluated.

Example

public class LuoJi {
  public static void main(String[] args) {
     int a = 5;
     boolean b = (a<4) && (a++<10);
     System.out.println("Using short-circuit logical operator result is " + b);
     System.out.println("Value of a is " + a);
  }
}

This will produce the following result:

Using short-circuit logical operator result is false
Value of a is 5

Analysis: This program uses the short-circuit logical AND operator (&&). First, it evaluates a<4, which is false. Therefore, the result of b is guaranteed to be false, so the second operand a++<10 is not evaluated. Thus, the value of a remains 5.

Assignment Operators

Following are the assignment operators supported by Java language:

Example

The following simple example program demonstrates the assignment operators. Copy and paste the following Java program and save it as Test.java file, then compile and run this program:

Test.java File Code:

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 ;
     System.out.println("c >>= 2 = " + c );

     c >>= 2 ;
     System.out.println("c >>= 2 = " + 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 );
  }
}

This will produce the following result:

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

Conditional Operator (?:)

The conditional operator is also known as the ternary operator. This operator consists of three operands and is used to evaluate Boolean expressions. The goal of the operator is to decide which value should be assigned to the variable.

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

Example

Test.java File Code:

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

     b = (a == 10) ? 20 : 30;
     System.out.println( "Value of b is : " + b );
  }
}

This will produce the following result:

Value of b is : 30
Value of b is : 20

instanceof Operator

This operator is used only for object reference variables. The operator checks whether the object is of a particular type (class type or interface type).

The instanceof operator is used as follows:

(Object reference variable) instanceof (class/interface type)

If the object referred to by the variable on the left side of the operator passes the IS-A check for the class/interface type on the right side, then the result is true.

Here is one example:

String name = "James";
boolean result = name instanceof String; // Since name is of String type, result is true

This operator will still return true if the object being compared is compatible with the type on the right.

Here is one more example:

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);
  }
}

This will produce the following result:

true

Java Operator Precedence

When multiple operators appear in an expression, the order of evaluation depends on their precedence. In an expression with multiple operators, the different precedence levels can lead to vastly different results.

For example, (1+3) + (3+2)*2, if addition is evaluated first, the answer is 18; if multiplication is evaluated first, the answer is 14.

Another example: x = 7 + 3 * 2; here x gets 13, not 20, because the multiplication operator * has higher precedence than the addition operator +, so 3 * 2 gets 6 first, then 7 is added.

The operator with the highest precedence is at the top of the table, and the one with the lowest is at the bottom.