Groovy02_字符串与循环

Posted 2022-12-05 李樟清

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$aing"
        println b               // Zekaing
        //          闭包，就是可执行的代码块，跟函数一样可以接收参数
        //          在-> 前面定义我们的参数列表
        //          这个代码块会在我们使用到这个变量的时候执行
        def c = "Grov$->avy"  // 后面用到闭包在说
        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