› ›

运算符：布尔

编辑

运算符：布尔

编辑

布尔非运算符

编辑

使用 布尔非运算符 '!' 来对 boolean 类型的值进行 NOT 运算，其中 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 引用`；instanceof `HashMap 引用` 和 `HashMap` → `boolean true`；存储 `boolean true` 到 `a`
	声明 `boolean b`；从 `m` 加载 → `Map 引用`；隐式转换 `Map 引用` 为 `HashMap 引用` → `HashMap 引用`；instanceof `HashMap 引用` 和 `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 引用`；instanceof `ArrayList 引用` 和 `List` → `boolean true`；存储 `boolean true` 到 `a`；（注意 `ArrayList` 是 `List` 的子类）
	声明 `boolean b`；从 `d` 加载 → `def`；隐式转换 `def` 为 `ArrayList 引用` → `ArrayList 引用`；instanceof `ArrayList 引用` 和 `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 引用`；调用 `add` 在 `List 引用` 上，参数为 (`int 1)`
	声明 `boolean c`；从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；调用 `equals` 在 `List 引用 @0` 上，参数为 (`List 引用 @1`) → `boolean false`；存储 `boolean false` 到 `c`
	从 `b` 加载 → `List 引用`；调用 `add` 在 `List 引用` 上，参数为 (`int 1`)
	从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；调用 `equals` 在 `List 引用 @0` 上，参数为 (`List 引用 @1`) → `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`；调用 `equals` 在 `Object 引用` 上，参数为 (`null`) → `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 安全的，如果两个值都为 null，则结果 boolean 类型值为 false，如果只有一个值为 null，则结果 boolean 类型值为 true。合法的比较是 boolean 类型值、数值类型值或引用类型值之间的比较。

错误

如果在 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 类型进行不等于比较。

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 引用`；调用 `add` 在 `List 引用` 上，参数为 (`int 1)`
	声明 `boolean c`；从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；调用 `List 引用 @0` 的 `equals` 方法，参数为 (`List 引用 @1`) → `boolean false`；boolean 非 `boolean false` → `boolean true`；将 `boolean true` 存储到 `c`
	从 `b` 加载 → `List 引用`；调用 `add` 在 `List 引用` 上，参数为 (`int 1`)
	从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；调用 `List 引用 @0` 的 `equals` 方法，参数为 (`List 引用 @1`) → `boolean true`；boolean 非 `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` 加载 → `Object 引用`；从 `b` 加载 → `null`；调用 `Object 引用` 的 `equals` 方法，参数为 (`null`) → `boolean false`；boolean 非 `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 类型值、数值类型值或引用类型值之间的比较。

错误

如果在 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` 加载 → `Object 引用`；从 `b` 加载 → `null`；恒等比较 `Object 引用` 和 `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 类型值、数值类型值或引用类型值之间进行。

错误

如果在 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` 加载 → `Object 引用`；从 `b` 加载 → `null`；比较 `Object 引用` 和 `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`

« 运算符：数值运算符：引用 »