Groovy文件操作（贼简单，使用后在也不想用java的文件了）

掌握了这章的Json、Xml、groovy文件处理后，groovy语法就告一段落了，接下啦就可以踏入期待已久的gradle部分了。

一、Json处理

json的知识点一般分为两部分实体生成json字符串，json字符串转为实体。groovy为我们提供了api方便处理json，比java功能还要强大。其实我们没必要使用第三方库拉（Gson、fastGson）

1、实体生成json字符串

def list = [new Person(name: "Tom", age: 10),
            new Person(name: "Kate", age: 12)]

def jsonString = JsonOutput.toJson(list) //直接转变为Json
println(jsonString)

println(JsonOutput.prettyPrint(jsonString)) // 格式化输出json
//log:
[{"age":10,"name":"Tom"},{"age":12,"name":"Kate"}]
[
    {
        "age": 10,
        "name": "Tom"
    },
    {
        "age": 12,
        "name": "Kate"
    }
]

可以看出转换时主要使用的两个静态方法：
1、JsonOutput.toJson（agrs）可以直接把json对象转化为字符串
2、JsonOutput.prettyPrint(string)可以吧json字符串直接可视化输出，方便的一批。。

2、json字符串转为实体

// 准备一份json数据
String json = "[{\"age\":10,\"name\":\"Tom\"},{\"age\":12,\"name\":\"Kate\"}]"
def jsonSlurper = new JsonSlurper()

def userList =  jsonSlurper.parseText(json)
println(userList[0].name) //Tom

可以看出转换时主要使用的对象和方法：
1、获得JsonSlurper对象
2、对象的parseXXX（）即可

3、无缝衔接java的各种库

有人想说我还是喜欢google提供的Gson（安卓开发使用的较多）或者阿里的FastJson（后台使用的较多），不用担心groovy既然和java现有的api、第三方库无缝衔接，那么像java那样使用即可。

（1）idea上简单使用步骤介绍

1、下载java包，放到idea上的文件夹中（一般我们建立个libs）
2、选中java包add as library即可使用类

（2）有关网络

其实groovy没有提供网络访问的库，我们只需要使用java的那一套即可。

二、Xml处理

和json一样常用的就是处理xml字符串，或者生成xml文件。

1、解析xml字符串

其实解析xml字符串和解析xml文件都几乎一致，这里就以字符串为栗子啦

（1）解析xml字符串

1、获得XmlSlurper对象（new 方式）
2、获得节点对象（parseXXX(xmlString)方法的返回值）
3、通过节点对象获得节点值、节点属性值

• 节点值的获取：节点对象.text()
• 节点属性值访问：节点对象.@属性

String xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
        "<value>\n" +
        "    <books id=\"1\" type=\"android\">\n" +
        "        <book page=\"507\">\n" +
        "            <title>安卓开发艺术探索</title>\n" +
        "            <author>任玉刚</author>\n" +
        "        </book>\n" +
        "        <book page=\"507\">\n" +
        "            <title>第一行代码</title>\n" +
        "            <author>郭霖</author>\n" +
        "        </book>\n" +
        "        <book page=\"100\">\n" +
        "            <title>安卓进阶之光</title>\n" +
        "            <author>刘望舒</author>\n" +
        "        </book>\n" +
        "    </books>\n" +
        "\n" +
        "</value>"
def xmlSlurper = new XmlSlurper()
def value = xmlSlurper.parseText(xmlString) // 1、获得根节点对象

println value.books.book[0].title.text() //2、节点对象调用text()获得节点内的值

println value.books.book[0].@page // 3、对象@属性 直接访问这个属性值

（2）传统的闭包方式遍历

1、遍历： 书本页数为 507 的书
2、 思路：对book对象进行遍历即可

def bklist  = []

value.books.book.each {

    bk ->
        def pageCount = bk.@page
        if (pageCount == "507") {
            bklist.add(bk.title.text())
        }
}

println bklist.toListString()
//log:
[安卓开发艺术探索, 第一行代码]

（3）Groovy提供的更简单遍历方法：深度遍历

println value.depthFirst().findAll(){
    book-> return book.author.text()=="任玉刚"
}

1、直接调用目标节点的depthFirst方法的findAll即可，直接遍历目标节点集合。
2、depthFirst方法也可使用“**”代替

（4）Groovy提供的更简单遍历方法：广度遍历

def name= value.books.children().findAll {
    node -> node.@page == "507" && node.author.text() == "任玉刚"
}.collect {
    node -> return node.title.text()
}

println("name:$name")

1、直接调用目标节点的children方法的findAll即可，直接遍历目标节点集合。
2、depthFirst方法也可使用“*”代替

2、生成xml文件

（1）要生成的xml

<LolPersons id='1'>
  <yasuo type='中单' desc='托儿索'>亚索</yasuo>
  <gailun type='上单' desc='战士'>盖伦</gailun>
</LolPersons>

（2）静态生成：MarkupBuilder类的使用

//xml 的生成
//public class StringWriter extends Writer

def sw = new StringWriter() // 生成的xml写入文件
def xmlBuilder = new MarkupBuilder(sw) // 生成xml的核心类

xmlBuilder.LolPersons(id:"1"){
    yasuo(type:"中单" ,desc:"托儿索","亚索")
    gailun(type:"上单" ,desc:"战士","盖伦")
}
println(sw)
----------------------------------------
log:
<LolPersons id='1'>
  <yasuo type='中单' desc='托儿索'>亚索</yasuo>
  <gailun type='上单' desc='战士'>盖伦</gailun>
</LolPersons>

1、核心类MarkupBuilder
2、思路：

1、先生成根节点，调用方法即可（方法名为根节点名）
2、节点套节点就是，闭包里面吊方法
3、节点的属性、属性值就使用键值对即可
4、节点的值直接使用值即可。

（2）实体数据填充（动态方式）

1、定义实体
2、MarkupBuilder类进行生成
ps：json使用的较多，这里讲一种方式。

三、文件

java文件的操作api groovy都可以使用，但是groovy对文件进行了封装，更快捷操作

1、读取文件

如图读取工程目录下的这个iml文件

// 1、文件的读取(本工程下的一个iml文件)
def file = new File("../../HelloGroovy.iml")

// 遍历方式1(有点鸡肋)
file.eachLine {
    line -> println(line)
}

// 遍历方式2（快捷）
String text = file.getText()
println(file.getText())

println(file.readLines()) // 读取没行的结果放入了list集合中

// 遍历方式3：读取指定数据(前100个字符)

println(file.withReader {
    reader ->
        char[] buf = new byte[100]
        reader.read(buf)
        return buf
})

可以看出上面三种方式，其中file.getText()最简单，直接获得文件的文本内容，很适合读取文本文件。

2、文件的写

def newFile = new File("../../HelloGroovy2.iml")
if (!newFile.exists()) {
    newFile.createNewFile()

    newFile.withWriter {
        write -> write.append(file.getText())
    }
}

工程目录下复制份HelloGroovy2.iml文件
可以看出一句append（）直接写入文件中

3、对象的序列化：读写对象

//1、保存对象

def saveObject(Object object, String path) {
    def file = new File(path)
    if (!file.exists()) {
        file.createNewFile()
    }
    file.withObjectOutputStream {
        objectStream -> objectStream.writeObject(objectStream)
    }
}

//2、 读对象

def readObject(String path) {
    def obj = null
    def file = new File(path)
    if (!file.exists() || file == null) {
        return
    }
    file.withObjectInputStream {
        readObject ->
            obj = readObject.readObject()
    }
    return obj
}

4、小结

1、可以看出groovy扩展了File类
2、通过withXXX闭包方式可以获得相关的对象进行相关操作（例如，reader、writer、ObjectInputStream、等对象），这些对象操作时不需要进行close等操作。
3、通过newXXX也可以获得相关对象，相当于使用了java的文件类，需要close等操作。

end

感觉文件的相关处理封装太牛b了，使用过感觉有点不想用java啦！！！！