Groovy字符串及其常用方法

文本文字以字符链的形式表示被称作字符串。脚本语言在字符串处理方面比主流的应用程序开发语言做的更好。Groovy就提供了许多附加的特性。在Groovy中有两种风格的字符串：String（java.lang.String）和GString（groovy.lang.GString）。GString允许有占位符而且允许在运行时对占位符进行 解析和计算。

字符串方法

与java不同，在GString中提供了多种表示字符串的方法，分别是单引号字符串、双引号字符串、三单引号字符串、三双引号字符串、斜杠字符串和$修饰的斜杠字符串。

单引号字符串

单引号字符串是一系列被单引号包围的字符，是普通的java.lang.String。不支持插值。

def str = 'groovy'
assert str.class == java.lang.String

三单引号字符串

三单引号字符串是一列被三个单引号包围的字符，是普通的java.lang.String。不支持插值。

def str = '''groovy'''
assert str.class == java.lang.String

三单引号字符串是多行的。你可以使字符串内容跨越行边界，不需要将字符串分割为一些片段，不需要连接，或换行转义符：

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

//需要注意的是，这个字符串每一次换行都包含了一个换行转义符：

assert str.contains("\n") == true
assert str.size() == 14

//可以通过使用反斜杠换行符剥离该字符

def str = '''\
one\
two\
three'''

assert str.contains("\n") == false
assert str.size() == 11

双引号字符串

双引号字符串是一列被双引号包围的字符，如果没有插值表达式，双引号字符串就是普通的java.lang.String。如果有插值存在则是groovy.lang.GString实例：
任何Groovy表达式可以在所有字符文本进行插值，除了单引号和三单引号字符串。插值是使用占位符上的字符串计算值替换占位符的操作。占位符表达式是被${}包围，或前缀为$的表达式。当GString被传递给一个带有一个String参数的方法时，占位符的表达式被计算值，并通过调用表达式的toString()方法以字符串形式表示。
这里是一个占位符引用局部变量的字符串：

def name = 'Groovy'
def greeting = "Hello ${name}"

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


//而且任何Groovy表达式是合法的，正如我们在示例中使用算数表达式所见一样:
def sum = "The sum of 2 and 3 equals ${2 + 3}"
assert sum.toString() == 'The sum of 2 and 3 equals 5'

//除了${}占位符以外，也可以使用$作为表达式前缀：
def person = [name: 'Guillaume', age: 36]
assert "$person.name is $person.age years old" == 'Guillaume is 36 years old'

//空${}占位符等于null
assert "demo${}" == "demonull"

//如果在GString中你需要转义$或${}占位符，使它们不出现插值，那么你只需要使用反斜杠字符转义美元符号：
assert '${name}' == "\${name}"

当占位符包含一个箭头时：${->}。表达式实际上是一个闭包表达式：

name = "zhangsan"
assert "${->name}" == "zhangsan"

延迟加载

嵌入的闭包表达式仅仅允许携带0或者1个参数。
闭包作为表达式比普通插值表达式有一个很有用的特性：延迟加载。

 def b = 'old'
 def value1 = "${b}"
 def value2 = "${->b}"
 assert value1 == "old"
 assert value2 == "old"

 b = "new"
 assert value1 == "old"    //使用纯插值表达式，结果在GString创建时结合
 assert value2 == "new"    //但使用闭包表达式，GString被强转为Sring时，闭包被调用，并产生包含新数值的更新字符串。

GString和String的hascode不同

虽然插值字符串可以代替普通Java字符串，字符串相同的两者还是有区别：它们的hashCode是不同的。普通Java字符串是不可变的，而一个GString依赖于插入的值，它的String是可变的。即使有相同的字符串结果，GString和String也没有相同的hashCode。

def key = "a"
def m = ["${key}": "letter ${key}"]  //map被一个初始化键值对创建，其键值是GString

assert m["a"] == null   //当我们尝试使用String键值获取值时，我们并没获取对应值，因为String和GString有不同的hashCode

三双引号字符串

三双引号字符串与双引号字符串相同，增加多行，像三单引号字符串一样。

斜杠字符串

除了通常的带引号字符串，groovy提供斜杠字符串，使用/作为分隔符。斜杠字符串对于定义正则表达式和模式是特别有用的，因为不需要转义反斜杠。只有正斜杠需要反斜杠转义。斜杠字符串支持多行，支持插值。

字符串方法

Groovy通过包含附加方法的方法扩展了JDK中的类：center、getAt、leftShift等等。

//String center(Number numberOfChar)  返回一个长度为numberOfChar，其左边和右边均使用空格的填充的新字符串。
def str = "demo"
assert str.center(6) == " demo "
assert str.center(6).size() == 6
assert str.center(5) ==  "demo "    //如果numberOfChar比字符串长度大1.那么在原字符串后添加一个空格。

//String center(Number numberOfChar，String padding)  返回一个长度为numberOfChar，其左边和右边均使用padding的填充的新字符串，与上一个一致：如果第一个参数比字符串长度大1，在元字符串后添加padding
assert str.center(5,"a") == "demoa"
assert str.center(7,"ab") == "ademoab"      //先在元字符串后添加padding的前一个字符，再在原字符串前添加padding的前一个字符。然后在新字符串后添加padding的第二个字符，以此类推。

//int compareToIgnoreCase(String str) 按字典大小比较两个字符串，忽略大小写，返回他们的顺序差值
def str = "a"
assert str.compareToIgnoreCase("a") == 0    //相同返回0
assert str.compareToIgnoreCase("A") == 0    //忽略大小写
assert str.compareToIgnoreCase("c") == -2   //返回差值

//Boolean equalsIgnoreCase(String str) 判断两个字符串是否相等，忽略大小写

//String getAt(int index)   字符串的下标运算符
assert "abcdefg".getAt(2) == "c"
assert "abcdefg"[2] == "c"
assert "abcdefg".getAt(1..2) == "bc"    //String getAt(Range range)
assert "abcdefg"[1..2] == "bc"

//Int indexOf(String str) 返回给定子字符串在当前字符串中首次出现的索引值
assert "abcdefg".indexOf("b") == 1
assert "abcd".indexOf("g") == -1    //如果原字符串中不存在给定子字符串就返回-1

//StringBuffer leftShift(Object value)  重载<< 使两个字符串相加，返回一个新的字符串
assert "ab".leftShift("cd").class ==  java.lang.StringBuffer
assert "ab".leftShift("cd").toString() == "abcd"

//int length() / int size()   返回字符串的长度
assert "abcd".length() == 4
assert "abcd".size() == 4

//String concat(String str) 在字符串后添加str字符串
assert "ab".concat("12") == "ab12"

//Boolean endsWith(String suffix) 测试字符串是否以给定的后缀结尾
assert "demo1".endsWith("1") == true

//String minus(Object value) 删除字符串中value部分
assert "abcd".minus("bc") == "ad"

//String next()  按字典顺序增加给定字符串末尾字符顺序
assert "abcd".next() == "abce"
assert "abc1".next() == "abc2"

//String previous() 按字典顺序增加给定字符串末尾字符顺序
assert "abcd".previous() == "abcc"
assert "abc1".previous() == "abc0"


//String padLeft(Number numberOfCharacters) 与center()用法类似，在元字符串左边填充空格字符
assert "abcd".padLeft(5) == " abcd" 
//String padLeft(Number numberOfCharacters，String padding) 与center()用法类似，在元字符串左边填充padding字符
assert "abcd".padLeft(5,"12") == "1abcd"
//String padRight(Number numberOfCharacters) 与padLeft()用法类似，在元字符串左边填充空格字符
assert "abcd".padRight(5) == "abcd " 
//String padRight(Number numberOfCharacters，String padding) 与padLeft()用法类似，在元字符串左边填充padding字符
assert "abcd".padRight(5,"12") == "abcd1"

//String plus(Object valus) 字符串相加
assert "abcd".plus("123") == "abcd123"

//String reverse() 创建当前字符串的逆序字符串
assert "abcd".reverse() == "dcba"

//String substring(int beginIndex) 返回一个当前字符串的指定索引开始的子字符串
assert "abcd".substring(1) == "bcd"
//String substring(int beginIndex,int endIndex) 返回一个当前字符串的指定索引开始的子字符串
assert "abcd".substring(1,2) == "bc"
//Character toCharacter()
//Double toDouble()
//Float toFloat()
//Integer toInteger()
//Long toLong() 字符串类型转换
//List toList() 将指定的字符串转换成一个由单个字符组成的字符串列表
assert "abcd".toList() == ["a","b","c","d"]

//String toUpperCase() 将当前字符串对象的所有字符转换为大写
assert "abcd".toUpperCase() == "ABCD"
//String toLowerCase() 将当前字符串对象的所有字符转换为小写 
assert "ABCD".toUpperCase() == "abcd"
//List tokenize()  使用空格作为字符串的分隔符
//List tokenize(String token) 使用指定的token参数作为字符串的分隔符
//String[] split(String regex) 使用与给定的正则表达式相匹配的子字符串将字符串分隔为多个字符串
// Boolean matches(String regex) 测试字符串是否匹配给定子字符串

tokenize() vs split()

1.split()返回string[]， tokenize()返回list
2.tokenize()忽略空字符串

String testString = 'hello brother'
assert testString.split() instanceof String[]
assert ['hello','brother']==testString.split() //split with no arguments
assert['he','','o brother']==testString.split('l')

assert testString.tokenize() instanceof List
assert ['hello','brother']==testString.tokenize() //tokenize with no arguments
assert ['he','o brother']==testString.tokenize('l')

3.tokenize()使用字符串内的所有字符

String  testString1='hello world'
assert ['hel',' world']==testString1.split('lo')
assert ['he',' w','r','d']==testString1.tokenize('lo')

4.split()可以使用正则表达式

String testString2='hello world 123 herload'
assert['hello world ',' herload']==testString2.split(/\d{3}/)

matches()

对正则表达式感兴趣的读者可以看一下这篇文章正则表达式30分钟入门教程。

正则表达式的简单规则

\b :单词的开始或者结尾
\w :匹配字母或者数字或者下划线或汉字
\d :匹配数字
{n}:表示匹配前一个规则，重复n次
. :匹配除了换行符以外的任意字符
* :*前边的内容可以连续重复使用任意次以使整个表达式得到匹配
+ :与*相似，匹配一次或更多次数。
\s :匹配任意的空白符
^ :匹配字符串的开始
$:匹配字符串的结束 ^和$的意义就变成了匹配行的开始处和结束处。

assert 'hi'.matches('hi')
assert '111'.matches('\\d{3}')       //'\d':表示匹配一位数字
assert '11as11'.matches('\\d{2}.*\\d{2}')