操作符	用途	说明
`+`	相加
`-`	相减
`*`	相乘
`/`	相除	如果想使用整数除法，请使用 intdiv() 方法，请同时查看 integer division 章节了解更多关于整数除法的返回值类型信息。
`%`	取余
`**`	乘方	请查看 the power operation 章节来了解更多关于乘方操作符的返回值信息。

下面是关于这些操作符用法的一些例子：


assert  1  + 2 == 3
assert  4  - 3 == 1
assert  3  * 5 == 15
assert  3  / 2 == 1.5
assert 10  % 3 == 1
assert  2 ** 3 == 8

1.2 一元操作符

+ 和 - 操作符也可以被当作一元操作符来使用：


assert +3 == 3
assert -4 == 0 - 4
 
assert -(-1) == 1      //1

//1：将一元操作符 - 应用到表达式上时，需要在表达式上添加括号

在一元算术操作符方面，Groovy 也同时支持前缀和后缀形式的自增（++）和自减（--）操作符：


def a = 2
def b = a++ * 3                 //1
 
assert a == 3 && b == 6
 
def c = 3
def d = c-- * 2                 //2
 
assert c == 2 && d == 6
 
def e = 1
def f = ++e + 3                 //3
 
assert e == 2 && f == 5
 
def g = 4
def h = --g + 1                 //4
 
assert g == 3 && h == 4

//1: 后缀自增操作符会在表达式求值完成后，对 a 执行自增操作，并将表达式的值赋值给 b

//2: 后缀自减操作符会在表达式求值完成后，对 c 执行自减操作，并将表达式的值赋值给 d

//3: 前缀自增操作符会先对 e 执行自增操作，然后对表达式进行求值并赋值给 f

//4: 前缀自减操作符会先对 g 执行自减操作，然后对表达式进行求值并赋值给 h

1.3 赋值算术操作符

前面我们看到的各种二元算术操作符都具有对应的赋值算术操作符形式：

+=
-=
*=
/=
%=
**=

我们来看些实例：


def a = 4
a += 3
 
assert a == 7
 
def b = 5
b -= 3
 
assert b == 2
 
def c = 5
c *= 3
 
assert c == 15
 
def d = 10
d /= 2
 
assert d == 5
 
def e = 10
e %= 3
 
assert e == 1
 
def f = 3
f **= 2
 
assert f == 9

2. 关系运算符

关系操作符允许在对象之间执行比较运算，以确定两个对象是否相同，或者是否一个比另一个大、小或等于另一个。Groovy 中有如下的关系运算符：

操作符	用途
`==`	等于
`!=`	不等于
`<`	小于
`<=`	小于等于
`>`	大于
`>=`	大于等于

下面是使用这些操作符进行简单的算术比较的例子：


assert 1 + 2 == 3
assert 3 != 4
 
assert -2 < 3
assert 2 <= 2
assert 3 <= 4
 
assert 5 > 1
assert 5 >= -2

3. 逻辑运算符

Groovy 为布尔表达式提供了 3 个逻辑运算符：

&&: 逻辑与
||: 逻辑或
!: 逻辑非

用下面例子作简单演示：


assert !false           
assert true && true     
assert true || false

3.1 优先级

逻辑非！运算符的优先级高于逻辑与 && 运算符：

assert (!false && false) == false     //1

//1: 这里断言为真（因为括号内的表达式为假），因为逻辑非运算符的优先级高于逻辑与运算符，所有逻辑非操作符只作用于第一个 false，不然的话，它就得作用于逻辑与运算的结果，导致断言失败。

逻辑与 && 运算符的优先级高于逻辑或 || 运算符：

assert true || true && false     //1

//1: 这里断言为真，因为 && 运算符的优先级比 || 运算符高，因此 || 运算最后执行，并返回真值。

3.2 短路特性

逻辑或 || 运算符具有短路特性：如果运算符的左操作数为真，那么它就已经知道结果无论如何都是真，因此右操作数就不会执行计算。仅当左操作数为假时，右操作数才会执行计算。

类似地，逻辑与操作也具有短路特性：如果运算符的左操作数为假，那么它就已经知道结果无论如何都是假，因此右操作数就不会执行计算。仅当左操作数为真时，右操作数才会执行计算。


boolean checkIfCalled() {       //1
    called = true
}
 
called = false
true || checkIfCalled()
assert !called                  //2
 
called = false
false || checkIfCalled()
assert called                   //3
 
called = false
false && checkIfCalled()
assert !called                  //4
 
called = false
true && checkIfCalled()
assert called                   //5

//1: 创建一个叫做 checkIfCalled 的函数，它内部会将 called 变量设置为 true

//2: 将 called 标记置为 false 后，我们验证下 || 操作符的左操作数为真时，不会对右操作数执行计算，因为 || 操作符具有短路特性

//3: 由于 || 操作符的左操作数为假，因此会对又操作数执行计算，导致 called 标记变为 true

//4: 类似的，我们验证 && 操作符的左操作数为假时，不会对右操作数执行计算

//5: 但是当 && 操作符的左操作数为真时，会对右操作数执行计算

4. 位运算操作符

Groovy 中有 4 个位运算操作符：

&: 位与
|: 位或
^: 位异或
~: 按位取反

位运算操作符可以应用于 byte 或 int 型数据，并返回一个 int 值：


int a = 0b00101010
assert a == 42
int b = 0b00001000
assert b == 8
assert (a & a) == a                         // 位与
assert (a & b) == b                         // 位与并返回同时为 1 的比特
assert (a | a) == a                         // 位或
assert (a | b) == a                         // 位或并返回所有为 1 的比特
 
int mask = 0b11111111                       // 设置一个只检查最后 8 位的掩码
assert ((a ^ a) & mask) == 0b00000000       // 对自身进行按位异或将返回 0
assert ((a ^ b) & mask) == 0b00100010       // 位异或
assert ((~a) & mask)    == 0b11010101       // 按位取反

值得注意的是，原始类型的内部表示遵循 Java 语言规范。特别地，原始类型是有符号的，这意味着对于按位取反操作，通常比较好的实践是：使用掩码来提取那些必需的比特。

在 Groovy 中，位操作符是可以重载的，意味着你可以针对任意类型的对象定义这些操作符作用在其上的行为。

5. 条件运算符

5.1 非运算符

非运算符由感叹号！表示，它会反转底层布尔表达式的计算结果。特别是非运算符可以和 Groovy 真值（Groovy truth）结合使用：


assert (!true)    == false   // 非 true 即 false                   
assert (!'foo')   == false   // 'foo' 是非空字符串，求值后为 true, 取非后得到 false                   
assert (!'')      == true    // '' 是空字符串，求值后为 false, 取非后得到 true

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/寸_铁/article/detail/810350