Groovy操作符

这一篇简单介绍一下Groovy中的操作符。

算数操作符

groovy支持java中的所有操作符，下面只列举一些groovy特有的：

** power运算符，也叫次方。

assert  2 ** 3 == 8

**= power的一元运算

def f = 3

f **= 2

assert f == 9

类操作符

Safe navigation operator（安全导航符）用于避免空指针。当不确定一个类是否是空指针的时候使用。

def person = Person.find { it.id == 123 }

def name = person?.name

assert name == null

Direct field access operator

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'

在groovy中，user.name会调用对应的getName()方法，这是groovy的一个语法特性，后面的章节再将。如果想要直接使用这个属性可以这么写：

assert user.@name == 'Bob'

Method pointer operator

.&用于将被调用的方法存入一个方法变量中，接着只要调用这个变量就相当于调用之前的那个方法。直接看代码：

def str = 'example of method reference'

def fun = str.&toUpperCase

def upper = fun()

assert upper == str.toUpperCase()

上面的代码将str的toUpperCase方法存入了fun中，接着调用fun等于调用了str的toUpperCase方法。

正则表达式

Pattern operator

模式操作符使用~，~后面加字符串用于创建java.util.regex.Pattern实例。

def p = ~/foo/

p = ~'foo'

p = ~"foo"

p = ~$/dollar/slashy $ string/$

p = ~"${pattern}"

assert p instanceof Pattern

Find operator

查询操作符使用=~，在字符串上调用=~会生成java.util.regex.Matcher实例。

def text = "some text to match"

def m = text =~ /match/

assert m instanceof Matcher

if (!m) {

    throw new RuntimeException("Oops, text not found!")

}

Match operator

匹配操作符使用==~表示，返回结果是Boolean类型。

m = text ==~ /match/

assert m instanceof Boolean

if (m) {

    throw new RuntimeException("Should not reach that point!")

}

其他操作符

Spread operator

展开操作符*.，用于收集列表中的一些公共属性，然后将他们合成一个新的列表：

class Car {

    String make

    String model

}

def cars = [

       new Car(make: 'Peugeot', model: '508'),

       new Car(make: 'Renault', model: 'Clio')]

def makes = cars*.make

assert makes == ['Peugeot', 'Renault']

Range operator

范围操作符使用..

def range = 0..5

assert (0..5).collect() == [0, 1, 2, 3, 4, 5]

assert (0..<5).collect() == [0, 1, 2, 3, 4]

assert (0..5) instanceof List

assert (0..5).size() == 6

Spaceship operator

比较操作符<=>，内部其实是调用了compareTo方法：

assert (1 <=> 1) == 0

assert (1 <=> 2) == -1

assert (2 <=> 1) == 1

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

Membership operator

成员关系操作符in，相当于调用isCase方法，在List中，相当于contains方法：

def list = ['Grace','Rob','Emmy']

assert ('Emmy' in list)

也可以使用list.contains('Emmy') or list.isCase('Emmy')

Identity operator

身份操作符is用于判断两个引用是否相同。相当于在java中的==,而在groovy中==相当于equals方法。

def list1 = ['Groovy 1.8','Groovy 2.0','Groovy 2.3']

def list2 = ['Groovy 1.8','Groovy 2.0','Groovy 2.3']

assert list1 == list2

assert !list1.is(list2)

Coercion operator

强制操作符as，用于不同类型的转换：

Integer x = 123

String s = x as String

如果要给自定义的类实现强制转换，需要asType方法：

class Identifiable {

    String name

}

class User {

    Long id

    String name

    def asType(Class target) {

        if (target==Identifiable) {

            return new Identifiable(name: name)

        }

        throw new ClassCastException("User cannot be coerced into $target")

    }

}

def u = new User(name: 'Xavier')

def p = u as Identifiable

assert p instanceof Identifiable

assert !(p instanceof User)

Call operator

Call操作符使用()，用来调用call这个方法，如下：

class MyCallable {

    int call(int x) {

        2*x

    }

}

def mc = new MyCallable()

assert mc.call(2) == 4

assert mc(2) == 4

操作符重载

groovy中支持操作符重载，重载操作符很简单，只要实现对应的方法即可，如+只要实现plus方法：

class Bucket {

    int size

    Bucket(int size) { this.size = size }

    Bucket plus(Bucket other) {

        return new Bucket(this.size + other.size)

    }

}

def b1 = new Bucket(4)

def b2 = new Bucket(11)

assert (b1 + b2).size == 15

结尾

关于groovy操作符的详细用法请参考：http://www.groovy-lang.org/operators.html