Groovy 运算符

Groovy 运算符

官方文档（运算符）：http://www.groovy-lang.org/operators.html

1. 算术运算符

1.1 除法

如果操作数是float或double，则除法/或/=会产生一个double，反之，则会产生一个BigDecimal的结果(当这两个操作数都是整型short, char, byte, int, long, BigInteger 或 BigDecimal的组合)。

对于像Java那样的整数除法，应该使用intdiv()方法，Groovy并没有提供一个专用的整数除法运算符。

1.2 次方运算符

**

assert  2 ** 3 == 8
 
def f = 3
f **= 2
assert f == 9

2. 条件运算符

2.1 三元运算符

Java写法：

result = (string!=null && string.length()>0) ? 'Found' : 'Not found'

Groovy的更简短：

result = string ? 'Found' : 'Not found'

Groovy truth

2.2 Elvis operator

Elvis运算符 ?:是三元运算符的缩短:

displayName = user.name ? user.name : 'Anonymous'   
displayName = user.name ?: 'Anonymous'     

使用Elvis操作符可以减少代码的冗余，减少重构时出错的风险，消除条件和正返回值的复制。

3. 对象操作符

3.1 安全导航操作符

安全导航操作符?.用于避免NullPointerException，通常使用对象引用时，在访问对象的方法或属性之前，可能需要验证引用是否为null，为了避免这种情况，安全导航操作符将简单地返回null而不是抛出异常（如果为引用为null，则返回null）。

class Person{
    public String name = 'aaa'
}
 
Person person              
println(person?.name)  // null
println(person.name)  // java.lang.NullPointerException

3.2 直接字段访问操作符

因为Groovy自动支持属性的getter方法，但有时我们会自定义getter方法，如果不想调用自定义的getter方法，那么可以用直接字段访问操作符 .@。

class User {
    public final String name                 
    User(String name) { this.name = name}
    String getName() { "Name: $name" }
}
def user = new User('Bob')
assert user.name == 'Name: Bob'  // 会触发getter方法调用
assert user.@name == "Bob"  // 直接访问name字段

.@会强制使用字段而不是getter

3.3 方法指针操作符

方法指针操作符 .& 将对方法的引用存储于变量中，以便稍后调用它：

def str = 'example String'
def upperFun = str.&toUpperCase //将str实例的toUpperCase方法的引用存储到upperFun变量内
def result = upperFun()  // 像常规方法一样调用upperFun
assert result == str.toUpperCase()  // 与在str上直接调用方法的结果一样
println(result)  // EXAMPLE STRING

使用方法指针有多个优点。首先，方法指针的类型是 groovy.lang.Closure，所以可以在任何使用闭包的地方使用它。特别适合于针对策略模式的需求转换现有方法的情景：

class Person{
    String name
    int age
    Person(String name, int age){
        this.name = name
        this.age = age
    }
}
def list = [
    new Person("wzx", 24),
    new Person("lc", 22)]
    
//描述一个Person对象的方法
def describe(Person p){
    "$p.name is $p.age"
}   
  
//转换方法：遍历List，将每一个元素都执行一次describe方法
def transform(List elements, Closure closure){
    def list = [];
    elements.each{
        list << closure(it)
    }
    list
}
 
//存储describe方法引用的变量
def describeReference = this.&describe
assert transform(list, describeReference) == ['wzx is 24', 'lc is 22']

存储引用的变量只与方法名称绑定，其参数在运行时才会解析。这意味着如果有多个名称相同的方法，在运行时才会根据传入的参数调用适当的方法：

def doSomething(String str){str.toUpperCase()}
def doSomething(int num){num ** 2}
def reference = this.&doSomething
assert reference('abc') == 'ABC'
assert reference(3) == 9

4. 正则表达式操作符

4.1 Pattern操作符

Pattern操作符 ~ 提供了一个创建java.util.regex.Pattern实例的简单方式，通常和斜线字符串一起使用，不过可以与任何Groovy String一起使用。

def p = ~/foo/ 
p = ~'foo'                                                        
p = ~"foo"                                                        
p = ~$/dollar/slashy $ string/$                                   
p = ~"${pattern}"  
assert p instanceof Pattern 

创建Pattern后不能再改变

def pattern = 'aabb'
def p = ~"${pattern}"
assert p.toString() == 'aabb'
 
pattern = 'ttyy'
assert p.toString() == 'aabb'

4.2 查找操作符

可以使用 =~ 操作符直接构建一个java.util.regex.Matcher实例

def text = "some text to match"
def m = text =~ /.*match.*/                                           
assert m instanceof Matcher  // =~ 的返回类型为Matcher
assert m  // true，相当于调用了m.find()
println(m.group())  // some text to match

4.3 匹配操作符

==~ 返回的是Boolean

def text = 'text to match'
def m = text ==~ /.*match.*/ 
assert m instanceof Boolean  
if (m) {
   println('text match!')  // text match!
}

5. 其他操作符

5.1 扩展操作符

*. 用于对聚合对象的所有item进行操作，相当于在每一个item上操作，并将结果放在一个List中

class Person{
    String name
    int age
}
def persons = [
    new Person(name:'wzx', age:24),
    new Person(name:'lc', age:22)
]
def result = persons*.name;  //相当于在每一个item上操作，并将结果放在一个List中
assert result instanceof List
println(result)  // [wzx, lc]

扩展运算符是null安全的，如果集合的一个元素为null，它将返回null而不是抛出NullPointerException

def persons = [
    new Person(name:'wzx', age:24),
    null,
    new Person(name:'lc', age:22)
]
def result = persons*.name;
println(result)  // [wzx, null, lc]

对于实现了Iterable接口的任意类，都可以使用该操作符

5.1.1 扩展方法参数

* 例如，假设具有以下方法签名：

def fun(String a, String b, int c){
    "$a $b $c"
}

有以下列表：

def args = ["aaa", "bbb", 123]

可以调用该方法而不必定义中间变量：

assert function(*args) == 'aaa bbb 123'

甚至可以将普通参数与传播参数进行混合：

params = ["aaa", "bbb"]
assert function(*args, 123) == 'aaa bbb 123'

5.1.2 扩展List元素

*

def items = [4,5]                      
def list = [1,2,3,*items,6]  //不用addAll()而直接将items插入到list中    
assert list == [1,2,3,4,5,6] //items已经被内联到list中

5.1.3 扩展Map元素

*:

def m1 = [c:3, d:4]                   
def map = [a:1, b:2, *:m1]            
assert map == [a:1, b:2, c:3, d:4]

扩展的结果与插入操作符的位置有关：

def m1 = [c:3, d:4]                   
def map = [a:1, b:2, *:m1, d:8]  // 扩展后d的值被重新指定了
assert map == [a:1, b:2, c:3, d:8]

5.2 范围操作符

Groovy提供..来创建范围对象

def range = 0..5 //用一个变量来存储一个整数范围对象                              
assert (0..5).collect() == [0, 1, 2, 3, 4, 5] // 一个IntRange，包含边界
assert (0..<5).collect() == [0, 1, 2, 3, 4] // 一个IntRange，不包含上边界
assert (0..5) instanceof List // groovy.lang.Range实际是一个List 
assert (0..5).size() == 6 //可以调用size()
assert ('a'..'d').collect() == ['a','b','c','d']

5.3 比较运算符

<=>代理了compareTo方法：

assert (1 <=> 1) == 0
assert (1 <=> 2) == -1
assert (2 <=> 1) == 1
assert ('a' <=> 'z') == -1

5.4 下标运算符

下标运算符[]是getAt或putAt的简写：

def list = [0,1,2,3,4]                    
list[2] = 4                                 
assert list[0..2] == [0,1,4]                
list[0..2] = [6,6,6]                        
assert list == [6,6,6,3,4] 

下标运算符结合自定义实现的getAt/ putAt是解构对象的一种方便的方法：

class Person{
    int id;
    String name;
    
    def getAt(int i){  //自定义的getAt实现
        switch(i){
            case 0: return id;
            case 1: return name;
        }
        throw new IllegalArgumentException("No such element $i")
    }
    void putAt(int i, def value){  //自定义的putAt实现
        switch(i){
            case 0: this.id = value; return;
            case 1: this.name = value; return;
        }
        throw new IllegalArgumentException("No such element $i")
    }
}
 
def p = new Person(id:10001, name:"wzx")
assert p[0] == 10001;
assert p[1] == "wzx"
p[1] = "lc"
assert p[1] == "lc"
assert p.name == "lc"

5.5 从属运算符

in相当于调用 isCase

def list = ['wzx', 'lc', 'aaa']
assert ('lc' in list)
assert list.contains('lc')
assert list.isCase('lc')
 
def map = ['wzx':24, 'lc':22]
assert ('wzx' in map)
assert map.containsKey('wzx')
assert map.isCase('wzx')

5.6 相等运算符

在Groovy中，使用==测试相等性不同于在Java中使用相同的运算符。在Groovy，它会调用equals。如果要比较引用的相等性，应该使用is：

def list1 = ['wzx', 'lc']
def list2 = ['wzx', 'lc']
assert list1 == list2
assert !list1.is(list2)

5.7 强制转换操作符

类型不兼容：

String s = "123"
Integer x = (Integer) s

运行时抛出异常：GroovyCastException: Cannot cast object '123' with class 'java.lang.String' to class 'java.lang.Integer'

可以使用as完成转换：

String s = "123"
Integer x = s as Integer
println(x)  // 123

当一个对象被强转到另一个对象时，若目标类型与源类型相同，强转将返回一个新对象。转换的规则取决于源类型和目标类型，如果没有找到转换规则，强转可能会失败。通过asType方法可以自定义转换规则:

class Orange{
    String name
}
class Apple{
    String name
    def asType(Class target){
        if(target == Orange){
            return new Orange(name:name)
        }
        throw new ClassCastException("Apple cannot be coerced into $target")
    }
}
 
def apple = new Apple(name: "Apple")
def orange = apple as Orange  //强转成功则返回一个新对象
assert !(orange instanceof Apple)
assert orange instanceof Orange
println(orange.name); //Apple

5.8 调用操作符

操作符()是call的隐式调用，对于定义了call方法的任何对象都可以省略.call部分

class MyCallable {
    int call(int x) {           
        2*x
    }
}
def mc = new MyCallable()
assert mc.call(2) == 4          
assert mc(2) == 4 

6. 运算符优先级

7. 运算符重载

Groovy允许重载各种运算符，以便它们可以与自己的类一起使用，下面是个简单的类：

class Bucket {
    int size
 
    Bucket(int size) { this.size = size }
 
    Bucket plus(Bucket other) {                     
        return new Bucket(this.size + other.size)
    }
}

Bucket 实现了一个特殊的方法 plus()，只要实现该方法，Bucket类就可以与+运算符一起使用：

def b1 = new Bucket(4)
def b2 = new Bucket(11)
assert (b1 + b2).size == 15 

所有Groovy运算符（非比较）都有一个相应的方法，可以在自己的类中实现。唯一的要求是方法是public，有正确的名称，正确的参数数量，参数类型取决于要运算符右侧要支持的类型，比如：

Bucket plus(int capacity) {
    return new Bucket(this.size + capacity)
}
assert (b1 + 11).size == 15

以下是运算符及其相应方法的完整列表: