这一篇简单介绍一下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