关系运算符生成的是一个“布尔”（ boolean ）结果。它们评价的是运算对象值之间的关系。若关系是真实的，关系表达式会生成 true （真）；若关系不真实，则生成 false （假）。关系运算符包括小于（ < ）、大于（ > ）、小于或等于（ <= ）、大于或等于（ >= ）、等于（ == ）以及不等于（ != ）。等于和不等于适用于所有内建的数据类型，但其他比较不适用于 boolean 类型。

检查对象是否相等关系运算符 == 和 != 也适用于所有对象，但它们的含义通常会使初涉 Java 领域的人找不到北。下面是一个例子：

//: Equivalence.java 
 public class Equivalence { 
 public static void main(String[] args) { 
 Integer n1 = new Integer(47); 
 Integer n2 = new Integer(47); 
 System.out.println(n1 == n2); 
 System.out.println(n1 != n2); 
 } 
} ///:~ 
 

其中，表达式 System.out.println(n1 == n2) 可打印出内部的布尔比较结果。一般人都会认为输出结果肯定先是 true ，再是false，因为两个 Integer 对象都是相同的。但尽管对象的内容相同， 句柄 却是不同的，而==和!=比较的正好就是对象句柄。所以输出结果实际上先是 false ，再是 true 。这自然会使第一次接触的人感到惊奇。

若想对比两个对象的实际内容是否相同，又该如何操作呢？此时，必须使用所有对象都适用的特殊方法 equals() 。但这个方法不适用于“主类型”，那些类型直接使用 == 和 != 即可。下面举例说明如何使用：

//: EqualsMethod.java 
 
public class EqualsMethod { 
 public static void main(String[] args) { 
 Integer n1 = new Integer(47); 
 Integer n2 = new Integer(47); 
 System.out.println(n1.equals(n2)); 
 } 
} ///:~ 
 
正如我们预计的那样，此时得到的结果是true。但事情并未到此结束！假设您创建了自己的类，就象下面这样： 
 
//: EqualsMethod2.java 
 class Value { 
 int i; 
} 
public class EqualsMethod2 { 
 public static void main(String[] args) { 
 Value v1 = new Value(); 
 Value v2 = new Value(); 
 v1.i = v2.i = 100; 
 System.out.println(v1.equals(v2)); 
 } 
} ///:~ 
 

此时的结果又变回了 false ！这是由于 equals() 的默认行为是比较句柄。所以除非在自己的新类中改变了 equals() ，否则不可能表现出我们希望的行为。不幸的是，要到第7章才会学习如何改变行为。但要注意 equals() 的这种行为方式同时或许能够避免一些“灾难”性的事件。大多数 Java 类库都实现了 equals() ，所以它实际比较的是对象的内容，而非它们的句柄。

逻辑运算符

逻辑运算符 AND （&&） 、 OR（||） 以及 NOT（!） 能生成一个 布尔值 （ true 或 false ）——以自变量的逻辑关系为基础。下面这个例子向大家展示了如何使用关系和逻辑运算符。

//: Bool.java 
// Relational and logical operators import java.util.*; 
public class Bool { 
 public static void main(String[] args) { 
 Random rand = new Random(); 
 int i = rand.nextInt() % 100; 
 int j = rand.nextInt() % 100; 
 prt("i = " + i); 
 prt("j = " + j); 
 prt("i > j is " + (i > j)); 
 prt("i < j is " + (i < j)); 
 prt("i >= j is " + (i >= j)); 
 prt("i <= j is " + (i <= j)); 
 prt("i == j is " + (i == j)); 
 prt("i != j is " + (i != j)); 
 // Treating an int as a boolean is 
 // not legal Java 
 //! prt("i && j is " + (i && j)); 
 //! prt("i || j is " + (i || j)); 
 //! prt("!i is " + !i); 
 prt("(i < 10) && (j < 10) is " + ((i < 10) && (j < 10)) ); prt("(i < 10) || (j < 10) is " + ((i < 10) || (j < 10)) ); 
 } 
 static void prt(String s) { 
 System.out.println(s); 
 } 
} ///:~ 
 

只可将 AND ， OR 或 NOT 应用于布尔值。与在 C 及 C++ 中不同，不可将一个非布尔值当作布尔值在逻辑表达式中使用。若这样做，就会发现尝试失败，并用一个“ //! ”标出。然而，后续的表达式利用关系比较生成布尔值，然后对结果进行逻辑运算。输出列表看起来象下面这个样子：

 i = 85 
 j = 4 
 i > j is true 
 i < j is false 
 i >= j is true 
 i <= j is false 
 i == j is false 
 i != j is true 
(i < 10) && (j < 10) is false 
(i < 10) || (j < 10) is true 
 

注意若在预计为 String 值的地方使用，布尔值会自动转换成适当的文本形式。

在上述程序中，可将对 int 的定义替换成除 boolean 以外的其他任何主数据类型。但要注意，对浮点数字的比较是非常严格的。即使一个数字仅在小数部分与另一个数字存在极微小的差异，仍然认为它们是“不相等”的。即使一个数字只比零大一点点（例如 2 不停地开平方根），它仍然属于“非零”值。

短路

操作逻辑运算符时，我们会遇到一种名为“短路”的情况。这意味着只有明确得出整个表达式真或假的结论，才会对表达式进行逻辑求值。因此，一个逻辑表达式的所有部分都有可能不进行求值：

//: ShortCircuit.java 
// Demonstrates short-circuiting behavior // with logical operators. 
 
public class ShortCircuit { 
 static boolean test1(int val) { 
 System.out.println("test1(" + val + ")"); 
 System.out.println("result: " + (val < 1)); 
 return val < 1; 
 } 
 static boolean test2(int val) { 
 System.out.println("test2(" + val + ")"); 
 System.out.println("result: " + (val < 2)); 
 return val < 2; 
 } 
 static boolean test3(int val) { 
 System.out.println("test3(" + val + ")"); 
 System.out.println("result: " + (val < 3)); 
 return val < 3; 
 } 
public static void main(String[] args) { 
 if(test1(0) && test2(2) && test3(2)) 
 System.out.println("expression is true"); 
else 
 System.out.println("expression is false"); 
 } 
} ///:~ 
 
 

每次测试都会比较自变量，并返回真或假。它不会显示与准备调用什么有关的资料。测试在下面这个表达式中进行：

if(test1(0)) && test2(2) && test3(2)) 很自然地，你也许认为所有这三个测试都会得以执行。但希望输出结果不至于使你大吃一惊：

test1(0) result: true 
test2(2) result: false 
expression is false 
 

第一个测试生成一个 true 结果，所以表达式求值会继续下去。然而，第二个测试产生了一个false结果。由于这意味着整个表达式肯定为 false ，所以为什么还要继续剩余的表达式呢？这样做只会徒劳无益。事实上，“短路”一词的由来正种因于此。如果一个逻辑表达式的所有部分都不必执行下去，那么潜在的性能提升将是相当可观的。