Groovy learning record 04

1. List basic operations

package study

/**
 * GroovyList的Demo
 */
//定义List
def list = [5, 'string', true]
//变量存取：可以直接通过索引存取，而且不用担心索引越界。如果索引超过当前链表长度，List会自动
//往该索引添加null元素
list[100] = 100
println list.class //class java.util.ArrayList
println list.size()  //101

//list操作合集
def list01 = [5, 'string', true]
//1.添加
list01.add(4)
list01 << 3
println list01 //[5, string, true, 4, 3]
def newList01 = list01 + 7
println newList01//[5, string, true, 4, 3, 7]
newList01.add(0, 1) //指定下标添加元素
println newList01//[1, 5, string, true, 4, 3, 7]

//2.删除
newList01.remove(2)//移除index=2的元素
println newList01 //[1, 5, true, 4, 3, 7]
newList01.remove((Object) 7)//移除指定元素
println newList01//[1, 5, true, 4, 3]
newList01.removeElement(true)
println newList01//[1, 5, 4, 3]
newList01.removeAll {
    
     //移除集合中是偶数的函数
    it % 2 == 0
}
println newList01//[1, 5, 3]
println newList01 - [1, 3]//[5]

//3.查找
def findList = [5, -2, 4, -3, 1]
//查找满足条件的第一个元素
println findList.find {
    
     it % 2 == 0 } //-2
//查找满足条件的所有元素
println findList.findAll {
    
     it % 2 == 0 }//[-2, 4]
//查找是否存在满足条件的元素
println findList.any {
    
     it % 2 == 0 }//true
//查找是否全部满足条件
println findList.every {
    
     it % 2 == 0 }//false
//查找绝对值最小的元素
println findList.min {
    
     Math.abs(it) }  //1
//查找绝对值最大的元素
println findList.max {
    
     Math.abs(it) }//5
//统计满足元素的个数
println findList.count {
    
     it > 0 } //3

//4.排序
def sortList = [5, 7, 9, -1, 2, 10]
sortList.sort {
    
     a, b -> a == b ? 0 : Math.abs(a) > Math.abs(b) ? 1 : -1 }
println sortList//[-1, 2, 5, 7, 9, 10]
//对象排序
def sortStringList = ['aaaa', 'bbbb', 'e', 'dd', 'c']
//根据字符串长度来排序
sortStringList.sort {
    
     it.size() }
println sortStringList//[e, c, dd, aaaa, bbbb]

//定义数组
def array = [1, 3, 4, 2, 5, 7, 6] as int[]
println array.class //class [I

Two, the basic operation of Map

package study.collection

/**
 * 针对map集合的操作
 */

def key1 = "wahaha"
def map = [(key1): "value1", name: "ymh"]
println map//[wahaha:value1, name:ymh]

def colors = [red: '#ff0000', green: '#00ff00', blue: '#0000ff']
println colors['red']  //#ff0000
println colors.red //#ff0000

println colors.getClass()//class java.util.LinkedHashMap
println colors//[red:#ff0000, green:#00ff00, blue:#0000ff]

//添加元素
colors.yellow = "#ffff00"
println colors//[red:#ff0000, green:#00ff00, blue:#0000ff, yellow:#ffff00]

//添加集合对象
colors.map = [key1: 1, key2: 2]
println colors.toMapString()//[red:#ff0000, green:#00ff00, blue:#0000ff, yellow:#ffff00, map:[key1:1, key2:2]]

//遍历map
def teachers = [
        1: [number: '001', name: 'tom'],
        4: [number: '004', name: 'tony'],
        3: [number: '003', name: 'jerry'],
        2: [number: '002', name: 'jok'],
        5: [number: '005', name: 'jack'],
        6: [number: '006', name: 'xiao ma'],
        8: [number: '008', name: 'rain'],
        7: [number: '007', name: 'nua'],
        9: [number: '009', name: 'tony']
]
//用键值对的方式
teachers.each {
    
    
    def key, def value ->
        println "key=$key----value=$value"
}
println "===================================================="
teachers.each {
    
    
    println it.class//class java.util.LinkedHashMap$Entry
    println "key:${it.key}====value:${it.value}"
}
//带索引的方式
teachers.eachWithIndex {
    
     def teacher, int index ->
    println "下标index==$index--key=${teacher.key}--value=${teacher.value}"
}
teachers.eachWithIndex {
    
     it, int index ->
    println "一个参数：下标index==$index--key=${it.key}--value=${it.value}"
}
teachers.eachWithIndex {
    
     def key, def value, int index ->
    println "下标index==$index--key=${key}--value=${value}"
}
//map的查找
println teachers.find {
    
     it.value.name == 'tony' }//4={number=004, name=tony}
println teachers.findAll {
    
     it.value.name == 'tony' }//[4:[number:004, name:tony], 9:[number:009, name:tony]]
println teachers.count {
    
     it.value.name == 'tony' }//2

//实现嵌套查询
println teachers.findAll {
    
     it.value.name == 'tony' }.collect() {
    
     it.value.number }
//实现分组查询
println teachers.groupBy {
    
     it.value.name == 'tony' ? 'group1' : 'group2' }
//排序，根据key值来排序
println teachers.sort {
    
     t1, t2 -> t1.key > t2.key ? 1 : -1 }

Three, Range basic operation

package study

/**
 * 范围编程
 */
def range = 10..1//虽然反转了，但是起点仍然是1，终点仍然是10
println "当前这个范围是否反转，${range.isReverse()}"
println range[0]
println range.contains(8)
def range1 = 10..1
println range1.from //起点  1
println range1.to//终点  10

println "====================="
//遍历
range.each {
    
     println it }
println "====================="
for (i in range) {
    
    
    println i
}
println "====================="


//获得成绩等级,默认返回最后一行
def getGrade(Number score) {
    
    
    switch (score) {
    
    
        case 0..<60:
            result = '不及格'
            break;
        case 60..100:
            result = '及格'
            break;
        default:
            result = '输入异常'
    }
}

println getGrade(50)
println getGrade(80)
println getGrade(120)package study.collection

/**
 * 范围编程
 */
def range = 10..1//虽然反转了，但是起点仍然是1，终点仍然是10
println "当前这个范围是否反转，${range.isReverse()}"
println range[0]
println range.contains(8)
def range1 = 10..1
println range1.from //起点  1
println range1.to//终点  10

println "====================="
//遍历
range.each {
    
     println it }
println "====================="
for (i in range) {
    
    
    println i
}
println "====================="


//获得成绩等级,默认返回最后一行
def getGrade(Number score) {
    
    
    switch (score) {
    
    
        case 0..<60:
            result = '不及格'
            break;
        case 60..100:
            result = '及格'
            break;
        default:
            result = '输入异常'
    }
}

println getGrade(50)
println getGrade(80)
println getGrade(120)

/**
 * 1
 * 2
 * 3
 * 4
 * 5
 * 6
 * 7
 * 左闭右开
 */
(1..<8).each {
    
    
    println it
}