文本是由一连串的字符也就是字符串组成，Groovy让你实例化java.lang.String实体，和其他编程语言中的内插字符串GStrings (groovy.lang.GString)一样。

单引号字符串

单引号字符串是一系列被单引号包含的字符。

'a single quoted string'

注意：单引号字符串是简单的java.lang.String类型不支持内插

字符串连接

所有的Groovy 字符串都可以用+操作符进行连接。

assert 'ab' == 'a' + 'b'

三单引号字符串

三单引号字符串是一系列被三个单引号包含的字符。

'''a triple single quoted string'''

注意:三单引号字符串是简单的java.lang.String类型不支持内插

三单引号字符串是多行的字符串，你可以把字符串内容展开成跨行而不需要分出几部分，而且不需要连接符+和转义字符。

def aMultilineString = '''line one

line two

line three'''

如果你的代码有空格，比如在一个类的方法中，你的字符串可能包含有空白缩进。Groovy 的开发包中有方法String#stripIndent()可以去除这个空白缩进。并且提供了String#stripMargin()方法可以删除字符串开始位置指定的分隔符。

当我们创建如下字符串时：

def startingAndEndingWithANewline = '''

line one

line two

line three

'''

我们会发现字符串开头会包含\n字符，可以通过反斜号来转义开头的换行符：

def strippedFirstNewline = '''\

line one

line two

line three

'''

assert !strippedFirstNewline.startsWith('\n')

转义特殊字符

你可以使用反斜号\来转义单引号，避免完整的字符串被分割开了

'an escaped single quote: \' needs a backslash'

而且你可以使用双斜号\\来转义转义字符\：

'an escaped escape character: \\ needs a double backslash'

一些特殊的字符也是用反斜号作为转义字符

特殊字符转义

Unicode码转义序列

对于在键盘中未出现的字符即中文，你可以使用unicode 转义序列：反斜号跟上u还有四个十六进制数字。

例如，欧洲货币符号可以如下展示：

'The Euro currency symbol: \u20AC'

双引号字符串

双引号字符串是被双引号包含的一系列字符。

"a double quoted string"

注意：当双引号字符串中没有插值表达式时，字符串的类型为java.lang.String，当双引号字符串中包含插值表达式时，字符串类型为groovy.lang.GString。

想要转义双引号的话你可以使用反斜号\："A double quote: ""

字符串插值(String interpolation)

除了单引号和三单引号字符串，所有的字符串都可以插入Groovy 表达式。插值实际就是替换字符串中的占位符，占位表达式是由${}包含起来或者是由$开头的.表达式，当GString 被传给一个带有String参数的方法 时，通过调用toString()方法，可以把占位符里面的表达式解析为真正的值。

这里我们就有引用了局部变量带有占位符的字符串

def name = 'Guillaume' // a plain string

def greeting = "Hello ${name}"

assert greeting.toString() == 'Hello Guillaume'

正如我们看到的，在这个带有算术表达式的例子中，这些Groovy 表达式都是正确的

def sum = "The sum of 2 and 3 equals ${2 + 3}"

assert sum.toString() == 'The sum of 2 and 3 equals 5'

注意:并不仅仅只有表达式可以放在${}占位符中，声明也是可以放在之中的，但是一个声明的值会是null，所以当有几个声明都被放在占位符中的话，最后一个声明必须返回一个有意义的值。例如："The sum of 1 and 2 is equal to ${def a = 1; def b = 2; a + b}"是支持的，但是一个最佳实践是，在GString 占位符中通常是放一些简单的表达式。

除了${}占位符，我们也可以使用单独的$加上.表达式：

def person = [name: 'Guillaume', age: 36]

assert "$person.name is $person.age years old" == 'Guillaume is 36 years old'

但是只有这种格式例如a.b,a.b.c是对的，但是表达式包含圆括号像方法调用那样，还有大括号，或者算术操作也会是正确的，例如下面数字的定义：

def number = 3.14

下面的声明会抛出错误groovy.lang.MissingPropertyException，因为Groovy 认为，你将尝试调用这个数字的toString方法，但是是不存在的。

shouldFail(MissingPropertyException) {

println "$number.toString()"

}

注意:你可以考虑将"$number.toString()"替换为"${number.toString}()"就可以被正常运行了

如果你想转义$和${}占位符，你只要用反斜号\来转义$即可：

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

特殊的插值闭包表达式

到目前为止，我们知道我们可以在${}占位符中插入任意的表达式，而且包含一种特殊的闭包表达式.当占位符带有箭头如：${→}, 那么这个表达式就是一个闭包表达式。你可以认为有一个$符号在大括号前面。

1.

def sParameterLessClosure = "1 + 2 == ${-> 3}"

assert sParameterLessClosure == '1 + 2 == 3'

2.

def sOneParamClosure = "1 + 2 == ${ w -> w << 3}"

assert sOneParamClosure == '1 + 2 == 3'

1.第一个例子是一个没有带参数的闭包

2.第二个例子是带了一个java.io.StringWriter类型参数的闭包，你可以用<

从表面上看，这似乎是一个冗长的定义插入表达式的方式，但是它有一个非常有趣的特性：延迟解析。

让我们看看下面这些例子：

1.

def number = 1

def eagerGString = "value == ${number}"

def lazyGString = "value == ${ -> number }"

2.

assert eagerGString == "value == 1"

3.

assert lazyGString == "value == 1"

4.

number = 2

5.

assert eagerGString == "value == 1"

6.

assert lazyGString == "value == 2"

1.我们定义了一个number变量1，然后将它插入GStrings中间，就像一个放在eagerGString中的表达式和一个放在lazyGString中间的闭包。

2.我们希望最终的字符串拥有跟eagerGString一样的字符串值1.

3.跟2一样

4.然后我们将数字number变为2

5.普通的插值表达式，在GString一创建的时候值就被确定了。

6.但是对于闭包表达式就不同了，每次number值变化，在它从GString 强转为String的时候，闭包表达式都会被调用，所以lazyGString 最终得到的值会发生变化。

注意:一个内嵌的闭包表达式不能包含多于一个参数，不然会报错。

跟java的协作

当一个方法(不管使用Groovy或者java实现)希望接收java.lang.String，但是我们传过去的却是groovy.lang.GString，那么toString()方法会自动且隐式地被调用。

String takeString(String message) {

assert message instanceof String 4

return message 5

}

def message = "The message is ${'hello'}" 1

assert message instanceof GString 2

def result = takeString(message) 3

assert result instanceof String

assert result == 'The message is hello'

1.创建一个GString 类型的变量

2.检查他是否是一个GString类型

3.将一个带有一个String类型参数的方法赋值给GString 类型的变量

4.takeString() 方法的签名说明了他的参数是String类型

5.我们能很明确分辨出参数是String 类型而不是GString 类型

GString and String hashCodes

虽然内插字符串可以替代普通的java字符串，但是在某些方面还是不同的：他们的哈希值不同。普通的java字符串是不可变的，但是由于内插值，GString字符串是可以改变的。设置对于相同的结果串，GString和普通字符串的哈希值都是不同的。

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

GString和普通字符串拥有不同的哈希值，用GString 作为map的key是不允许的。

def key = "a"

def m = ["${key}": "letter ${key}"] 1

assert m["a"] == null 2

1.这个map是用GString作为key来创建的

2.当我们打算用字符串取回map中的值的话，是查找不到的，因为普通字符串和GString字符串拥有不同的哈希值。

三双引号字符串

三双引号字符串和双引号字符串是类似的，只是三双引号字符串是支持多行的，和三单引号字符串是一样的。

def name = 'Groovy'

def template = """

Dear Mr ${name},

You're the winner of the lottery!

Yours sincerly,

Dave

"""

assert template.toString().contains('Groovy')

注意:双引号和单引号在三双引号字符串中都不需要转义字符。

Slashy (/)字符串

除了通常的引号字符串，Groovy还提供了Slashy 字符串，Slashy 字符串是以/作为分割符的。Slashy 字符串在定义常规表达式和模式的时候非常有用，因为他不需要转义字符。

def fooPattern = /.*foo.*/

assert fooPattern == '.*foo.*'

只有/是需要转义字符\来转义的：

def escapeSlash = /The character \/ is a forward slash/

assert escapeSlash == 'The character / is a forward slash'

Slashy字符串是可以多行的：

def multilineSlashy = /one

two

three/

assert multilineSlashy.contains('\n')

Slashy 字符串也是支持内插的：

def color = 'blue'

def interpolatedSlashy = /a ${color} car/

assert interpolatedSlashy == 'a blue car'

有一些小陷阱需要注意：

空的slashy字符串是不能用//来表示的，因为他会被理解为注释。这就是为什么下面的assert语句不会编译通过，因为这被理解为一个没有结束的语句。

assert '' == //

注意：slashy 字符串是设计来简化正则表达式的，GStrings 能跟它基本上一起使用，比如$()就可以放在slashy 字符串中。

Dollar slashy($/)字符串

Dollar slashy字符串是以$/开头/$结尾的多行GStrings字符串。这里的转义字符是$，它可以转义另外的$或者/,但是$和/都不需要转义,除非在Dollar slashy字符串中的子串里需要放置GString占位序列，或者包含了闭合的 dollar slashy字符串，才需要用$进行转义。

def name = "Guillaume"

def date = "April, 1st"

def dollarSlashy = $/

Hello $name,

today we're ${date}.

$ dollar sign

$$ escaped dollar sign

\ backslash

/ forward slash

$/ escaped forward slash

$$$/ escaped opening dollar slashy

$/$$ escaped closing dollar slashy

/$

assert [

'Guillaume',

'April, 1st',

'$ dollar sign',

'$ escaped dollar sign',

'\\ backslash',

'/ forward slash',

'/ escaped forward slash',

'$/ escaped opening dollar slashy',

'/$ escaped closing dollar slashy'

].every { dollarSlashy.contains(it) }

字符串总结表

总结表

字符

和java不同，Groovy 没有非常明确的字符类型，但是你能将Groovy中的字符串明确地转为字符，有三种不同的方式：

char c1 = 'A' 1

assert c1 instanceof Character

def c2 = 'B' as char 2

assert c2 instanceof Character

def c3 = (char)'C' 3

assert c3 instanceof Character

1.明确指定声明的字符为char类型

2.用as操作符强转

3.转化为char类型

注意：第一个选择是很有趣的，一个字符被一个变量持有，但是后面两种更有趣，一个字符被作为参数传给了一个方法调用。