Groovy学习

代码：

结果如下：

说明类或方法内他们指代相同

当出现闭包内写闭包时 this 与 owner 不同

结果：

delegate 对象发生变换时他与owner 不同，默认他是指向owner 的

 结果：

 改变闭包指向设置delegate优先级

 结果：

创建数组：

//数组定义方式
def list = [1,2,3,4,5]
println list.class
println list.size()
//定义数组
def list2 = [1,2,3,5-2,5] as int[]

Groovy的数组添加操作：

//1,添加
list.add(2)
list << -5

println list

def plusList = list + 3
plusList.add(3,28)
println plusList

Groovy的数组添加删除操作：

list.remove(2)//删除下标位置
list.remove((Object) -5)
list.removeElement(2)
println list

list.removeAll({
    it % 2 != 0
})

println list

println list - [2,3]

Groovy的数组添加查找操作：

def findList = [1,-2,3,4,5]
findList.find {
    it % 2 == 0
}

//查找满足条件的第一个
int result = findList.find {
    it % 2 == 0
}
println result

//查找满足条件的数组
int [] result2 = findList.findAll{
    it % 2 == 0
}
println result2

//查找是否存在满足条件的元素
def result3 = findList.any {
    it % 2 == 0
}
println result3

//判断是否全部满足条件
def result4 = findList.every{
    it % 2 == 0
}
println result4

//查找最大值与最小值
def result5 = findList.min {
    return Math.abs(it)
}
println result5

//查找最大值最大的一个

def  result6 = findList.max {
    return Math.abs(it)
}
println result6
//统计功能
def  result7 = findList.count {
    return it > 0
}
println result7

Groovy的数组排序操作：

def sortList = [1,-2,3,-4,5]
def s = sortList.sort()
println s
//数组排序规则
def s1 = sortList.sort {a,b ->
    a == b ? 0 : Math.abs(a) > Math.abs(b) ? 1 : -1
}
println s1
//对象排序规则

def sortStringList = ["aa","b","cccc","ddd","e"]
def s2 = sortStringList.sort {
    it.size()
}
println s2

Map相关代码：

//定义和读取
def colors = [red:'ff0000',green:'00ff00',blue:'0000ff'] as HashMap
println colors['red']
println colors.red

//如果用colors.class 会把class 当成键
println colors.getClass()

//添加普通对象
colors.yellow = 'ffff00'
println colors

//添加集合对象
colors.map = [key1:1,key2:2]
println colors.toMapString()

//遍历
def teacher = [
        1:[number:'001',name:'juck'],
        4:[number:'004',name:'mack'],
        2:[number:'002',name:'lite'],
        3:[number:'003',name:'jid'],
        5:[number:'005',name:'ds'],
        7:[number:'007',name:'jid'],
        8:[number:'008',name:'bk'],
        6:[number:'006',name:'jat'],
]

//键值对方式
teacher.each {
    def key ,def value ->
        println "key = ${key}  ----value = ${value}"
}

//Entry 方式
teacher.each {
    def t ->
        println "key = ${t.key}  ----value = ${t.value}"
}

//带索引的方式
teacher.eachWithIndex {
    def t ,def index ->
        println "index = ${index} ----key = ${t.key}  ----value = ${t.value}"
}

//map的查找

//查找第一条
def entry = teacher.find {
    def t ->
        return  t.value.name == 'bk'
}
println entry

//查找所有满足条件的数据
def entrys = teacher.findAll {
    def t ->
        return t.value.name == 'jid'
}

println entrys

//统计复合条件的个数
def count = teacher.count {
    def t ->
        return t.value.name =='jid'
}
println count

//嵌套查询实现
def number = teacher.findAll {
    def t ->
    return t.value.name == 'jid'
}.collect {
    def t ->
        return t.value.number
}
println number.toListString()

// 分组查询
def group = teacher.groupBy {
    def t ->
    return t.value.name == 'jid' ? 'group1':'group2'
}
println group.toMapString()

//排序 注意：map会返回一个新的map list 是在原来的list 中进行排序的
def sort  = teacher.sort{
    def t1,def t2->
        return t1.key > t2.key ?  1:-1
}
println sort.toMapString()