The JavaTM Tutorial

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form

Trail: Learning the Java Language
Lesson: Language Basics

## Relational and Conditional Operators

> A relational operator compares two values and determines the relationship between them. For example, `!=` returns `true` if the two operands are unequal. This table summarizes the relational operators:

> Operator | Use | Returns `true` if
> `>` | `op1 > op2` | `op1` is greater than `op2`
> `>=` | `op1 >= op2` | `op1` is greater than or equal to `op2`
> `<` | `op1 < op2` | `op1` is less than `op2`
> `<=` | `op1 <= op2` | `op1` is less than or equal to `op2`
> `==` | `op1 == op2` | `op1` and `op2` are equal
> `!=` | `op1 != op2` | `op1` and `op2` are not equal

> Following is an example, `RelationalDemo`, that defines three integer numbers and uses the relational operators to compare them. The relational operations are shown in red:

> >     public class RelationalDemo {
> >         public static void main(String[] args) {

> >             //a few numbers
> >             int i = 37;
> >             int j = 42;
> >             int k = 42;
> >             System.out.println("Variable values...");
> >             System.out.println("    i = " + i);
> >             System.out.println("    j = " + j);
> >             System.out.println("    k = " + k);

> >     	//greater than
> >             System.out.println("Greater than...");
> >             System.out.println("    i > j = " + (i > j));	  //false
> >             System.out.println("    j > i = " + (j > i));     //true
> >             System.out.println("    k > j = " + (k > j));     //false, they are equal

> >     	//greater than or equal to
> >             System.out.println("Greater than or equal to...");
> >             System.out.println("    i >= j = " + (i >= j));   //false
> >             System.out.println("    j >= i = " + (j >= i));   //true
> >             System.out.println("    k >= j = " + (k >= j));   //true

> >     	//less than
> >             System.out.println("Less than...");
> >             System.out.println("    i < j = " + (i < j));     //true
> >             System.out.println("    j < i = " + (j < i));     //false
> >             System.out.println("    k < j = " + (k < j));     //false

> >     	//less than or equal to
> >             System.out.println("Less than or equal to...");
> >             System.out.println("    i <= j = " + (i <= j));   //true
> >             System.out.println("    j <= i = " + (j <= i));   //false
> >             System.out.println("    k <= j = " + (k <= j));   //true

> >     	//equal to
> >             System.out.println("Equal to...");
> >             System.out.println("    i == j = " + (i == j));   //false
> >             System.out.println("    k == j = " + (k == j));   //true

> >     	//not equal to
> >             System.out.println("Not equal to...");
> >             System.out.println("    i != j = " + (i != j));   //true
> >             System.out.println("    k != j = " + (k != j));   //false

> >         }
> >     }

> Here's the output from this program:

> >     Variable values...
> >         i = 37
> >         j = 42
> >         k = 42
> >     Greater than...
> >         i > j = false
> >         j > i = true
> >         k > j = false
> >     Greater than or equal to...
> >         i >= j = false
> >         j >= i = true
> >         k >= j = true
> >     Less than...
> >         i < j = true
> >         j < i = false
> >         k < j = false
> >     Less than or equal to...
> >         i <= j = true
> >         j <= i = false
> >         k <= j = true
> >     Equal to...
> >         i == j = false
> >         k == j = true
> >     Not equal to...
> >         i != j = true
> >         k != j = false

> Relational operators often are used with conditional operators to construct more complex decision-making expressions. The Java programming language supports six conditional operators-five binary and one unary--as shown in the following table.

> Operator | Use | Returns `true` if
> `&&` | `op1 && op2` | `op1` and `op2` are both `true`, conditionally evaluates `op2`
> `||` | `op1 || op2` | either `op1` or `op2` is `true`, conditionally evaluates `op2`
> `!` | `! op` | `op` is `false`
> `&` | `op1 & op2` | `op1` and `op2` are both `true`, always evaluates `op1` and `op2`
> `|` | `op1 | op2` | either `op1` or `op2` is `true`, always evaluates `op1` and `op2`
> `^` | `op1 ^ op2` | if op1 and op2 are different--that is if one or the other of the operands is true but not both

> One such operator is `&&`, which performs the conditional `AND` operation. You can use two different relational operators along with `&&` to determine whether both relationships are `true`. The following line of code uses this technique to determine whether an array index is between two boundaries. It determines whether the index is both greater than or equal to 0 and less than `NUM_ENTRIES`, which is a previously defined constant value.

> >     0 <= index && index < NUM_ENTRIES

> Note that in some instances, the second operand to a conditional operator may not be evaluated. Consider this code segment:

> >     (numChars < LIMIT) && (...)

> The `&&` operator will return `true` only if both operands are `true`. So, if `numChars` is greater than or equal to `LIMIT`, the left-hand operand for `&&` is `false`, and the return value of `&&` can be determined without evaluating the right-hand operand. In such a case, the interpreter will not evaluate the right-hand operand. This has important implications if the right-hand operand has side effects, such as reading from a stream, updating a value, or making a calculation.

> When both operands are boolean, the operator `&` performs the same operation as `&&`. However, `&` always evaluates both of its operands and returns `true` if both are `true`. Likewise, when the operands are boolean, `|` performs the same operation as `||`. The `|` operator always evaluates both of its operands and returns `true` if at least one of its operands is `true`. When their operands are numbers, `&` and `|` perform bitwise manipulations.

> The next section has more information.

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form

Copyright 1995-2004 Sun Microsystems, Inc. All rights reserved.