Groovy之数据结构

def listMake = [1, 2, 3, 4]
/**
 * list 添加元素
 */
//listMake.add(10)
//listMake.leftShift(9)
listMake << 8
println listMake

/**
 * list 删除元素
 */
//listMake.remove(0)
//listMake.removeAt(1)
//listMake.removeElement(2)
 
//自定义闭包方式移除集合中所有的奇数
listMake.removeAll { return (it & 1) == 1 }
//减去当前集合中存在的元素，有就移除，没有不移除
println listMake - [2, 4]

*
列表查找
 */
def findList = [2, 4, 3, 5, 7, -100]
//查找第一个满足是奇数条件的数
int result = findList.find { return (it & 1) == 1 }
println result
def resultLsit = findList.findAll { return (it & 1) == 0 }
println resultLsit.toListString()
 
def anyResult = findList.any { return (it & 1) == 1 }
println anyResult
def everyResult = findList.every { return (it & 1) == 1 }
println everyResult
println findList.min()
//获取绝对值的最大值
println findList.max { Math.abs(it) }

/**
 * 列表排序
 */
def sortList = [-4, -10, 23, 4, 11, 9]
//自定义排序方式，按照绝对值进行排序
Comparator mc = { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 }
//Collections.sort(sortList,mc)
//sortList.sort()
//按照绝对值从大到小进行排序
sortList.sort { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? 1 : -1 }
println sortList

def array = [2, 3, 4, 5] as int[]//将列表转换成数组形式
int[] array2 = [1, 2, 3, 4]
 
println findList.min()
//获取绝对值的最大值
println findList.max { Math.abs(it) }
 
//统计个数
def count = findList.count { return (it & 1) == 1 }
println count

def color = ["red"  : "ff0000",
             "green": "00ff00",
             "black": "000000"]
 
//索引方式
println color['red']
println color.green
//添加元素，查找元素，没有则添加
color.yello = "fff000"
//添加新的map
color.complex = [a: 1, b: 2]
//添加一个元素
color.leftShift("ss": "222")
println color.toMapString()
//只能通过getClass 来获取类型，否则color.class 就是查找当前中是否有key为class内容，没有则返回null
println color.getClass()

def student = [
        1: [number: 001, score: 45, age: 23, name: "ztz"],
        2: [number: 002, score: 56, age: 25, name: "yif"],
        3: [number: 003, score: 67, age: 26, name: "fxy"],
        4: [number: 004, score: 78, age: 28, name: "cxm"],
]
 
//遍历
student.each { def stu ->
    println "the key is ${stu.key},and the value is ${stu.value}"
}
 
/**
 * 索引遍历 注意：student与index不能颠倒顺序，否则输出报错，因为会首先迭代获取当前map中内容
 */
student.eachWithIndex { def stu, int index ->
    println "the index is ${index}," + "the key is ${stu.value}" + " the value is ${stu.value}"
}
 
//直接遍历 key与value
student.each { key, value ->
    println "the key is $key," + "the value is $value"
}
 
student.eachWithIndex { key, value, index ->
    println "the index is $index," + "the key is $key," + "the value is $value"
}

/**
 * map 查找
 */
def student = [
        1: [number: 001, score: 45, age: 24, name: "ztz"],
        2: [number: 002, score: 56, age: 25, name: "yif"],
        3: [number: 003, score: 67, age: 26, name: "fxy"],
        4: [number: 004, score: 78, age: 26, name: "cxm"],
]
 
def entry = student.find { def students ->
    //必须通过get来获取key值
    return students.value.get("score") >= 60
}
def entrys = student.findAll { def stu ->
    return stu.value.get("score") >= 60
}
println entry
println entrys
 
def counts = student.count { def stu ->
    return stu.value.get("score") >= 60 && stu.value.get("age") == 26
}
println counts
 
def names = student.findAll { def stu ->
    return stu.value.get("score") >= 60
}.collect {
    //使用collect进行过滤，只输出名字
    return it.value.get("name")
}
println names.toListString()
 
//groupBy 进行分组输出
def groupResult = student.groupBy { def stu ->
    return stu.value.get("score") >= 60 ? "及格" : "不及格"
}
println groupResult.toMapString()

/*
map 排序
 */
def sortResult = student.sort { def stu1, def stu2 ->
    Number sore1 = stu1.value.get("score")
    Number sore2 = stu2.value.get("score")
    return sore1 == sore2 ? 0 : sore1 > sore2 ? 1 : -1
}
println sortResult.toMapString()

/*
范围
 */
def range = 1..10
println range[0]
println range.contains(10)
//获取范围起始值
println range.from
println range.to
range.each {
    print it + " "
}
 
def getGrade(Number number) {
    def result = 0
    switch (number) {
        case 0..<60:
            result = "不及格"
            break
        case 60..<70:
            result = "及格"
            break
        case 70..<80:
            result = "良好"
            break
        case 80..<100:
            result = "优秀"
            break
    }
    //return 可以省略
    return result
}
 
println getGrade(90)