一、字符串类型变量

在双引号字符串中 , 使用 ${变量名} 进行字符串拼接 ,

• ${变量名} 符号的取值 , 是在 定义时取值 ;

        def s1 = "Hello"
        def s3 = "${s1} World!!!"
        s1 = "Hello Groovy" // 修改被拼接的函数值
        // 打印的值为 "Hello World!!!"
        println s3

  

 

  
1
  
2
  
3
  
4
  
5
 

• ${->变量名} 符号的取值 , 是在 访问时取值 , 不是在定义时取值 , 如果访问前 , 修改了 变量名 对应的变量值 , 则最后取值是修改后的值 ; 这是闭包的规则 ;

        def s1 = "Hello"
        def s4 = "${->s1} World!!!"
        s1 = "Hello Groovy" // 修改被拼接的函数值
        // 打印的值为 "Hello Groovy World!!!"
        println s4

  

 

  
1
  
2
  
3
  
4
  
5
 

在 单引号 中 , 不能进行字符串连接操作 ;

        // 单引号中不能进行字符串拼接
        def s5 = '${s1} World!!!'
        // 打印的值为 "${s1} World!!!"
        println s5

  

 

  
1
  
2
  
3
  
4
 

字符串拼接代码示例 :

        // 字符串
        def s1 = "Hello"

        // 字符串拼接

        // 注意 , 双引号中才能进行字符串拼接 , 单引号中不行
        // ${变量名} 符号的取值 , 是在 定义时取值 ;
        def s3 = "${s1} World!!!"

        // ${->变量名} 符号的取值 , 是在 访问时取值 , 不是在定义时取值 ,
        // 如果访问前 , 修改了 变量名 对应的变量值 , 则最后取值是修改后的值 ;
        // 这是闭包的规则 ;
        def s4 = "${->s1} World!!!"

        // 修改被拼接的函数值
        s1 = "Hello Groovy"

        // 分别打印 s3 字符串内容和类型 , 修改被拼接的函数值没有影响到最终字符串值
        println s3
        println s3.class

        // 分别打印 s4 字符串内容和类型
        // 修改被拼接的函数值 影响到了 最终字符串值
        println s4
        println s4.class

        // 单引号中不能进行字符串拼接
        def s5 = '${s1} World!!!'
        // 分别打印 s4 字符串内容和类型
        println s5
        println s5.class

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
 

执行结果 :

Hello World!!!
class org.codehaus.groovy.runtime.GStringImpl
Hello Groovy World!!!
class org.codehaus.groovy.runtime.GStringImpl
${s1} World!!!
class java.lang.String

  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

二、多行字符串

在 普通字符串中 , 使用 \n 符号 , 代表换行操作 ,

def m1 = "Hello\nWorld"

  

 

  
1
 

代表

Hello
World

  

 

  
1
  
2
 

字符串 ;

在 $6$ 个双引号之间 , 可以直接写多行文本 , 多行文本的 左右两侧各有 $3$ 个双引号 ;

        def m2 = """Hello
World"""

  

 

  
1
  
2
 

代表

Hello
World

  

 

  
1
  
2
 

字符串 ;

代码示例 :

        // 多行字符串输出
        def m1 = "Hello\nWorld"
        def m2 = """Hello
World"""
        // 打印多行字符串
        println m1
        println m2

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
 

执行结果 :

Hello
World
Hello
World

  

 

  
1
  
2
  
3
  
4
 

三、完整代码示例

完整代码示例 :

class Test {
    static void main(args) {

        // 字符串
        def s1 = "Hello"

        // 字符串拼接

        // 注意 , 双引号中才能进行字符串拼接 , 单引号中不行
        // ${变量名} 符号的取值 , 是在 定义时取值 ;
        def s3 = "${s1} World!!!"

        // ${->变量名} 符号的取值 , 是在 访问时取值 , 不是在定义时取值 ,
        // 如果访问前 , 修改了 变量名 对应的变量值 , 则最后取值是修改后的值 ;
        // 这是闭包的规则 ;
        def s4 = "${->s1} World!!!"

        // 修改被拼接的函数值
        s1 = "Hello Groovy"

        // 分别打印 s3 字符串内容和类型 , 修改被拼接的函数值没有影响到最终字符串值
        println s3
        println s3.class

        // 分别打印 s4 字符串内容和类型
        // 修改被拼接的函数值 影响到了 最终字符串值
        println s4
        println s4.class

        // 单引号中不能进行字符串拼接
        def s5 = '${s1} World!!!'
        // 分别打印 s4 字符串内容和类型
        println s5
        println s5.class

        // 多行字符串输出
        def m1 = "Hello\nWorld"
        def m2 = """Hello
World"""
        // 打印多行字符串
        println m1
        println m2
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
 

执行结果 :

Hello World!!!
class org.codehaus.groovy.runtime.GStringImpl
Hello Groovy World!!!
class org.codehaus.groovy.runtime.GStringImpl
${s1} World!!!
class java.lang.String
Hello
World
Hello
World

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
 

文章来源: hanshuliang.blog.csdn.net，作者：韩曙亮，版权归原作者所有，如需转载，请联系作者。

原文链接：hanshuliang.blog.csdn.net/article/details/122037285