Groovy02_字符串与循环

1. 字符串

字符串
单引号与双引号的区别 （使用闭包时候惰性求值）
多行字符串
对字符串类型的一些扩展
(execute、find)

class lsn_2_0 {

    static String test(){
        // 这是java的写法
        //return "111"

        // 但是在Groovy当中，无论是我们的函数还是我们的闭包，
        // 我们不写return，他会默认把这个方法体（代码块）当中的最后一行作为一个返回值
        "111"
        "222"
    }

    // (String[] args) 代表接收String[] 类型的参数
    // (args)   前面不写 代表能接收任意类型的参数
    static  void main (args){
//        println "Grovvy"
        // 1. 字符串   i 和 j 都是String类型  ，k 是char类型
        def k = 'a' as char
        def i = 'Groovy'
        def j = "Grovvy"
        println k.class         //  class java.lang.Character
        // 2. 字符串的拼接
        //      1. 用 + 拼接
        def z = "zekign" + i
        println z               // zekignGroovy
        //      2. 用 String.format   整形用%d char 用%c  stirng 用%s
        String.format("gr%doovy",9)
        println String.format("gr%doovy",9)     // gr9oovy
        println String.format("gr%soovy",i)     // grGroovyoovy
        println String.format("gr%coovy",k)     // graoovy
        //      3. 用${}  跟Linux的shell脚本一样  只用双引号的时候才能用
        def a = 'a'
        def b = "Zek${a}ing"
        println b               // Zekaing
        //          闭包，就是可执行的代码块，跟函数一样可以接收参数
        //          在-> 前面定义我们的参数列表
        //          这个代码块会在我们使用到这个变量的时候执行
        def c = "Grov${->a}vy"  // 后面用到闭包在说
        a = '123'   // 惰性求值的方式
        println c               // Grov123vy

        println test()

        // 3. 多行字符串
        //      d java写法
        //      e  3个双引号中间写  要换行直接回车
        def d = "java\nddd  groovy"
        def e = """java
eeee groovy"""
        println d
        println e

        // 4. Groovy为很多类都注入了很多方法
        //      4.1
        //      所以我们可以直接使用对象进行条件判断，例如
        "".asBoolean()
        //      4.2
        if("".asBoolean()){  // 这种写法和 if("")  是一样的，他会自动调用asBoolean方法

        }
        //      4.3 如果定义的是整形
        def f = 9
        f.asBoolean()
        //      4.4
        "cmd /c groovy -v".execute()  // window这样写，如果是Linux 或者 苹果系统  "groovy -v".execute()
        println "cmd /c groovy -v".execute().text  // Groovy Version: 2.4.14 JVM: 1.8.0_111 Vendor: Oracle Corporation OS: Windows 10

        println "groovy"[0]         // g
        println "groovy" - "vy"     // groo
    }
}

2. 循环

IntRnage i..j(0..9)
times/downto/upto/step

// 循环

for (int i = 0; i<10;++i){
    print i+' '
}
// 0 1 2 3 4 5 6 7 8 9
println("")
for (i in new IntRange(0,9)){
    print i+' '
}
// 0 1 2 3 4 5 6 7 8 9
println("")
for (i in new IntRange( 0 , 9 ,true)){
    print i+' '
}
// 9 8 7 6 5 4 3 2 1 0
println("")
for (i in new IntRange(false,0,9)){
    print i+' '
}
// 0 1 2 3 4 5 6 7 8
println("")
for (i in 0..9){
    print i+' '
}
// 0 1 2 3 4 5 6 7 8 9
println("")
def j = 0..9
println j.class
// class groovy.lang.IntRange
for (i in 0..<9){
    print i+' '
}
// 0 1 2 3 4 5 6 7 8
println("")
// 当我们定义一个闭包的时候，我们没有给他指定参数列
// 表的时候，他是默认可以接受一个参数的
// 这个参数我们就用it来接收他
10.times {
    print it + ' '
}
// 0 1 2 3 4 5 6 7 8 9
println("")

10.upto(15){
    print it + ' '
}
// 10 11 12 13 14 15
println("")
10.downto(5){
    print it + ' '
}
// 10 9 8 7 6 5
println("")
10.step(15,2){
    print it + ' '
}
// 10 12 14
println("")
10.step(6,-2){
    print it + ' '
}
// 10 8 6