本文参考自The Groovy Development Kit，一些代码直接引用了源文档。

Groovy开发工具包（The Groovy Development Kit）的名字一开始迷惑了我，我以为是一些IDE的插件之类的。在实际看了原文档之后，我才明白这是Groovy提供的一组类库和方法，让我们开发更加方便。

IO功能

在Java中读写文件非常麻烦。由于JDK类库设计问题，以及Java本身的局限性，导致Java自带的功能很不好用。比如说Java的读写流，使用了装饰器设计模式，原意是让我们能够自行组合各种流，实现功能。但是实际情况是这让类库变得很复杂，我们哪怕是简单读写文件也需要声明一个很长的嵌套流。

Groovy为JDK的很多类提供了很多助手方法，让文件读写变得异常简单。列举如下。如果需要查看完整的GDK文档，可以查看GDK API文档。

• the java.io.File class : http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/File.html
• thejava.io.InputStream class: http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/InputStream.html
• the java.io.OutputStream class: http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/OutputStream.html
• thejava.io.Reader class: http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/Reader.html
• the java.io.Writer class: http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/Writer.html
• the java.nio.file.Path class: http://docs.groovy-lang.org/latest/html/groovy-jdk/java/nio/file/Path.html

读取文件

Groovy提供了非常方便的文件读写方式。而且在使用withXXX方法或者闭包中抛出异常时，Groovy会自动关闭文件资源。所以我们可以放心的使用这些API。首先来看看文件读取。

Groovy为我们提供了丰富的功能。如果只需要简单读一个文件，简单的几行代码就可以做到。这些方法很简单，看代码就能知道怎么用。

    static void readingFiles() {
        def baseDir = /C:\Windows\System32\drivers\etc/
        def filename = 'hosts'

        //读取文件
        def file = new File(baseDir, filename)
        file.eachLine {
            println(it)
        }

        //同时获取行号
        file.eachLine { line, num ->
            println("line $num:$line")
        }

        //获取字节流
        byte[] contents = file.bytes
        println(contents.join(''))
        //获取行列表
        String[] lines = file.collect { it }
        println(lines.join('\n'))

        //将文件用作输入流
        file.withInputStream {
            //在这里执行操作
        }

    }

写入文件

写文件和读文件一样简单。我们可以使用Writer来写文件。文件编码可以不指定，默认是UTF-8。

new File(baseDir,'haiku.txt').withWriter('utf-8') { writer ->
    writer.writeLine 'Into the ancient pond'
    writer.writeLine 'A frog jumps'
    writer.writeLine 'Water’s sound!'
}

还可以使用左移操作符更简单的写文件，这种方式是追加方式。

new File(baseDir,'haiku.txt') << '这是一段文字'

还可以直接写入文件的字节流。

file.bytes = [66,22,11]

同样的，可以直接操作输出流，使用withXXX方法可以在闭包结束之后就自动关闭资源。

new File(baseDir,'data.bin').withOutputStream { stream ->
    // do something ...
}

遍历文件树

遍历文件树也很简单。首先来看看遍历目录。

def dir = new File('C:\\Windows')

//列出所有文件
dir.eachFile {
    if (it.isFile()) {
        println(it)
    }
}
//列出所有可执行文件
dir.eachFileMatch(~/.*\.exe$/){
    println(it)
}

递归遍历也很简单，使用eachFileRecurse方法即可，还可以像方法传递枚举变量指定要递归的类型。

dir.eachFileRecurse { file ->                      
    println file.name
}

dir.eachFileRecurse(FileType.FILES) { file ->      
    println file.name
}

traverse方法提供了更强大的功能，该方法还可以接受一个Map作为遍历参数，详细参数作用参见[这里](http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/File.html#traverse(java.util.Map, groovy.lang.Closure))。

dir.traverse { file ->
    if (file.directory && file.name=='bin') {
        FileVisitResult.TERMINATE                   
    } else {
        println file.name
        FileVisitResult.CONTINUE                    
    }

}

序列化对象

在Groovy中序列化和反序列化对象同样简单，直接看代码。

    static void serializeObjects() {
        def person = new Person(id: 1, name: 'yitian', birthday: LocalDate.now())

        def file = new File(getCurrentDir(), 'obj.txt')
        file.withObjectOutputStream { it.writeObject(person) }

        def obj
        file.withObjectInputStream { obj = it.readObject() }
        println(obj)

    }

class Person implements Serializable{
    int id
    String name
    LocalDate birthday

    @Override
    String toString() {
        "Person(id=$id,name=$name,birthday=$birthday"
    }
}

执行外部进程

在Grooy中调用外部进程也很简单。在字符串上面调用execute方法，然后就会返回一个java.lang.Process对象。

    static void executeExternalProcess() {
        //列出文件
        def userDir = System.properties['user.dir']
        def process = "cmd /c dir ${userDir}".execute()
        println "${process.text}"
    }

要连接到进程的输入输出流也很简单，直接引用进程的in、out、err属性即可。需要注意in是输出流，out、err是输入流。

def process = "ls -l".execute()             
process.in.eachLine { line ->               
    println line                            
}

进程也支持各种高级操作，例如管道。我们只要调用进程的pipeTo方法，或者使用管道操作符，都可以使用管道。其他进程的使用方法请参见Groovy文档。

proc1 = 'ls'.execute()
proc2 = 'tr -d o'.execute()
proc3 = 'tr -d e'.execute()
proc4 = 'tr -d i'.execute()
proc1 | proc2 | proc3 | proc4
proc4.waitFor()
if (proc4.exitValue()) {
    println proc4.err.text
} else {
    println proc4.text
}

集合操作

Groovy开发工具包提供了方便的集合操作，这些操作类似Java 8的流类库，C#的LINQ，Kotlin的集合库，提供了各种方便的功能。

列表操作

列表上定义了丰富的操作，求和、排序、取值、集合运算等等。直接看代码吧。

    static void lists() {
        println('列表')
        //定义列表
        def list = [1, 3, 25, 77, 5, 8, 97, 34, 100, 230]

        //访问列表
        println(list[2])

        list[1] = 100
        println(list[2..-1])

        //添加元素
        list << 77
        list << 45
        list.add(12)
        list.addAll([1, 2, 3, 4, 5])
        list += 5
        println(list)

        //删除元素
        list - 77
        //删除下标为6的元素
        list.remove(6)
        list.removeAll([1, 2, 3, 4, 5])
        list -= 5
        println(list)

        //列表排序
        list.sort().reverse()
        println(list)

        //断言
        assert ![]
        assert list
        //迭代
        list.each { print("$it ") }
        println()

        //带序号迭代
        list.eachWithIndex { int e, int index -> print("$index->$e ") }
        println()

        //转换列表
        def multi2 = list.collect { it * 2 }
        println(multi2)

        //和上面等价
        def times2 = list*.multiply(2)
        println(times2)

        //过滤列表
        def greaterThan17 = list.findAll { it > 7 }
        println(greaterThan17)

        //只查找第一个
        def firstGreaterThan7 = list.find { it > 7 }
        println(firstGreaterThan7)

        //判断列表
        assert !list.every { it > 100 }
        assert list.any { it > 100 }

        //求和和最值
        def sum = list.sum()
        println("sum=$sum")
        println("max=${list.max()}")
        println("min=${list.min()}")

        //连接操作
        println([1, 2, 3, 4].join('<->'))

        //累积操作，累加、累乘还有更复杂的操作
        println("累计求和:${[1, 2, 3, 4].inject { s, i -> s + i }}")
        println("累计求积:${[1, 2, 3, 4].inject { s, i -> s * i }}")

        //集合操作
        def list1 = [1, 2, 3, 4]
        def list2 = [2, 3, 5, 4, 23, 2]
        println("求交:${list1.intersect(list2)}")
        println("2出现了几次:${list2.count(2)}")
        println("有几个奇数:${list2.count { it % 2 != 0 }}")

        //无相交元素
        assert [1, 2, 3].disjoint([4, 5, 6])

        //重复元素
        println("[1,2]重复两遍是什么:${[1, 2] * 2}")
        println("[1,2]重复4遍是什么:${[1, 2].multiply(4)}")
    }

Map操作

Map同样支持很多操作。直接看代码吧。

    static void maps() {
        println("Map")
        def map = [:]
        //添加元素
        map[7] = 7
        map.put(8, 8)
        (1..6).each { map[it] = it }

        //遍历元素
        println(map)
        map.each { entry -> println("key:$entry.key,value:$entry.value") }
        map.eachWithIndex { Map.Entry<Object, Object> entry, int index ->
            println("index:$index,key:$entry.key,value:$entry.value")
        }
        map.each { key, value ->
            println("key:$key,value:$value")
        }

        //集合
        println("keys:${map.keySet()}")
        println("entries:${map.entrySet()}")
        println("values:${map.values()}")

        //分组
        def list = [1, 2, 3, 4, 5, 6]
        def group = list.groupBy { it % 2 == 0 }
        println("分组后的结果:$group")

        //获取字符串键值
        def couples = [amy: 'leo', king: 'lily', smith: 'lisa']
        println(couples['king'])
        println(couples.smith)


        //字符串键要特别注意
        def name = 'yitian'
        def people = [name: 24]
        println(people)
        //使用括号才能正确将变量的值用作键
        people = [(name): 24]
        println(people)

        //不要用GString作为键，它和String的哈希值不同
        def s = '1234'
        def gs = "${s}"
        println("GString hash:${gs.hashCode()},String hash:${s.hashCode()}")

        //放进去再用String取是读不出来的
        def m = [(gs): 123]
        assert m[s] == null
    }

范围操作

范围操作是另一类方便的操作。我们可以定义闭区间和开闭区间，然后方便的迭代和判断范围。

    static void ranges() {
        def range = 1..10
        println(range)

        //开闭区间
        def range2 = 1..<10
        range2.each { print "$it " }
        println()

        //范围的起止
        println("起:${range.from},止:${range.to}")
        
        //范围继承了List接口
        assert range instanceof List

        println("第二个和最后第二个元素:${range[1, -2]}")
        println("第二个到倒数第二个:${range[1..-2]}")

        println("3是否在范围内:${3 in range}")

        //范围可用于switch
        def marriedYears = 15
        switch (marriedYears) {
            case 1..5:
                println("小夫妻")
                break
            case 6..10:
                println("老夫妻")
                break
            case 11..30:
                println("老夫老妻")
                break
            default:
                println("成仙了")

        }
    }

操作符

Groovy还提供了切片操作符、展开操作符和星点操作符，对集合执行不同的操作。

    static void operators() {
        //切片运算符
        def list = 1..100
        println("倒数十个元素:${list[-10..-1]}")

        //展开运算符，也就是将两个集合展开合并为一个
        def list2 = [1, 2, 3, *(4..10)]
        println(list2)

        //星点操作符，用于选定一个集合中的某个属性
        def people = [[name: 'yitian'], [name: 'zhang3'], [name: 'li4']]
        println("所有名字是:${people*.name}")
    }

Groovy还为提供了扩展的方法，详细情况请参见相应文档。

• 添加到Iterable的方法可以在后面的链接中找到here
• 添加到Iterator的方法可以在后面的链接中找到here
• 添加到Collection的方法可以在后面的链接中找到here
• 添加到List的方法可以在后面的链接中找到here
• 添加到Map的方法可以在后面的链接中找到here