Groovy 字符串

官方文档：http://www.groovy-lang.org/syntax.html

Groovy有java.lang.String和groovy.lang.GString两种字符串对象类型，具体如下

单引号字符串

单引号字符串是java.lang.String类型的，不支持占位符插值操作

def name = 'Groovy!'
def body = 'test $name'println(body); //test $name,不是 test Groovy!

Groovy的字符串可以通过 "+" 直接拼接

assert 'groovy' == 'g' + 'roo' + 'vy';
println('ab\'' + 'f');  // ab'f

转义字符规则同Java一样

三重单引号字符串

三重单引号字符串也是java.lang.String类型的，不支持占位符插值操作，可以表示多行字符串

def str = '''line one
line two
line three'''

如果在换行之前加个，则相当于没有换行

def str = '''\
line one aaa \n kkkk
line tow 2\
line three'''
println(str);

运行结果：

line one aaa kkkk
line tow 2line three

双引号字符串

双引号字符串支持占位插值操作，如果双引号字符串中不包含占位符则是java.lang.String类型的，如果包含则是groovy.lang.GString类型的。

占位符可以用${}或$来表示，${}用于替换一般字符串或表达式，$主要用于A.B的形式中

// ${}
def str1 = 'Groovy!'
def str2 = "hello ${str1}"
println(str2);  // hello Groovy!def str3 = "the sum of 2 and 3 is ${2 + 3}"
println(str3);  // the sum of 2 and 3 is 5// $
def str4 = "hello $str1"
println(str4);  // hello Groovy!def map = ['name':'Tom', 'age':null, 'gender':null]
println("$map.name is $map.age years old, gender $map.gender"); // Tom is null years old, gender null

$ 只对a.b或a.b.c形式有效，如果表达式包含括号类似于方法调用、闭包的大括号或算术运算符是无效的。

def str = "wzx"
println("my name length is ${str.length()}");  //my name length is 3println("my name length is $str.length()");
//该代码运行抛出groovy.lang.MissingPropertyException异常，因为Groovy认为去访问num的toString的属性，所以异常def closure = {"sum " + it};
def str1 = "2 + 3 = ${closure(5)}"
def str2 = "2 + 3 = $closure(5)"
println(str1);  // 2 + 3 = sum 5
println(str2);  // 2 + 3 = (5) 错误

注意，在表达式中访问属性前必须保证属性已经定义好(值为空也可以)，如果使用了未定义的属性会抛出groovy.lang.MissingPropertyException异常

如果需要表示$ or ${}字符串，可以使用反斜杠\

assert '${name}' == '\${name}'

插值闭包表达式的特殊情况

到目前为止，我们已经可以在${}占位符插值任意表达式。但是对于闭包有一个特殊情况和符号，占位符包含一个箭头${→}时,表达式实际上是一个闭包表达式,可以认为它是一个闭包前缀了一个美元符号:

//无参闭包
def strWithNoParmClosure = "2 + 3 = ${ -> 5}"  // 2 + 3 = 5
//带有一个 java.io.StringWriter 参数的闭包，可通过 << 操作符将内容传给参数
def strWithParmClosure = "1 + 2 != ${parm -> parm << 'six'}"  // 1 + 2 != six

以上两种都是占位符插值闭包的情况，看起来比单纯的表达式定义麻烦，但是闭包有一个特性：延迟运算(lazy evaluation)

def number = 1;
def eargeGString = "value = ${number}"
def lazyGString = "value = ${ -> number}"assert eargeGString == "value = 1"
assert lazyGString == "value = 1"number = 2;
assert eargeGString == "value = 1"
assert lazyGString == "value = 2"

对于普通插值表达式(eargeGString)，其值实际在表达式创建时就被绑定了，如：

def num1 = 9, num2 = 11;
def fun(int p1, int p2){p1 + p2
}
def strWithParmClosure = "xxx ${fun(num1, num2)}";println(strWithParmClosure);  // xxx 20num2 = 20;
println(strWithParmClosure);  //xxx 20

但是对于有闭包的表达式，在每次GString转成String时闭包都会被调用。

插值闭包表达式中的闭包只允许有0或1个参数，否则运行时会抛异常

groovy> def strWithParmClosure = "2 + 3 != ${parm, parm2 -> (parm << 2) + (parm2 << 3)}";
groovy> println(strWithParmClosure); 

运行时异常：

groovy.lang.GroovyRuntimeException: Trying to evaluate a GString containing a Closure taking 2 parameters

GString & String hashCodes

String是不可变的，GString的String表示会根据插值变化，即使String和GString有相同的字符串，其hashCode也不同

assert "one: ${1}".hashCode() != "one: 1".hashCode()

所以应该避免使用GString作为Map key，例如：

def key = "a"
def m = ["${key}": "letter ${key}"] assert m["a"] == null   //由于key的HashCode不同，所以取不到

三重双引号字符串

三重双引号字符串表现得像双引号字符串，另外它们是多行的

def name = 'Groovy'
def template = """Dear Mr ${name},\You're "the winner" of 'the lottery'!Yours sincerly,\Dave\"AAABBBB\\"
"""assert template.contains("Groovy")
println(template);

运行结果：

...第一行为空行Dear Mr Groovy,    You're "the winner" of 'the lottery'!Yours sincerly,    Dave"AAABBBB\"

斜线字符串

使用/作为分隔符，Slashy字符串对于定义正则表达式和模式特别有用，因为没有必要转义反斜杠。

前斜线与单引号：

def fooPattern = /.*foo.*/
assert fooPattern == '.*foo.*'

若在斜线字符串中要使用前斜线，需要用反斜线转义

def escapeSlash = /The character \/ is a forward \t slash  //用反斜线转义前斜线，而反斜线可直接写入，适用于正则式assert escapeSlash == 'The character / is a forward \\t slash'  //单引号等其他字符串前斜线不需要转义

可表示多行字符串

def multilineSlashy = /one\twothree/assert multilineSlashy.contains('\n')
println(multilineSlashy)

运行结果：

one    twothree

支持插入占位符

def color = "blue"
def interpolatedSlashy = /a ${color} car/assert interpolatedSlashy == /a blue car/
println(interpolatedSlashy)

需要注意的问题：

一个空的slashy字符串不能用双斜杠表示，因为它被Groovy解析器理解为一行注释，下面的断言实际上不会被编译，因为它被认为是一个未结束语句:

def color = ''
assert color == //

由于slashy字符串的设计主要是为了使regexp更容易，因此在GStrings中有一些错误，比如$()，在slashy字符串中可以使用

def slashy = /a $() car/
assert slashy == "a \$() car"  // GString中$需要转义

String比较