groovy 字符串 数字 list map

字符串：

def str1 = 'hello'

def str2 = "$str1 world"? //双引号中可以有表达式运算，输出hello world

def str3 = /drnab/? //str3 =='drnab'

def str4 = """

hello

world

hello

grails

"""? //输出"nhellonworldnhellongrailsn"

str1*2 == "hellohello"

str2-str1 == ' world'

str2[0..3]=='ell'

str2[-3..-1] == 'rld'

str1.toList() ==["h","e","l","o"]

str1.reverse() == "olleh"

str2.size == 20

数字：

def x = 3

def y =4

x+y == 7

x.plus(y) == 7

x instanceof Integer

def a = 2/3? //结果0.6666666667

a instanceof BigDecimal

a = 2.intdiv(3)

a instanceof Integer

def b =? a.setScale(3,BigDecimal.ROUND_HALF_UP)

b == 0.667

类：

class A{

String p1

String p2

}

def a = new A(p1:"XX",p2:"yy")

a.p1 == "XX"

a.p2 == "yy"

class A {

?String p1

}

class A {

private String p1

public String getP1(){p1}

public void setP1(String p1)( this.p1 = p1)

}

以上两个类完全等价。

并且groovy中，a.p1 == a.getP1()

a.p1 == "YY" a.setP1("YY")

a+b 实际上是调用了a的plus方法。

如果要求一个类可以相加，在类中添加此方法即可。

List

def list1 = [1,2,3]

list1 *2 == [1,3,1,3]

list1.unique() ==[1,3]

list1 = [1,3]

list1.unique() == (list1 as Set) as List

list1.size() == 6

list1.reverse() == [3,1]

[1,4] + [5] == [1,4,5]

[1,4] << [5] == [1,5]

[1,4] + 5 == [1,1] - [1] == [2,4]

[1,1] - 1 == [2,4]

[1,[4,5]].flatten() == [1,5]? //展开List中的List

[1,4].max() == 4

[1,4].min() == 1

[1,1].count(1) == 2

[1,4].sum() == 10

[1,4].sort() == [1,4].disjoint([...])? //一个List与另一个List是否存在交集，return boolean

[1,4].intersect([...])? //求一个List与另一个List的交集

List*.unique()? //对List中的每个元素都执行后面的方法

(1..9).each({ ?}) ?//遍历里面的所有元素

findAll({ it>4 }) ?//返回真的元素组成一个新的List

collect({ it*it }) ?//返回值构造成新的列表

any({ it*it == it+6 }) ?//用于判断集合是否有符合条件的元素。至少存在一个元素符合条件时，返回真，否则假

every({ it*it == it+6 })??//用于判断集合是否有符合条件的元素。当集合所有元素都符合条件时，返回真，否则假

Map：

def map =[key1:"vlaue1"]

map == ["key1":"value1"]

map.key1 == "value1"

map["key1"] == "value1"

map.keySet() == ["key1"]

def key = "key123"

def map1 = [key:"value"]

map1.key == 'value'

map1[key] == null

def map2 = [(key):"value"]

map2 == ["key123":"value"]

map1["newKey"] = "newValue"

map1 == ["key":"value","newKey":"newValue"]

map1.remove("key")

map1.key == null

[key1:"value1",key2:"value2"].each({ entry -> println "$entry.key $entry.value" }) ?//对Map的遍历

区间:

def range1 == 1..5

def range2 == 1..<5

range1.contains(5)

!range2.contains(5)

range1.size() == 5

range2.size() == 4

def today == new Date()

def yesterday = today - 1

(yesterday..today).size() == 2

('a'..'c').contains('b')

'b' in ('a'..'c')

//区间用于循环

def log = ' '

for (i in 1..5){

? log+=i

}

log == '12345'

//区间用于switch

def score = 36

switch(score){

case 0..60:

? ? println '不及格'

? ? break //注：break要换行写

case 60..<70:

? ? println '及格'

? ? break

case 70..<85:

? ? println '良好'

? ? break?

case 85..<100:

? ? println '优秀'

? ? break?

case 100:

? ? println '完美'

? ? break?

default:throw new IllegalArgumentException()

}

输出：不及格

[*range1] == [1,5]//前置*可将区间展开，用于构造List

闭包：

def c1 = {println it}//当没有->时，可用it的变量访问参数

def c2 = {text ->println text}

c1.call("XX") ?//用call方法调用闭包

c2("content2") ?//直接调用闭包

动态添加方法：

1、类名.metaClass.方法名 = 闭包

2、类名.metaClass.方法名 << 闭包

如果新加入的方法名与参数都和旧的完全一样，使用"="会覆盖旧的方法，使用“<<”会报错。

如果添加的方法带参数，闭包中要添加“输入参数”。

Foo.metaClass.speak = { def num -> ?//无指定类型的参数

}

Foo.metaClass.speak = { int num -> ?//强制类型的参数，如果传入的参数类型不对，会报错

}

Foo.metaClass.speak = { -> ?//强制无参数，如果传入参数，会报错

}

补充domain中的方法：beforeUpdate/Insert/Delete