# Java: Relational Operators

## Relational Operators

This Java video tutorial examines the nature and uses of relational operators in Java. A relational operator is an operator that takes two values and evaluates whether they fulfill the specified relationship. If so, the boolean value true is returned. Otherwise, the operator returns false.

### Six Relational Operators

Above, we have the six relational operators and their Java representations; notice that four of the the Java operators are represented by two characters. The equal to operator is represented by a double equals sign because the single equals sign is used for the assignment operator. The not equal to, greater than or equal to, and the less than or equal to are represented by !=, >=, and <=, respectively. This is because the normal characters for these operators are not available on the keyboard.

### Program 1

```package test;

public class Test {
public static void main(String[] args) {
System.out.print("Is 6 < 2? ");
System.out.println(6 < 2);
System.out.print("Is 6 > 2? ");
System.out.println(6 > 2);
}
}
```

### Output 1

In the program above, we demonstrate the usage of the relational less than operator with two sets of arguments: one that returns false and one that returns true. First, we print out a question. Then we print out the answer by evaluating the relational operator. As we see in the output, the words false and true are printed for the boolean values that the operators returns.

When we apply a relational operator to a variable, we have a set of values for which the operator is true. Above, we have six example sets that are graphed on the number line. The red regions indicate the values of X for which the operator is true. Notice that each pair of successive operators generates setwise complements. That is, the sets have exactly the opposite members.

### Program 2

```package test;

public class Test {
public static void main(String[] args) {
double dX = 3.0;
System.out.print("dX < 5 ? " + (dX < 5));
System.out.println(" if dX = " + dX);
dX = 4.0;
System.out.print("dX < 5 ? " + (dX < 5));
System.out.println(" if dX = " + dX);
dX = 5.0;
System.out.print("dX < 5 ? " + (dX < 5));
System.out.println(" if dX = " + dX);
dX = 6.0;
System.out.print("dX < 5 ? " + (dX < 5));
System.out.println(" if dX = " + dX);
dX = 7.0;
System.out.print("dX < 5 ? " + (dX < 5));
System.out.println(" if dX = " + dX);
}
}
```

### Output 2

In the second program above, we apply the relational operator less than to the value 5 and the variable dX while it takes on a series of values. In the output pane, we see that the operator evaulates to true for some values and false for others. The set of values for which the operator is true can be represented on the number line, as we showed before.

### Program 3

```package test;

public class Test {
public static void main(String[] args) {
double dX = 3.0;
if (dX != 4.0) {
System.out.println("dX != 4.0");
} else {
System.out.println("dX == 4.0");
}
}
}
```

### Output 3

Our third program illustrates the most powerful application of a relational operator. In this program, we put the relational operator into a conditional if statement that executes one block of code if the operator returns true and another block if the operator returns false. Since the variable was initialized to 3.0, the first print statement is executed.