I recommend that you open another copy of this module in a separate browser window and use the following links to easily find and view the listings while you are reading about them.

Java supports various arithmetic operators on all floating point and integer numbers.

The binary arithmetic operators

The following table lists the binary arithmetic operators supported by Java.

Operator    Description                              
   
   +        Adds its operands                        
   -        Subtracts the right operand from the left 
            operand
   *        Multiplies the operands                  
   /        Divides the left operand by the right operand
   %        Remainder of dividing the left operand by 
            the right operand

String concatenation

As mentioned earlier, the plus operator (+) is also used to concatenate strings as in the following code fragment:

"MyVariable has a value of  " 
                      + MyVariable + " in this program."

Coercion

Note that this operation also coerces the value of MyVariable to a string representation for use in the expression only. However, the value stored in the variable is not modified in any lasting way.

Unary arithmetic operators

Java supports the following unary arithmetic operators.

Operator    Description                              

   +        Indicates a positive value       
   -        Negates, or changes algebraic sign
   ++       Adds one to the operand, 
            both prefix and postfix
   --       Subtracts one from operand, 
            both prefix and postfix

The result of the increment and decrement operators being either prefix or postfix was discussed earlier .

Binary Relational operators

Java supports the set of binary relational operators shown in the following table. Relational operators in Java return either true or false as a boolean type.

Operator    Returns true if   
   >        Left operand is greater than right operand
   >=       Left operand is greater than or equal to 
            right operand
   <        Left operand is less than right operand  
   <=       Left operand is less than or equal to 
            right operand
   ==       Left operand is equal to right operand   
   !=       Left operand is not equal to right operand

Conditional expressions

Relational operators are frequently used in the conditional expressions of control statement such as the one in the code fragment shown below.

if(LeftVariable <= RightVariable). . .

Illustration of relational operators

The program shown in Listing 2 illustrates the result of applying relational operators in Java. The output is shown in the comments at the beginning of the program. Note that the program automatically displays true and false as a result of applying the relational operators.

/*File relat01.java Copyright 1997, R.G.Baldwin
Illustrates relational operators.

Output is

The relational 6<5 is false
The relational 6>5 is true

*********************************************************/
class relat01 { //define the controlling class
  public static void main(String[] args){ //main method
    System.out.println("The relational 6<5 is " 
      +(6<5));
    System.out.println("The relational 6>5 is " 
      +(6>5));
  }//end main
}//End relat01 class.

Conditional operators

The relational operators are often combined with another set of operators (referred to as conditional or logical operators) to construct more complex expressions.

Java supports three such operators as shown in the following table.

Operator  Typical Use            Returns true if     
   &&     Left && Right     Left and Right are both true
   ||     Left || Right     Either Left or Right is true
   !      ! Right           Right is false

The operands shown in the table must be boolean types, or must have been created by the evaluation of an expression that returns a boolean type.

Left to right evaluation

An important characteristic of the behavior of the logical and and the logical or operators is that the expressions are evaluated from left to right, and the evaluation of the expression is terminated as soon as the result of evaluating the expression can be determined.

For example, in the following expression, if the variable a is less than the variable b , there is no need to evaluate the right operand of the || to determine that the result of evaluating the entire expression would be true . Therefore, evaluation will terminate as soon as the answer can be determined.

(a < b) || (c < d)

Don't confuse bitwise and with logical and

As discussed in the next section, symbols shown below are the bitwise and and the bitwise or .

& bitwise and
| bitwise or

One author states that in Java, the bitwise and operator can be used as a synonym for the logical and and the bitwise or can be used as a synonym for the logical inclusive or if both of the operands are boolean . (I recommend that you don't do that because it could cause confusion for someone reading your code.)

Note however that according to a different author, in this case, the evaluation of the expression is not terminated until all operands have been evaluated, thus eliminating the possible advantage of the left-to-right evaluation.

Java provides a set of operators that perform actions on their operands one bit at a time as shown in the following table.

Operator   Typical Use         Operation                  

 >>     OpLeft >> Dist      Shift bits of OpLeft right 
                            by Dist bits (signed)  
 <<     OpLeft << Dist      Shift bits of OpLeft left 
                            by Dist bits
 >>>    OpLeft >>> Dist     Shift bits of OpLeft right 
                            by Dist bits (unsigned)
 &      OpLeft & OpRight    Bitwise and of the 
                            two operands
 |      OpLeft | OpRight    Bitwise 

Populating vacated bits for shift operations

The signed right shift operation populates the vacated bits with the sign bit, while the left shift and the unsigned right shift populate the vacated bits with zeros.

In all cases, bits shifted off the end are lost.

The rule for bitwise and

The bitwise and operation operates according to the rule that the bitwise and of two 1 bits is a 1 bit.

Any other combination results in a 0 bit.

Bitwise inclusive or

For the inclusive or , if either bit is a 1, the result is a 1.

Otherwise, the result is a 0.

Bitwise exclusive or

For the exclusive or , if either but not both bits is a 1, the result is a 1.

Otherwise, the result is a 0.

Another way to state this is if the bits are different, the result is a 1. If the two bits are the same, the result is a 0.

The complement operator

Finally, the complement operator changes each 1 to a 0 and changes each 0 to a 1.

Simple assignment operator

The (=) is a value assigning binary operator in Java. The value stored in memory and represented by the right operand is copied into the memory represented by the left operand.

Using the assignment operator with reference variables

You need to be careful and think about what you are doing when you use the assignment operator with reference variables in Java. If you assign one reference variable to another, you simply end up with two reference variables that refer to the same object. You do not end up with two different objects.

(If what you need is another copy of the object, you may be able to use the clone method to accomplish that.)

Shortcut assignment operators

Java supports the following list of shortcut assignment operators. These operators allow you to perform an assignment and another operation with a single operator.

+= 
-= 
*= 
/= 
%= 
&= 
|= 
^= 
<<= 
>>= 
>>>=

For example, the two statements that follow perform the same operation.

x += y;
x = x + y;