groovy基础

变量

groovy中没有基本类型的变量，都是对象类型的。定义的int也会被转成Integer类型。

int x = 10
//输出结果为 class java.lang.Integer
println x.class

double d =3.14
//输出结果为 class java.lang.Double
println d.class

弱类型定义方式

def a = 3.14
//输出结果为 class java.math.BigDecimal
println a.class

可以为一个变量多次改变类型

def aa = 12
//输出结果为 class java.lang.Integer
println aa.class

aa='12'
//输出结果为 class java.lang.String
println aa.class

字符串

def s = '111'
//输出结果为 class java.lang.String
println s.class

 s = "222"
//输出结果为 class java.lang.String
println s.class

s = """
333
333
"""

//输出结果为 class java.lang.String
println s.class

一个单引号、两个单引号和三个单引号表示的都是java.lang.String的字符串。三个单引号定义的字符串可以保留字符串的格式，可以按照格式输出三个单引号里面的字符串。

def ss = "groovy"
def ss2 = "hello ${ss}"
//输出结果为 class org.codehaus.groovy.runtime.GStringImpl
println ss2.class

${} 大括号内可以放任意的表达式,例如：

def sum = "1+1=${1 + 1}"
//输出结果为1+1=2
println sum

GString类型和String类型可以相互转换，不需要强转。

def s = "groovy"
def ss = "hello ${s} "
def result = ehco(ss)
//输出结果为 class java.lang.String
println result.class

//传入的是GString类型的 参数是String类型的 返回值是String类型的  说明GString和String可以互相转换
String ehco(String s) {
    return s
}

字符串常用方法

def str = "groovy"
def result = str.center(8, 'a')
//输出结果为 agroovya  以str为中心 两边填充
println result

//只有一个参数的话  用空格填充
result = str.center(10)
println result

result = str.padLeft(10, 'a')
//输出结果为 aaagrooovy  左边填充
println result

result = str.padRight(10, 'a')
//输出结果为 grooovyaaa  右边填充
println result


def str = 'hello'
def str2 = 'groovy'
//输出结果为true 字符串也可以用 > < == 来比较
println str > str2

//输出结果为 e 可以通过类似于数组下标的方式  获取字符串中的某一个字符
println str[1]

//输出结果为 hel 可以通过传入一个范围来取一个字符串片段  首尾闭合区间 包含下标0 和下标2
println str[0..2]

def str = 'hello groovy'
def str2 = 'groovy'
//输出结果一样  结果为 hello  意思是从str中去掉和str2一样的字符串
println str - str2
println str.minus(str2)

//输出结果为yvoorg olleh  可以将字符串倒序
println str.reverse()

//输出结果为 Hello groovy  可以将字符串的首字母大写
println str.capitalize()

//输出结果为 false 判断字符串是否都是数字
println str.isNumber()

//将字符串转成其他类型 toInteger toDouble 等等
println str.toDouble()

逻辑语句

switch case

def x = 1.23
def result
switch (x) {
    case 'foo': result = 'foo'; break
    case 'bar': result = 'bar'; break
    case [4, 5, 6, 'list']: result = 'list'; break//列表
    case 12..30: result = 'range'; break//范围
    case Integer: result = 'integer'; break
    case BigDecimal: result = 'bigdecimal'; break
    default: result = 'defaule'
}

//输出结果为 bigdecimal  case里面可以是任意的对象类型
println result

对范围的for循环

def sum = 0
for (i in 0..100) {
    sum += i
}
//输出结果为5050 包含头和尾
println sum

对list的循环

def sum = 0
for (i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) {
    sum += i
}
//输出结果为55 包含头和尾
println sum

对map的循环

for (i in ['key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4', 'key5': 'value5']) {
    println 'key='+i.key+"  value="+i.value
    //输出结果为
    //key=key1  value=value1
    //key=key2  value=value2
    //key=key3  value=value3
    //key=key4  value=value4
    //key=key5  value=value5
}

闭包

//闭包就是{}括起来的代码块
def clouser = { println 'hello groovy' }
//调用闭包 方式1
clouser.call()
//调用闭包 方式2
clouser()

带参数的闭包

//用 -> 区分参数和代码块   左边的是参数 右边的是逻辑
def clouser = { name, age -> println "name is  ${name},age is ${age}" }
clouser.call("qgl", 25)
clouser("qgl", 25)
//输出结果为 name is  qgl,age is 25

闭包的默认参数

//闭包有一个默认参数  it
def clouser = { println "name is ${it}" }
//输出结果为 name is tom
clouser("tom")

闭包的返回值

//闭包一定有返回值
def clouser = { return "name is ${it}" }
//输出结果为 name is joy
println clouser("joy")

clouser = {println "name is ${it}"}
//输出结果为null  闭包里没有return的话 就return一个null
println clouser("jack")

求一个数的阶乘

int x = 3
//求一个数的阶乘
int fab(int number) {
    int result = 1
    //从1增加到number   闭包中是每次增加后执行的逻辑
    1.upto(number, { num -> result *= num })
    return result
}
//输出结果为6
println fab(x)

int fab2(int number) {
    int result = 1
    //如果一个方法的最后一个参数是一个闭包的话  这个闭包可以写在方法的外面
    number.downto(1) {
        num -> result *= num
    }
    return result
}
//输出结果为6
println fab2(x)

求和

int cal(int number) {
    int result
    //times不包含最后一个值 所以1-100的和 要传入101才可以  因为times的起始值是0 所以不能用来求阶乘
    number.times {
        num -> result += num
    }
    return result
}

println cal(101)
//输出结果为5050

字符串遍历

String str = "the 2 and 3 is 5"

str.each {
    //输出结果为the 2 and 3 is 5
    temp -> print temp
}

str.each {
    //输出结果为 tthhee  22  aanndd  33  iiss  55  每个字符打印两边
    temp -> print temp.multiply(2)
}

通过find查找符合条件的第一个字符

//通过find查找符合条件的第一个字符
String str = "the 2 and 3 is 5"
println str.find {s ->
        if (s == "2") {
            return true
        }
}

findAll方法返回一个集合

String str = "the 2 and 3 is 5"
//返回一个集合 输出结果为 [2, 3, 5]
println str.findAll {s ->
        if (s.isNumber()) {
            return true
        }
}

any方法返回bool类型的值

String str = "the 2 and 3 is 5"
//返回bool类型的值 返回值为true 如果有一个满足条件 就返回true
println str.any {
    s ->
        if (s.isNumber()) {
            return true
        }
}