Bitwise OperatorsJ8 Home « Bitwise Operators

• <<    Operators
• Conditional Statements     >>

In the second lesson on operators we look at the bitwise logical and bitwise shift operators. Bitwise operators perform their operations on the integer types byte, short, int and long and will not work with any other type. These operators are used to manipulate the bits within an integer value, hence the name.

• Bits with the value 0 are said to be switched off.
• Bits with the value 1 are said to be switched on.
• All bitwise conversions get promoted to the int type before conversion so you need to cast back to short and byte when using these types for the target.

Bitwise Logical Operators Top

The bitwise logical operators perform the same operations as the logical operators discussed in the last lesson but work on a bit-by-bit basis on the integer type. The following table shows all possible combinations for a bit using 0 and 1.

Let's look at each of the bitwise logical operators in turn to get a feel for how they work.

Bitwise AND Top

The bitwise AND operator can be used for turning non-matched bits off. Lets look at some code to illustrate how this works:

package info.java8;
/*
  Bitwise AND
*/ 
public class BitwiseAnd {

  public static void main (String[] args) {
    byte a = 97;
    printBits(a);
    byte b = 57;
    printBits(b);
    byte c = (byte) (a & b);
    printBits(c);
  }

  /*
    Loop through input parameter and print out the bits
  */ 
  public static void printBits (byte aByte) {
    System.out.print("Input param aByte = " + aByte + ": ");
    
    for (int i = 128; i > 0; i /= 2) {
        if ((aByte & i) != 0) {
            System.out.print("1 "); 
        } else { 
            System.out.print("0 ");
        } 
    } 
    System.out.println(" ");
  }
}

Running the BitwiseAnd class produces the following output:

Ok there are several new things going on with the above piece of code that we will go through. The first thing to notice is we are casting to a byte when using the bitwise AND (byte c = (byte) (a & b);). All bitwise conversions get promoted to the int type before conversion so we need to cast back to the byte type. Also we are enclosing the bitwise operation in parentheses so the whole expression gets evaluated and not just the a. We are using the printBits method to save replication of code. We pass each variable to this method and print the value. We then use a for loop to print out each bit of the byte variable passed to the method. We will go through the for loop in the Loop Statements lesson but what we are doing here is just dividing 256 by 2 to get to each bit. The 8th bit is used for the sign (0 = positive, 1 negative), hence the actual value range of a byte is 127 to -128 as stated in the Primitive Variables lesson. As you can see from the output the bitwise AND operator switches non-matched bits off.

Bitwise OR Top

The bitwise OR operator can be used for turning non-matched bits on. Lets look at some code to illustrate how this works:

package info.java8;
/*
  Bitwise OR
*/ 
public class BitwiseOr {

  public static void main (String[] args) {
      byte a = 97;
      printBits(a);
      byte b = 57;
      printBits(b);
      byte c = (byte) (a | b);
      printBits(c);
}

  /*
    Loop through input parameter and print out the bits
  */ 
  public static void printBits (byte aByte) {
    System.out.print("Input param aByte = " + aByte + ": ");
    
    for (int i = 128; i > 0; i /= 2) {
        if ((aByte & i) != 0) {
            System.out.print("1 "); 
        } else { 
            System.out.print("0 ");
        } 
    } 
    System.out.println(" ");
  }
}

Running the BitwiseOr class produces the following output:

As you can see from the output the bitwise OR operator switches non-matched bits on.

Bitwise XOR Top

The bitwise XOR operator can be used for highlighting unmatched bits as any matching bits will be switched to 0, whilst unmatched bits are switched to 1. Lets look at some code to illustrate how this works:

package info.java8;
/*
  Bitwise XOR
*/ 
public class BitwiseXor {

  public static void main (String[] args) {
    byte a = 97;
    printBits(a);
    byte b = 57;
    printBits(b);
    byte c = (byte) (a ^ b);
    printBits(c);
}

  /*
    Loop through input parameter and print out the bits
  */ 
  public static void printBits (byte aByte) {
    System.out.print("Input param aByte = " + aByte + ": ");
    
    for (int i = 128; i > 0; i /= 2) {
        if ((aByte & i) != 0) {
            System.out.print("1 "); 
        } else { 
            System.out.print("0 ");
        } 
    } 
    System.out.println(" ");
  }
}

Running the BitwiseXor class produces the following output:

As you can see from the output the bitwise XOR operator switches non-matched bits on and matched bits off.

Bitwise NOT Top

The bitwise NOT operator can be used for switching bits to show the compliment of the number. Lets look at some code to illustrate how this works:

package info.java8;
/*
  Bitwise NOT
*/ 
public class BitwiseNot {

  public static void main (String[] args) {
    byte a = 57;
    printBits(a);
    a = (byte)~a;
    printBits(a);
}

  /*
    Loop through input parameter and print out the bits
  */ 
  public static void printBits (byte aByte) {
    System.out.print("Input param aByte = " + aByte + ": ");
    
    for (int i = 128; i > 0; i /= 2) {
        if ((aByte & i) != 0) {
            System.out.print("1 "); 
        } else { 
            System.out.print("0 ");
        } 
    } 
    System.out.println(" ");
  }
}

Running the BitwiseNot class produces the following output:

As you can see from the output the bitwise NOT operator switches bits to show the compliment of the number.

Bitwise Shift Operators Top

The bitwise shift operators allow us to shift the bits that make up an integer type to the left or right by a specified amount.

Let's look at each of the bitwise shift operators in turn to see how we got the values in the table above.

Bitwise Left Shift Top

The bitwise left shift operator allows us to shift the bits in an integer type to the left by the specified amount.

package info.java8;
/*
  Bitwise Left Shift
*/ 

public class BitwiseLeftShift {

    public static void main (String[] args) {
        short a = 1234;
        printBits(a);
        a = (short) (a <<  2);
        printBits(a);
    }

    /*
      Use a loop to print out the bits
    */ 
    public static void printBits (short a) {
        System.out.print("Input param a = " + a + ": ");
    
        for (int i = 32768 ; i > 0; i /= 2) {
            if (i == 128) {
                System.out.print(" |  "); 
            }  
            if ((a & i) != 0) {
                    System.out.print("1 "); 
            } else { 
                System.out.print("0 ");
            } 
        }
        System.out.println(" ");
    }
}

Running the BitwiseLeftShift class produces the following output:

As you can see from the output all the bits have been shifted 2 places to the left giving us a new value. We are using the | symbol to split the result into 8-bit chunks.

Bitwise Right Shift Top

The bitwise right shift operator allows us to shift the bits in an integer type to the right by the specified amount.

package info.java8;
/*
  Bitwise Right Shift
*/ 

public class BitwiseRightShift {

    public static void main (String[] args) {
        short a = 1234;
        printBits(a);
        a = (short) (a >>  3);
        printBits(a);
    }

    /*
      Use a loop to print out the bits
    */ 
    public static void printBits (short a) {
        System.out.print("Input param a = " + a + ": ");
  
        for (int i = 32768 ; i > 0; i /= 2) {
            if (i == 128) {
                System.out.print(" |  "); 
            }  
                  if ((a & i) != 0) {
                System.out.print("1 "); 
            } else { 
                System.out.print("0 ");
            } 
        }
        System.out.println(" ");
    }
}

Running the BitwiseRightShift class produces the following output:

As the output shows all the bits have been shifted 3 places to the right giving us a new value. We are using the | symbol to split the result into 8-bit chunks.

Bitwise Signed Right Shift Top

The bitwise signed right shift operator allows us to shift the bits in an integer type to the right by the specified amount, whilst retaining the signed bit.

package info.java8;
/*
  Bitwise Signed Right Shift
*/ 

public class BitwiseSignedRightShift {

    public static void main (String[] args) {
        short a = -12345;
        printBits(a);
        a = (short) (a >>>  4);
        printBits(a);
    }

    /*
      Use a loop to print out the bits
    */ 
    public static void printBits (short a) {
        System.out.print("Input param a = " + a + ": ");
  
        for (int i = 32768 ; i > 0; i /= 2) {
            if (i == 128) {
                System.out.print(" |  "); 
            }  
                  if ((a & i) != 0) {
                System.out.print("1 "); 
            } else { 
                System.out.print("0 ");
            } 
        }
        System.out.println(" ");
    }
}

Running the BitwiseSignedRightShift class produces the following output:

As the output shows all the bits have been shifted 3 places to the right giving us a new value. We are using the | symbol to split the result into 8-bit chunks.

Did you spot anything else? When you right shift a negative number, when the interim expression is promoted to an int from a short or byte all the extra bits are sign-extended. Thus when we cast back to a short in our example all bits shifted in after our signed bit are 1 and we get an unexpected result. Be aware of this when using this particular bitwise operator.

Bitwise Shorthand Assignment Operators Top

The bitwise shorthand assignment operators allow us to write compact code that is implemented more efficiently. When using the bitwise shorthand assignment operators there is no need to cast either.

Operator Precedence Top

We will finish our discussion on operators with a table showing the order of precedence that is invoked when Java interprets operator symbols. The list includes the special operators which will be discussed in later lessons. When using multiple operators in an expression it is always best practice to use parentheses to explicitly state the order of precedence for clarity and readability. The table lists order of precedence from highest to lowest.

Lesson 6 Complete

In this lesson we took a second look at the symbols used in Java for mathematical and logical manipulation.

What's Next?

In the next lesson we take our first look at conditional statements when we look at the if construct.

• <<    Operators
• Conditional Statements     >>