› ›

运算符：布尔值

编辑

运算符：布尔值

编辑

布尔非

编辑

使用 布尔非运算符 '!' 对 boolean 类型值进行非运算，其中 true 将翻转为 false，false 将翻转为 true。

错误

如果给定的值不是 boolean 类型值，或不能转换为 boolean 类型的值。

真值

原始值	结果
true	false
false	true

语法

boolean_not: '!' expression;

示例

使用 boolean 类型的布尔非。

boolean x = !false; 
boolean y = !x;

	声明 `boolean x`; 布尔非 `boolean false` → `boolean true`; 将 `boolean true` 存储到 `x`
	声明 `boolean y`; 从 `x` 加载 → `boolean true`; 布尔非 `boolean true` → `boolean false`; 将 `boolean false` 存储到 `y`

使用 def 类型的布尔非。

def y = true; 
def z = !y;

	声明 `def y`; 隐式转换 `boolean true` 为 `def` → `def`; 将 `true` 存储到 `y`
	声明 `def z`; 从 `y` 加载 → `def`; 隐式转换 `def` 为 `boolean true` → boolean `true`; 布尔非 `boolean true` → `boolean false`; 隐式转换 `boolean false` 为 `def` → `def`; 将 `def` 存储到 `z`

大于

编辑

使用 大于运算符 '>' 比较两个数值类型的值，如果左侧值大于右侧值，则结果 boolean 类型值为 true，否则为 false。

错误

如果计算出的左侧值或右侧值是非数值。

语法

greater_than: expression '>' expression;

提升

	byte	short	char	int	long	float	double	def
byte	int	int	int	int	long	float	double	def
short	int	int	int	int	long	float	double	def
char	int	int	int	int	long	float	double	def
int	int	int	int	int	long	float	double	def
long	long	long	long	long	long	float	double	def
float	float	float	float	float	float	float	double	def
double	double	double	double	double	double	double	double	def
def	def	def	def	def	def	def	def	def

示例

不同数值类型的大于比较。

boolean x = 5 > 4; 
double y = 6.0;    
x = 6 > y;

	声明 `boolean x`; `int 5` 大于 `int 4` → `boolean true`; 将 `boolean true` 存储到 `x`;
	声明 `double y`; 将 `double 6.0` 存储到 `y`;
	从 `y` 加载 → `double 6.0 @0`; 提升 `int 6` 和 `double 6.0`：结果 `double`; 隐式转换 `int 6` 为 `double 6.0 @1` → `double 6.0 @1`; `double 6.0 @1` 大于 `double 6.0 @0` → `boolean false`; 将 `boolean false` 存储到 `x`

使用 def 类型的比较。

int x = 5;       
def y = 7.0;     
def z = y > 6.5; 
def a = x > y;

	声明 `int x`; 将 `int 5` 存储到 `x`
	声明 `def y`; 隐式转换 `double 7.0` 为 `def` → `def`; 将 `def` 存储到 `y`
	声明 `def z`; 从 `y` 加载 → `def`; 隐式转换 `def` 为 `double 7.0` → `double 7.0`; `double 7.0` 大于 `double 6.5` → `boolean true`; 隐式转换 `boolean true` 为 `def` → `def`; 将 `def` 存储到 `z`
	声明 `def a`; 从 `y` 加载 → `def`; 隐式转换 `def` 为 `double 7.0` → `double 7.0`; 从 `x` 加载 → `int 5`; 提升 `int 5` 和 `double 7.0`：结果 `double`; 隐式转换 `int 5` 为 `double 5.0` → `double 5.0`; `double 5.0` 大于 `double 7.0` → `boolean false`; 隐式转换 `boolean false` 为 `def` → `def`; 将 `def` 存储到 `z`

大于等于

编辑

使用 大于等于运算符 '>=' 比较两个数值类型的值，如果左侧值大于等于右侧值，则结果 boolean 类型值为 true，否则为 false。

错误

如果计算出的左侧值或右侧值是非数值。

语法

greater_than_or_equal: expression '>=' expression;

提升

	byte	short	char	int	long	float	double	def
byte	int	int	int	int	long	float	double	def
short	int	int	int	int	long	float	double	def
char	int	int	int	int	long	float	double	def
int	int	int	int	int	long	float	double	def
long	long	long	long	long	long	float	double	def
float	float	float	float	float	float	float	double	def
double	double	double	double	double	double	double	double	def
def	def	def	def	def	def	def	def	def

示例

不同数值类型的大于等于比较。

boolean x = 5 >= 4; 
double y = 6.0;     
x = 6 >= y;

	声明 `boolean x`; `int 5` 大于等于 `int 4` → `boolean true`; 将 `boolean true` 存储到 `x`
	声明 `double y`; 将 `double 6.0` 存储到 `y`
	从 `y` 加载 → `double 6.0 @0`; 提升 `int 6` 和 `double 6.0`：结果 `double`; 隐式转换 `int 6` 为 `double 6.0 @1` → `double 6.0 @1`; `double 6.0 @1` 大于等于 `double 6.0 @0` → `boolean true`; 将 `boolean true` 存储到 `x`

使用 def 类型的比较。

int x = 5;        
def y = 7.0;      
def z = y >= 7.0; 
def a = x >= y;

	声明 `int x`; 将 `int 5` 存储到 `x`;
	声明 `def y` 隐式转换 `double 7.0` 为 `def` → `def`; 将 `def` 存储到 `y`
	声明 `def z`; 从 `y` 加载 → `def`; 隐式转换 `def` 为 `double 7.0 @0` → `double 7.0 @0`; `double 7.0 @0` 大于等于 `double 7.0 @1` → `boolean true`; 隐式转换 `boolean true` 为 `def` → `def`; 将 `def` 存储到 `z`
	声明 `def a`; 从 `y` 加载 → `def`; 隐式转换 `def` 为 `double 7.0` → `double 7.0`; 从 `x` 加载 → `int 5`; 提升 `int 5` 和 `double 7.0`：结果 `double`; 隐式转换 `int 5` 为 `double 5.0` → `double 5.0`; `double 5.0` 大于等于 `double 7.0` → `boolean false`; 隐式转换 `boolean false` 为 `def` → `def`; 将 `def` 存储到 `z`

小于

编辑

使用 小于运算符 '<' 比较两个数值类型的值，如果左侧值小于右侧值，则结果 boolean 类型值为 true，否则为 false。

错误

如果计算出的左侧值或右侧值是非数值。

语法

less_than: expression '<' expression;

提升

	byte	short	char	int	long	float	double	def
byte	int	int	int	int	long	float	double	def
short	int	int	int	int	long	float	double	def
char	int	int	int	int	long	float	double	def
int	int	int	int	int	long	float	double	def
long	long	long	long	long	long	float	double	def
float	float	float	float	float	float	float	double	def
double	double	double	double	double	double	double	double	def
def	def	def	def	def	def	def	def	def

示例

不同数值类型的小于比较。

boolean x = 5 < 4; 
double y = 6.0;    
x = 6 < y;

	声明 `boolean x`; `int 5` 小于 `int 4` → `boolean false`; 将 `boolean false` 存储到 `x`
	声明 `double y`; 将 `double 6.0` 存储到 `y`
	从 `y` 加载 → `double 6.0 @0`; 提升 `int 6` 和 `double 6.0`：结果 `double`; 隐式转换 `int 6` 为 `double 6.0 @1` → `double 6.0 @1`; `double 6.0 @1` 小于 `double 6.0 @0` → `boolean false`; 将 `boolean false` 存储到 `x`

使用 def 类型的比较。

int x = 5;       
def y = 7.0;     
def z = y < 6.5; 
def a = x < y;

	声明 `int x`; 将 `int 5` 存储到 `x`
	声明 `def y`; 隐式转换 `double 7.0` 为 `def` → `def`; 将 `def` 存储到 `y`
	声明 `def z`; 从 `y` 加载 → `def`; 隐式转换 `def` 为 `double 7.0` → `double 7.0`; `double 7.0` 小于 `double 6.5` → `boolean false`; 隐式转换 `boolean false` 为 `def` → `def`; 将 `def` 存储到 `z`
	声明 `def a`; 从 `y` 加载 → `def`; 隐式转换 `def` 为 `double 7.0` → `double 7.0`; 从 `x` 加载 → `int 5`; 提升 `int 5` 和 `double 7.0`：结果 `double`; 隐式转换 `int 5` 为 `double 5.0` → `double 5.0`; `double 5.0` 小于 `double 7.0` → `boolean true`; 隐式转换 `boolean true` 为 `def` → `def`; 将 `def` 存储到 `z`

小于等于

编辑

使用 小于等于运算符 '<=' 比较两个数值类型的值，如果左侧值小于等于右侧值，则结果 boolean 类型值为 true，否则为 false。

错误

如果计算出的左侧值或右侧值是非数值。

语法

greater_than_or_equal: expression '<=' expression;

提升

	byte	short	char	int	long	float	double	def
byte	int	int	int	int	long	float	double	def
short	int	int	int	int	long	float	double	def
char	int	int	int	int	long	float	double	def
int	int	int	int	int	long	float	double	def
long	long	long	long	long	long	float	double	def
float	float	float	float	float	float	float	double	def
double	double	double	double	double	double	double	double	def
def	def	def	def	def	def	def	def	def

示例

不同数值类型的小于等于比较。

boolean x = 5 <= 4; 
double y = 6.0;     
x = 6 <= y;

	声明 `boolean x`; `int 5` 小于等于 `int 4` → `boolean false`; 将 `boolean true` 存储到 `x`
	声明 `double y`; 将 `double 6.0` 存储到 `y`
	从 `y` 加载 → `double 6.0 @0`；提升 `int 6` 和 `double 6.0`：结果 `double`；隐式转换 `int 6` 为 `double 6.0 @1` → `double 6.0 @1`；小于或等于 `double 6.0 @1` 和 `double 6.0 @0` → `boolean true`；将 `boolean true` 存储到 `x`

使用 def 类型进行小于或等于比较。

int x = 5;        
def y = 7.0;      
def z = y <= 7.0; 
def a = x <= y;

	声明 `int x`; 将 `int 5` 存储到 `x`;
	声明 `def y`；隐式转换 `double 7.0` 为 `def` → `def`；将 `def` 存储到 `y`；
	声明 `def z`；从 `y` 加载 → `def`；隐式转换 `def` 为 `double 7.0 @0` → `double 7.0 @0`；小于或等于 `double 7.0 @0` 和 `double 7.0 @1` → `boolean true`；隐式转换 `boolean true` 为 `def` → `def`；将 `def` 存储到 `z`
	声明 `def a`；从 `y` 加载 → `def`；隐式转换 `def` 为 `double 7.0` → `double 7.0`；从 `x` 加载 → `int 5`；提升 `int 5` 和 `double 7.0`：结果 `double`；隐式转换 `int 5` 为 `double 5.0` → `double 5.0`；小于或等于 `double 5.0` 和 `double 7.0` → `boolean true`；隐式转换 `boolean true` 为 `def` → `def`；将 `def` 存储到 `z`

instanceof 运算符

编辑

使用 instanceof 运算符 将变量/字段类型与指定的引用类型进行比较，使用引用类型名称，如果变量/字段类型与指定的引用类型相同或为其子类，则结果 boolean 类型值为 true，否则为 false。

错误

如果右侧指定的引用类型名称不存在。

语法

instance_of: ID 'instanceof' TYPE;

示例

使用不同引用类型的 instanceof。

Map m = new HashMap();            
boolean a = m instanceof HashMap; 
boolean b = m instanceof Map;

	声明 `Map m`；分配 `HashMap` 实例 → `HashMap 引用`；隐式转换 `HashMap 引用` 为 `Map 引用`；将 `Map 引用` 存储到 `m`
	声明 `boolean a`；从 `m` 加载 → `Map 引用`；隐式转换 `Map 引用` 为 `HashMap 引用` → `HashMap 引用`；`HashMap 引用` instanceof `HashMap` → `boolean true`；将 `boolean true` 存储到 `a`
	声明 `boolean b`；从 `m` 加载 → `Map 引用`；隐式转换 `Map 引用` 为 `HashMap 引用` → `HashMap 引用`；`HashMap 引用` instanceof `Map` → `boolean true`；将 `true` 存储到 `b`；（注意 `HashMap` 是 `Map` 的子类）

使用 def 类型的 instanceof。

def d = new ArrayList();       
boolean a = d instanceof List; 
boolean b = d instanceof Map;

	声明 `def d`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `def` → `def`；将 `def` 存储到 `d`
	声明 `boolean a`；从 `d` 加载 → `def`；隐式转换 `def` 为 `ArrayList 引用` → `ArrayList 引用`；`ArrayList 引用` instanceof `List` → `boolean true`；将 `boolean true` 存储到 `a`；（注意 `ArrayList` 是 `List` 的子类）
	声明 `boolean b`；从 `d` 加载 → `def`；隐式转换 `def` 为 `ArrayList 引用` → `ArrayList 引用`；`ArrayList 引用` instanceof `Map` → `boolean false`；将 `boolean false` 存储到 `a`；（注意 `ArrayList` 不是 `Map` 的子类）

相等性比较 (==)

编辑

使用 相等性比较运算符 '==' 比较两个值，如果两个值相等，则结果 boolean 类型值为 true，否则为 false。当值为引用类型值时，隐式调用成员方法 equals，其中第一个值为调用的目标，第二个值为参数。此操作是空安全的，如果两个值都为 null，则结果 boolean 类型值为 true；如果只有一个值为 null，则结果 boolean 类型值为 false。可以在 boolean 类型值、数字类型值或引用类型值之间进行有效比较。

错误

如果在 boolean 类型值和数字类型值之间进行比较。
如果在原始类型值和引用类型值之间进行比较。

语法

equality_equals: expression '==' expression;

提升

	布尔型	byte	short	char	int	long	float	double	引用类型	def
布尔型	布尔型	-	-	-	-	-	-	-	-	def
byte	-	int	int	int	int	long	float	double	-	def
short	-	int	int	int	int	long	float	double	-	def
char	-	int	int	int	int	long	float	double	-	def
int	-	int	int	int	int	long	float	double	-	def
long	-	long	long	long	long	long	float	double	-	def
float	-	float	float	float	float	float	float	double	-	def
double	-	double	double	double	double	double	double	double	-	def
引用类型	-	-	-	-	-	-	-	-	对象	def
def	def	def	def	def	def	def	def	def	def	def

示例

使用 boolean 类型的相等性比较。

boolean a = true;  
boolean b = false; 
a = a == false;    
b = a == b;

	声明 `boolean a`；将 `boolean true` 存储到 `a`
	声明 `boolean b`；将 `boolean false` 存储到 `b`
	从 `a` 加载 → `boolean true`；`boolean true` 和 `boolean false` 相等性比较 → `boolean false`；将 `boolean false` 存储到 `a`
	从 `a` 加载 → `boolean false @0`；从 `b` 加载 → `boolean false @1`；`boolean false @0` 和 `boolean false @1` 相等性比较 → `boolean false`；将 `boolean false` 存储到 `b`

使用原始类型的相等性比较。

int a = 1;          
double b = 2.0;     
boolean c = a == b; 
c = 1 == a;

	声明 `int a`；将 `int 1` 存储到 `a`
	声明 `double b`；将 `double 1.0` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `int 1`；从 `b` 加载 → `double 2.0`；提升 `int 1` 和 `double 2.0`：结果 `double`；隐式转换 `int 1` 为 `double 1.0` → `double 1.0`；`double 1.0` 和 `double 2.0` 相等性比较 → `boolean false`；将 `boolean false` 存储到 `c`
	从 `a` 加载 → `int 1 @1`；`int 1 @0` 和 `int 1 @1` 相等性比较 → `boolean true`；将 `boolean true` 存储到 `c`

使用引用类型的相等性比较。

List a = new ArrayList(); 
List b = new ArrayList(); 
a.add(1);                 
boolean c = a == b;       
b.add(1);                 
c = a == b;

	声明 `List a`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `a`
	声明 `List b`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `b`
	从 `a` 加载 → `List 引用`；使用参数 (`int 1`) 调用 `List 引用` 的 `add` 方法
	声明 `boolean c`；从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；使用参数 (`List 引用 @1`) 调用 `List 引用 @0` 的 `equals` 方法 → `boolean false`；将 `boolean false` 存储到 `c`
	从 `b` 加载 → `List 引用`；使用参数 (`int 1`) 调用 `List 引用` 的 `add` 方法
	从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；使用参数 (`List 引用 @1`) 调用 `List 引用 @0` 的 `equals` 方法 → `boolean true`；将 `boolean true` 存储到 `c`

使用 null 的相等性比较。

Object a = null;       
Object b = null;       
boolean c = a == null; 
c = a == b;            
b = new Object();      
c = a == b;

	声明 `Object a`；将 `null` 存储到 `a`
	声明 `Object b`；将 `null` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `null @0`；`null @0` 和 `null @1` 相等性比较 → `boolean true`；将 `boolean true` 存储到 `c`
	从 `a` 加载 → `null @0`；从 `b` 加载 → `null @1`；`null @0` 和 `null @1` 相等性比较 → `boolean true`；将 `boolean true` 存储到 `c`
	分配 `Object` 实例 → `Object 引用`；将 `Object 引用` 存储到 `b`
	从 `a` 加载 → `Object 引用`；从 `b` 加载 → `null`；使用参数 (`null`) 调用 `Object 引用` 的 `equals` 方法 → `boolean false`；将 `boolean false` 存储到 `c`

使用 def 类型的相等性比较。

def a = 0;               
def b = 1;               
boolean c = a == b;      
def d = new HashMap();   
def e = new ArrayList(); 
c = d == e;

	声明 `def a`；隐式转换 `int 0` 为 `def` → `def`；将 `def` 存储到 `a`；
	声明 `def b`；隐式转换 `int 1` 为 `def` → `def`；将 `def` 存储到 `b`；
	声明 `boolean c`；从 `a` 加载 → `def`；隐式转换 `a` 为 `int 0` → `int 0`；从 `b` 加载 → `def`；隐式转换 `b` 为 `int 1` → `int 1`；相等性比较 `int 0` 和 `int 1` → `boolean false`；将 `boolean false` 存储到 `c`
	声明 `def d`；分配 `HashMap` 实例 → `HashMap 引用`；隐式转换 `HashMap 引用` 为 `def` → `def`；将 `def` 存储到 `d`；
	声明 `def e`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `def` → `def`；将 `def` 存储到 `d`；
	从 `d` 加载 → `def`；隐式转换 `def` 为 `HashMap 引用` → `HashMap 引用`；从 `e` 加载 → `def`；隐式转换 `def` 为 `ArrayList 引用` → `ArrayList 引用`；调用 `HashMap 引用` 上的 `equals` 方法，参数为 (`ArrayList 引用`) → `boolean false`；将 `boolean false` 存储到 `c`

不相等比较

编辑

使用 不相等运算符 '!==' 比较两个值，如果两个值不相等，则结果为 boolean 类型值 true，否则为 false。当值为引用类型时，隐式调用成员方法 equals，第一个值作为调用目标，第二个值作为参数，结果 boolean 类型值取反。此操作是 空安全 的，如果两个值都为 null，则结果 boolean 类型值为 false；如果只有一个值为 null，则结果 boolean 类型值为 true。有效的比较对象包括布尔类型值、数值类型值或引用类型值。

错误

如果在 boolean 类型值和数字类型值之间进行比较。
如果在原始类型值和引用类型值之间进行比较。

语法

equality_not_equals: expression '!=' expression;

提升

	布尔型	byte	short	char	int	long	float	double	引用类型	def
布尔型	布尔型	-	-	-	-	-	-	-	-	def
byte	-	int	int	int	int	long	float	double	-	def
short	-	int	int	int	int	long	float	double	-	def
char	-	int	int	int	int	long	float	double	-	def
int	-	int	int	int	int	long	float	double	-	def
long	-	long	long	long	long	long	float	double	-	def
float	-	float	float	float	float	float	float	double	-	def
double	-	double	double	double	double	double	double	double	-	def
引用类型	-	-	-	-	-	-	-	-	对象	def
def	def	def	def	def	def	def	def	def	def	def

示例

布尔类型的不相等比较。

boolean a = true;  
boolean b = false; 
a = a != false;    
b = a != b;

	声明 `boolean a`；将 `boolean true` 存储到 `a`
	声明 `boolean b`；将 `boolean false` 存储到 `b`
	从 `a` 加载 → `boolean true`；`boolean true` 和 `boolean false` 不相等比较 → `boolean true`；将 `boolean true` 存储到 `a`
	从 `a` 加载 → `boolean true`；从 `b` 加载 → `boolean false`；`boolean true` 和 `boolean false` 不相等比较 → `boolean true`；将 `boolean true` 存储到 `b`

基本类型的不相等比较。

int a = 1;          
double b = 2.0;     
boolean c = a != b; 
c = 1 != a;

	声明 `int a`；将 `int 1` 存储到 `a`
	声明 `double b`；将 `double 1.0` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `int 1`；从 `b` 加载 → `double 2.0`；提升 `int 1` 和 `double 2.0`：结果为 `double`；隐式转换 `int 1` 为 `double 1.0` → `double 1.0`；`double 1.0` 和 `double 2.0` 不相等比较 → `boolean true`；将 `boolean true` 存储到 `c`
	从 `a` 加载 → `int 1 @1`；`int 1 @0` 和 `int 1 @1` 不相等比较 → `boolean false`；将 `boolean false` 存储到 `c`

引用类型的不相等比较。

List a = new ArrayList(); 
List b = new ArrayList(); 
a.add(1);                 
boolean c = a == b;       
b.add(1);                 
c = a == b;

	声明 `List a`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `a`
	声明 `List b`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `b`
	从 `a` 加载 → `List 引用`；使用参数 (`int 1`) 调用 `List 引用` 的 `add` 方法
	声明 `boolean c`；从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；调用 `List 引用 @0` 上的 `equals` 方法，参数为 (`List 引用 @1`) → `boolean false`；布尔非 `boolean false` → `boolean true`；将 `boolean true` 存储到 `c`
	从 `b` 加载 → `List 引用`；使用参数 (`int 1`) 调用 `List 引用` 的 `add` 方法
	从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；调用 `List 引用 @0` 上的 `equals` 方法，参数为 (`List 引用 @1`) → `boolean true`；布尔非 `boolean true` → `boolean false`；将 `boolean false` 存储到 `c`

与 null 的不相等比较。

Object a = null;       
Object b = null;       
boolean c = a == null; 
c = a == b;            
b = new Object();      
c = a == b;

	声明 `Object a`；将 `null` 存储到 `a`
	声明 `Object b`；将 `null` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `null @0`；`null @0` 和 `null @1` 不相等比较 → `boolean false`；将 `boolean false` 存储到 `c`
	从 `a` 加载 → `null @0`；从 `b` 加载 → `null @1`；`null @0` 和 `null @1` 不相等比较 → `boolean false`；将 `boolean false` 存储到 `c`
	分配 `Object` 实例 → `Object 引用`；将 `Object 引用` 存储到 `b`
	从 `a` 加载 → `对象引用`；从 `b` 加载 → `null`；调用 `对象引用` 上的 `equals` 方法，参数为 (`null`) → `boolean false`；布尔非 `boolean false` → `boolean true`；将 `boolean true` 存储到 `c`

与 def 类型的比较。

def a = 0;               
def b = 1;               
boolean c = a == b;      
def d = new HashMap();   
def e = new ArrayList(); 
c = d == e;

	声明 `def a`；隐式转换 `int 0` 为 `def` → `def`；将 `def` 存储到 `a`；
	声明 `def b`；隐式转换 `int 1` 为 `def` → `def`；将 `def` 存储到 `b`；
	声明 `boolean c`；从 `a` 加载 → `def`；隐式转换 `a` 为 `int 0` → `int 0`；从 `b` 加载 → `def`；隐式转换 `b` 为 `int 1` → `int 1`；相等性比较 `int 0` 和 `int 1` → `boolean false`；将 `boolean false` 存储到 `c`
	声明 `def d`；分配 `HashMap` 实例 → `HashMap 引用`；隐式转换 `HashMap 引用` 为 `def` → `def`；将 `def` 存储到 `d`；
	声明 `def e`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `def` → `def`；将 `def` 存储到 `d`；
	从 `d` 加载 → `def`；隐式转换 `def` 为 `HashMap 引用` → `HashMap 引用`；从 `e` 加载 → `def`；隐式转换 `def` 为 `ArrayList 引用` → `ArrayList 引用`；调用 `HashMap 引用` 上的 `equals` 方法，参数为 (`ArrayList 引用`) → `boolean false`；将 `boolean false` 存储到 `c`

同一性相等比较

编辑

使用 同一性相等运算符 '===' 比较两个值，如果两个值相等，则结果为 boolean 类型值 true，否则为 false。如果两个引用类型值都指向堆上的同一实例，或者两个值都为 null，则它们相等。有效的比较对象包括布尔类型值、数值类型值或引用类型值。

错误

如果在 boolean 类型值和数字类型值之间进行比较。
如果在原始类型值和引用类型值之间进行比较。

语法

identity_equals: expression '===' expression;

提升

	布尔型	byte	short	char	int	long	float	double	引用类型	def
布尔型	布尔型	-	-	-	-	-	-	-	-	def
byte	-	int	int	int	int	long	float	double	-	def
short	-	int	int	int	int	long	float	double	-	def
char	-	int	int	int	int	long	float	double	-	def
int	-	int	int	int	int	long	float	double	-	def
long	-	long	long	long	long	long	float	double	-	def
float	-	float	float	float	float	float	float	double	-	def
double	-	double	double	double	double	double	double	double	-	def
引用类型	-	-	-	-	-	-	-	-	对象	def
def	def	def	def	def	def	def	def	def	def	def

示例

引用类型的同一性相等比较。

List a = new ArrayList(); 
List b = new ArrayList(); 
List c = a;               
boolean c = a === b;      
c = a === c;

	声明 `List a`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `a`
	声明 `List b`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `b`
	从 `a` 加载 → `List 引用`；将 `List 引用` 存储到 `c`
	声明 `boolean c`；从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；`List 引用 @0` 和 `List 引用 @1` 同一性相等比较 → `boolean false`；将 `boolean false` 存储到 `c`
	从 `a` 加载 → `List 引用 @0`；从 `c` 加载 → `List 引用 @1`；`List 引用 @0` 和 `List 引用 @1` 同一性相等比较 → `boolean true`；将 `boolean true` 存储到 `c`（注意 `List 引用 @0` 和 `List 引用 @1` 指向同一实例）

与 null 的同一性相等比较。

Object a = null;        
Object b = null;        
boolean c = a === null; 
c = a === b;            
b = new Object();       
c = a === b;

	声明 `Object a`；将 `null` 存储到 `a`
	声明 `Object b`；将 `null` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `null @0`；`null @0` 和 `null @1` 同一性相等比较 → `boolean true`；将 `boolean true` 存储到 `c`
	从 `a` 加载 → `null @0`；从 `b` 加载 → `null @1`；`null @0` 和 `null @1` 同一性相等比较 → `boolean true`；将 `boolean true` 存储到 `c`
	分配 `Object` 实例 → `Object 引用`；将 `Object 引用` 存储到 `b`
	从 `a` 加载 → `对象引用`；从 `b` 加载 → `null`；`对象引用` 和 `null` 同一性相等比较 → `boolean false`；将 `boolean false` 存储到 `c`

与 def 类型的同一性相等比较。

def a = new HashMap();   
def b = new ArrayList(); 
boolean c = a === b;     
b = a;                   
c = a === b;

	声明 `def d`；分配 `HashMap` 实例 → `HashMap 引用`；隐式转换 `HashMap 引用` 为 `def` → `def`；将 `def` 存储到 `d`
	声明 `def e`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `def` → `def`；将 `def` 存储到 `d`
	声明 `boolean c`；从 `a` 加载 → `def`；隐式转换 `def` 为 `HashMap 引用` → `HashMap 引用`；从 `b` 加载 → `def`；隐式转换 `def` 为 `ArrayList 引用` → `ArrayList 引用`；`HashMap 引用` 和 `ArrayList 引用` 同一性相等比较 → `boolean false`；将 `boolean false` 存储到 `c`
	从 `a` 加载 → `def`；将 `def` 存储到 `b`
	从 `a` 加载 → `def`；隐式转换 `def` 为 `HashMap 引用 @0` → `HashMap 引用 @0`；从 `b` 加载 → `def`；隐式转换 `def` 为 `HashMap 引用 @1` → `HashMap 引用 @1`；`HashMap 引用 @0` 和 `HashMap 引用 @1` 同一性相等比较 → `boolean true`；将 `boolean true` 存储到 `b`；（注意 `HashMap 引用 @0` 和 `HashMap 引用 @1` 指向同一实例）

同一性不相等比较

编辑

使用 同一性不相等运算符 '!==' 比较两个值，如果两个值不相等，则结果为 boolean 类型值 true，否则为 false。如果两个引用类型值指向堆上的不同实例，或者一个值为 null 而另一个值不是，则它们不相等。有效的比较对象包括布尔类型值、数值类型值或引用类型值。

错误

如果在 boolean 类型值和数字类型值之间进行比较。
如果在原始类型值和引用类型值之间进行比较。

语法

identity_not_equals: expression '!==' expression;

提升

	布尔型	byte	short	char	int	long	float	double	引用类型	def
布尔型	布尔型	-	-	-	-	-	-	-	-	def
byte	-	int	int	int	int	long	float	double	-	def
short	-	int	int	int	int	long	float	double	-	def
char	-	int	int	int	int	long	float	double	-	def
int	-	int	int	int	int	long	float	double	-	def
long	-	long	long	long	long	long	float	double	-	def
float	-	float	float	float	float	float	float	double	-	def
double	-	double	double	double	double	double	double	double	-	def
引用类型	-	-	-	-	-	-	-	-	对象	def
def	def	def	def	def	def	def	def	def	def	def

示例

引用类型的同一性不相等比较。

List a = new ArrayList(); 
List b = new ArrayList(); 
List c = a;               
boolean c = a !== b;      
c = a !== c;

	声明 `List a`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `a`
	声明 `List b`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `b`
	从 `a` 加载 → `List 引用`；将 `List 引用` 存储到 `c`
	声明 `boolean c`；从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；身份不相等 `List 引用 @0` 和 `List 引用 @1` → `boolean true` 将 `boolean true` 存储到 `c`
	从 `a` 加载 → `List 引用 @0`；从 `c` 加载 → `List 引用 @1`；身份不相等 `List 引用 @0` 和 `List 引用 @1` → `boolean false` 将 `boolean false` 存储到 `c`（注意 `List 引用 @0` 和 `List 引用 @1` 指向同一个实例）

与 null 身份不相等。

Object a = null;        
Object b = null;        
boolean c = a !== null; 
c = a !== b;            
b = new Object();       
c = a !== b;

	声明 `Object a`；将 `null` 存储到 `a`
	声明 `Object b`；将 `null` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `null @0`；身份不相等 `null @0` 和 `null @1` → `boolean false`；将 `boolean false` 存储到 `c`
	从 `a` 加载 → `null @0`；从 `b` 加载 → `null @1`；身份不相等 `null @0` 和 `null @1` → `boolean false`；将 `boolean false` 存储到 `c`
	分配 `Object` 实例 → `Object 引用`；将 `Object 引用` 存储到 `b`
	从 `a` 加载 → `对象引用`；从 `b` 加载 → `null`；身份不相等 `对象引用` 和 `null` → `boolean true`；将 `boolean true` 存储到 `c`

与 def 类型身份不相等。

def a = new HashMap();   
def b = new ArrayList(); 
boolean c = a !== b;     
b = a;                   
c = a !== b;

	声明 `def d`；分配 `HashMap` 实例 → `HashMap 引用`；隐式转换 `HashMap 引用` 为 `def` → `def`；将 `def` 存储到 `d`
	声明 `def e`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `def` → `def`；将 `def` 存储到 `d`
	声明 `boolean c`；从 `a` 加载 → `def`；隐式转换 `def` 到 `HashMap 引用` → `HashMap 引用`；从 `b` 加载 → `def`；隐式转换 `def` 到 `ArrayList 引用` → `ArrayList 引用`；身份不相等 `HashMap 引用` 和 `ArrayList 引用` → `boolean true`；将 `boolean true` 存储到 `c`
	从 `a` 加载 → `def`；将 `def` 存储到 `b`
	从 `a` 加载 → `def`；隐式转换 `def` 到 `HashMap 引用 @0` → `HashMap 引用 @0`；从 `b` 加载 → `def`；隐式转换 `def` 到 `HashMap 引用 @1` → `HashMap 引用 @1`；身份不相等 `HashMap 引用 @0` 和 `HashMap 引用 @1` → `boolean false`；将 `boolean false` 存储到 `b`；（注意 `HashMap 引用 @0` 和 `HashMap 引用 @1` 指向同一个实例）

布尔异或

编辑

使用 布尔异或运算符 '^' 将两个 boolean 类型的值进行异或运算，如果一个 boolean 类型的值为 true，另一个为 false，则结果 boolean 类型的值为 true，否则为 false。

错误

如果任一计算值不是 boolean 类型的值，或者不能转换为 boolean 类型的值。

真值

	true	false
true	false	true
false	true	false

语法

boolean_xor: expression '^' expression;

示例

使用 boolean 类型的布尔异或。

boolean x = false;    
boolean y = x ^ true; 
y = y ^ x;

	声明 `boolean x`；将 `boolean false` 存储到 `x`
	声明 `boolean y`；从 `x` 加载 → `boolean false` 布尔异或 `boolean false` 和 `boolean true` → `boolean true`；将 `boolean true` 存储到 `y`
	从 `y` 加载 → `boolean true @0`；从 `x` 加载 → `boolean true @1`；布尔异或 `boolean true @0` 和 `boolean true @1` → `boolean false`；将 `boolean false` 存储到 `y`

使用 def 类型的布尔异或。

def x = false;    
def y = x ^ true; 
y = y ^ x;

	声明 `def x`；隐式转换 `boolean false` 到 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 到 `boolean false` → `boolean false`；布尔异或 `boolean false` 和 `boolean true` → `boolean true`；隐式转换 `boolean true` 到 `def` → `def`；将 `def` 存储到 `y`
	从 `y` 加载 → `def`；隐式转换 `def` 到 `boolean true @0` → `boolean true @0`；从 `x` 加载 → `def`；隐式转换 `def` 到 `boolean true @1` → `boolean true @1`；布尔异或 `boolean true @0` 和 `boolean true @1` → `boolean false`；隐式转换 `boolean false` → `def`；将 `def` 存储到 `y`

布尔与

编辑

使用 布尔与运算符 '&&' 将两个 boolean 类型的值进行与运算，如果两个 boolean 类型的值都为 true，则结果 boolean 类型的值为 true，否则为 false。

错误

如果任一计算值不是 boolean 类型的值，或者不能转换为 boolean 类型的值。

真值

	true	false
true	true	false
false	false	false

语法

boolean_and: expression '&&' expression;

示例

使用 boolean 类型的布尔与。

boolean x = true;      
boolean y = x && true; 
x = false;             
y = y && x;

	声明 `boolean x`；将 `boolean true` 存储到 `x`
	声明 `boolean y`；从 `x` 加载 → `boolean true @0`；布尔与 `boolean true @0` 和 `boolean true @1` → `boolean true`；将 `boolean true` 存储到 `y`
	将 `boolean false` 存储到 `x`
	从 `y` 加载 → `boolean true`；从 `x` 加载 → `boolean false`；布尔与 `boolean true` 和 `boolean false` → `boolean false`；将 `boolean false` 存储到 `y`

使用 def 类型的布尔与。

def x = true;      
def y = x && true; 
x = false;         
y = y && x;

	声明 `def x`；隐式转换 `boolean true` 到 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 到 `boolean true @0` → `boolean true @0`；布尔与 `boolean true @0` 和 `boolean true @1` → `boolean true`；隐式转换 `boolean true` 到 `def` → `def`；将 `def` 存储到 `y`
	隐式转换 `boolean false` 到 `def` → `def`；将 `def` 存储到 `x`；
	从 `y` 加载 → `def`；隐式转换 `def` 到 `boolean true` → `boolean true`；从 `x` 加载 → `def`；隐式转换 `def` 到 `boolean false` → `boolean false`；布尔与 `boolean true` 和 `boolean false` → `boolean false`；隐式转换 `boolean false` → `def`；将 `def` 存储到 `y`

布尔或

编辑

使用 布尔或运算符 '||' 将两个 boolean 类型的值进行或运算，如果两个 boolean 类型的值中有一个为 true，则结果 boolean 类型的值为 true，否则为 false。

错误

如果任一计算值不是 boolean 类型的值，或者不能转换为 boolean 类型的值。

真值

	true	false
true	true	true
false	true	false

语法

boolean_and: expression '||' expression;

示例

使用 boolean 类型的布尔或。

boolean x = false;     
boolean y = x || true; 
y = false;             
y = y || x;

	声明 `boolean x`；将 `boolean false` 存储到 `x`
	声明 `boolean y`；从 `x` 加载 → `boolean false`；布尔或 `boolean false` 和 `boolean true` → `boolean true`；将 `boolean true` 存储到 `y`
	将 `boolean false` 存储到 `y`
	从 `y` 加载 → `boolean false @0`；从 `x` 加载 → `boolean false @1`；布尔或 `boolean false @0` 和 `boolean false @1` → `boolean false`；将 `boolean false` 存储到 `y`

使用 def 类型的布尔或。

def x = false;     
def y = x || true; 
y = false;         
y = y || x;

	声明 `def x`；隐式转换 `boolean false` 到 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 到 `boolean false` → `boolean true`; 布尔或 `boolean false` 和 `boolean true` → `boolean true`；隐式转换 `boolean true` 到 `def` → `def`；将 `def` 存储到 `y`
	隐式转换 `boolean false` 为 `def` → `def`；将 `def` 存储到 `y`；
	从 `y` 加载 → `def`；隐式转换 `def` 为 `boolean false @0` → `boolean false @0`；从 `x` 加载 → `def`；隐式转换 `def` 为 `boolean false @1` → `boolean false @1`；布尔或 `boolean false @0` 和 `boolean false @1` → `boolean false`；隐式转换 `boolean false` → `def`；将 `def` 存储到 `y`

« 运算符：数值运算符：参考 »