clouser.call()
clouser()
def xxx = { paramters -> code }
def xxx = { 纯 code }
从 C/C++ 语言的角度看,闭包和函数指针很像,闭包可以通过 .call 方法来调用,也可以直接调用其构造函数,代码如下所示:
闭包对象.call(参数)
闭包对象(参数)
如果闭包没定义参数的话,则隐含有一个参数,这个参数名字叫 it,和 this 的作用类似。it 代表闭包的参数。表示闭包中没有参数的示例代码:
def noParamClosure = { -> true }
注意点:省略圆括号
函数最后一个参数都是一个闭包,类似于回调函数的用法,代码如下所示:
task JsonChao {
doLast ({
println “love is peace~”
}
})
// 似乎好像doLast会立即执行一样
task JsonChao {
doLast {
println “love is peace~”
}
}
闭包的用法
闭包的常见用法有如下 四种:
- 1)、与基本类型的结合使用。
- 2)、与 String 类的结合使用。
- 3)、与数据结构的结合使用。
- 4)、与文件等结合使用。
闭包进阶
- 1)、闭包的关键变量
- this
- owner
- delegate
- 2)、闭包委托策略
闭包的关键变量
this 与 owner、delegate
其差异代码如下代码所示:
def scrpitClouser = {
// 代表闭包定义处的类
printlin “scriptClouser this:” + this
// 代表闭包定义处的类或者对象
printlin “scriptClouser this:” + owner
// 代表任意对象,默认与 ownner 一致
printlin “scriptClouser this:” + delegate
}
// 输出都是 scrpitClouse 对象
scrpitClouser.call()
def nestClouser = {
def innnerClouser = {
// 代表闭包定义处的类
printlin “scriptClouser this:” + this
// 代表闭包定义处的类或者对象
printlin “scriptClouser this:” + owner
// 代表任意对象,默认与 ownner 一直
printlin “scriptClouser this:” + delegate
}
innnerClouser.call()
}
// this 输出的是 nestClouser 对象,而 owner 与 delegate 输出的都是 innnerClouser 对象
nestClouser.call()
可以看到,如果我们直接在类、方法、变量中定义一个闭包,那么这三种关键变量的值都是一样的,但是,如果我们在闭包中又嵌套了一个闭包,那么,this 与 owner、delegate 的值就不再一样了。换言之,this 还会指向我们闭包定义处的类或者实例本身,而 owner、delegate 则会指向离它最近的那个闭包对象。
delegate 与 this、owner 的差异
其差异代码如下代码所示:
def nestClouser = {
def innnerClouser = {
// 代表闭包定义处的类
printlin “scriptClouser this:” + this
// 代表闭包定义处的类或者对象
printlin “scriptClouser this:” + owner
// 代表任意对象,默认与 ownner 一致
printlin “scriptClouser this:” + delegate
}
// 修改默认的 delegate
innnerClouser.delegate = p
innnerClouser.call()
}
nestClouser.call()
可以看到,delegate 的值是可以修改的,并且仅仅当我们修改 delegate 的值时,delegate 的值才会与 ownner 的值不一样。
闭包的委托策略
其示例代码如下所示:
def stu = new Student()
def tea = new Teacher()
stu.pretty.delegate = tea
// 要想使 pretty 闭包的 delegate
修改生效,必须选择其委托策略为 Closure.DELEGATE_ONLY,默认是 Closure.OWNER_FIRST。
stu.pretty.resolveStrategy = Closure.DELEGATE_ONLY
println stu.toString()
需要注意的是,要想使上述 pretty 闭包的 delegate 修改生效,必须选择其委托策略为 Closure.DELEGATE_ONLY,默认是 Closure.OWNER_FIRST 的。
3、Groovy 数据结构
Groovy 常用的数据结构有如下 四种:
- 1)、数组
- 2)、List
- 3)、Map
- 4)、Range
数组的使用和 Java 语言类似,最大的区别可能就是定义方式的扩展,如下代码所示:
// 数组定义
def array = [1, 2, 3, 4, 5] as int[]
int[] array2 = [1, 2, 3, 4, 5]
下面,我们看看其它三种数据结构。
1、List
即链表,其底层对应 Java 中的 List 接口,一般用 ArrayList 作为真正的实现类,List 变量由[]定义,其元素可以是任何对象。
链表中的元素可以通过索引存取,而且 不用担心索引越界。如果索引超过当前链表长度,List 会自动往该索引添加元素。下面,我们看看 List 最常使用的几个操作。
1)、排序
def test = [100, “hello”, true]
// 左移位表示向List中添加新元素
test << 200
// list 定义
def list = [1, 2, 3, 4, 5]
// 排序
list.sort()
// 使用自己的排序规则
sortList.sort { a, b ->
a == b ?0 :
Math.abs(a) < Math.abs(b) ? 1 : -1
}
2)、添加
// 添加
list.add(6)
list.leftShift(7)
list << 8
3)、删除
// 删除
list.remove(7)
list.removeAt(7)
list.removeElement(6)
list.removeAll { return it % 2 == 0 }
4)、查找
// 查找
int result = findList.find { return it % 2 == 0 }
def result2 = findList.findAll { return it % 2 != 0 }
def result3 = findList.any { return it % 2 != 0 }
def result4 = findList.every { return it % 2 == 0 }
5)、获取最小值、最大值
// 最小值、最大值
list.min()
list.max(return Math.abs(it))
6)、统计满足条件的数量
// 统计满足条件的数量
def num = findList.count { return it >= 2 }
Map
表示键-值表,其 底层对应 Java 中的 LinkedHashMap。
Map 变量由[:]定义,冒号左边是 key,右边是 Value。key 必须是字符串,value 可以是任何对象。另外,key 可以用 ‘’ 或 “” 包起来,也可以不用引号包起来。下面,我们看看 Map 最常使用的几个操作。
1)、存取
其示例代码如下所示:
aMap.keyName
aMap[‘keyName’]
aMap.anotherkey = “i am map”
aMap.anotherkey = [a: 1, b: 2]
2)、each 方法
如果我们传递的闭包是一个参数,那么它就把 entry 作为参数。如果我们传递的闭包是 2 个参数,那么它就把 key 和 value 作为参数。
def result = “”
[a:1, b:2].each { key, value ->
result += “
k
e
y
key
keyvalue”
}
assert result == “a1b2”
def socre = “”
[a:1, b:2].each { entry ->
result += entry
}
assert result == “a=1b=2”
3)、eachWithIndex 方法
如果闭包采用两个参数,则将传递 Map.Entry 和项目的索引(从零开始的计数器);否则,如果闭包采用三个参数,则将传递键,值和索引。
def result = “”
[a:1, b:3].eachWithIndex { key, value, index -> result += “
i
n
d
e
x
(
index(
index(key$value)” }
assert result == “0(a1)1(b3)”
def result = “”
[a:1, b:3].eachWithIndex { entry, index -> result += “
i
n
d
e
x
(
index(
index(entry)” }
assert result == “0(a=1)1(b=3)”
4)、groupBy 方法
按照闭包的条件进行分组,代码如下所示:
def group = students.groupBy { def student ->
return student.value.score >= 60 ? ‘及格’ : ‘不及格’
}
5)、findAll 方法
它有两个参数,findAll 会将 Key 和 Value 分别传进 去。并且,如果 Closure 返回 true,表示该元素是自己想要的,如果返回 false 则表示该元素不是自己要找的。
Range
表示范围,它其实是 List 的一种拓展。其由 begin 值 + 两个点 + end 值表示。如果不想包含最后一个元素,则 begin 值 + 两个点 + < + end 表示。我们可以通过 aRange.from 与 aRange.to 来获对应的边界元素。
如果需要了解更多的数据结构操作方法,我们可以直接查 Groovy API 详细文档 即可。
4、Groovy 面向对象
如果不声明 public/private 等访问权限的话,Groovy 中类及其变量默认都是 public 的。
1)、元编程(Groovy 运行时)
Groovy 运行时的逻辑处理流程图如下所示:
为了更好的讲解元编程的用法,我们先创建一个 Person 类并调用它的 cry 方法,代码如下所示:
// 第一个 groovy 文件中
def person = new Person(name: ‘Qndroid’, age: 26)
println person.cry()
// 第二个 groovy 文件中
class Person implements Serializable {
String name
Integer age
def increaseAge(Integer years) {
this.age += years
}
/**
- 一个方法找不到时,调用它代替
- @param name
- @param args
- @return
*/
def invokeMethod(String name, Object args) {
return “the method is ${name}, the params is ${args}”
}
def methodMissing(String name, Object args) {
return “the method ${name} is missing”
}
}
为了实现元编程,我们需要使用 metaClass,具体的使用示例如下所示:
ExpandoMetaClass.enableGlobally()
//为类动态的添加一个属性
Person.metaClass.sex = ‘male’
def person = new Person(name: ‘Qndroid’, age: 26)
println person.sex
person.sex = ‘female’
println “the new sex is:” + person.sex
//为类动态的添加方法
Person.metaClass.sexUpperCase = { -> sex.toUpperCase() }
def person2 = new Person(name: ‘Qndroid’, age: 26)
println person2.sexUpperCase()
//为类动态的添加静态方法
Person.metaClass.static.createPerson = {
String name, int age -> new Person(name: name, age: age)
}
def person3 = Person.createPerson(‘renzhiqiang’, 26)
println person3.name + " and " + person3.age
需要注意的是通过类的 metaClass 来添加元素的这种方式每次使用时都需要重新添加,幸运的是,我们可以在注入前调用全局生效的处理,代码如下所示:
ExpandoMetaClass.enableGlobally()
// 在应用程序初始化的时候我们可以为第三方类添加方法
Person.metaClass.static.createPerson = { String name,
int age ->
new Person(name: name, age: age)
}
2)、脚本中的变量和作用域
对于每一个 Groovy 脚本来说,它都会生成一个 static void main 函数,main 函数中会调用一个 run 函数,脚本中的所有代码则包含在 run 函数之中。我们可以通过如下的 groovyc 命令用于将编译得到的 class 文件拷贝到 classes 文件夹下:
// groovyc 是 groovy 的编译命令,-d classes 用于将编译得到的 class 文件拷贝到 classes 文件夹 下
groovyc -d classes test.groovy
当我们在 Groovy 脚本中定义一个变量时,由于它实际上是在 run 函数中创建的,所以脚本中的其它方法或其他脚本是无法访问它的。这个时候,我们需要使用 @Field 将当前变量标记为成员变量,其示例代码如下所示:
import groovy.transform.Field;
@Field author = JsonChao
四、文件处理
1、常规文件处理
1)、读文件
eachLine 方法
我们可以使用 eachLine 方法读该文件中的每一行,它唯一的参数是一个 Closure,Closure 的参数是文件每一行的内容。示例代码如下所示:
def file = new File(文件名)
file.eachLine{ String oneLine ->
println oneLine
}
def text = file.getText()
def text2 = file.readLines()
file.eachLine { oneLine, lineNo ->
println “${lineNo} ${oneLine}”
}
然后,我们可以使用 ‘targetFile.bytes’ 直接得到文件的内容。
使用 InputStream
此外,我们也可以通过流的方式进行文件操作,如下代码所示:
//操作 ism,最后记得关掉
def ism = targetFile.newInputStream()
// do sth
ism.close
使用闭包操作 inputStream
利用闭包来操作 inputStream,其功能更加强大,推荐使用这种写法,如下所示:
targetFile.withInputStream{ ism ->
// 操作 ism,不用 close。Groovy 会自动替你 close
}
2)、写文件
关于写文件有两种常用的操作形式,即通过 withOutputStream/withInputStream 或 withReader/withWriter 的写法。示例代码如下所示:
通过 withOutputStream/、withInputStream copy 文件
def srcFile = new File(源文件名)
def targetFile = new File(目标文件名) targetFile.withOutputStream{ os->
srcFile.withInputStream{ ins->
os << ins //利用 OutputStream 的<<操作符重载,完成从 inputstream 到 OutputStream //的输出
}
}
通过 withReader、withWriter copy 文件
def copy(String sourcePath, String destationPath) {
try {
//首先创建目标文件
def desFile = new File(destationPath)
if (!desFile.exists()) {
desFile.createNewFile()
}
//开始copy
new File(sourcePath).withReader { reader ->
def lines = reader.readLines()
desFile.withWriter { writer ->
lines.each { line ->
writer.append(line + “\r\n”)
}
}
}
return true
} catch (Exception e) {
e.printStackTrace()
}
return false
}
此外,我们也可以通过 withObjectOutputStream/withObjectInputStream 来保存与读取 Object 对象。示例代码如下所示:
保存对应的 Object 对象到文件中
def saveObject(Object object, String path) {
try {
//首先创建目标文件
def desFile = new File(path)
if (!desFile.exists()) {
desFile.createNewFile()
}
desFile.withObjectOutputStream { out ->
out.writeObject(object)
}
return true
} catch (Exception e) {
}
return false
}
从文件中读取 Object 对象
def readObject(String path) {
def obj = null
try {
def file = new File(path)
if (file == null || !file.exists()) return null
//从文件中读取对象
file.withObjectInputStream { input ->
obj = input.readObject()
}
} catch (Exception e) {
}
return obj
}
2、XML 文件操作
1)、获取 XML 数据
首先,我们定义一个包含 XML 数据的字符串,如下所示:
final String xml = ‘’’
然后,我们可以 使用 XmlSlurper 来解析此 xml 数据,代码如下所示:
def xmlSluper = new XmlSlurper()
def response = xmlSluper.parseText(xml)
// 通过指定标签获取特定的属性值
println response.value.books[0].book[0].title.text()
println response.value.books[0].book[0].author.text()
println response.value.books[1].book[0].@available
def list = []
response.value.books.each { books ->
//下面开始对书结点进行遍历
books.book.each { book ->
def author = book.author.text()
if (author.equals(‘李刚’)) {
list.add(book.title.text())
}
}
}
println list.toListString()
2)、获取 XML 数据的两种遍历方式
获取 XML 数据有两种遍历方式:深度遍历 XML 数据 与 广度遍历 XML 数据,下面我们看看它们各自的用法,如下所示:
深度遍历 XML 数据
Sluper = new XmlSlurper()
def response = xmlSluper.parseText(xml)
// 通过指定标签获取特定的属性值
println response.value.books[0].book[0].title.text()
println response.value.books[0].book[0].author.text()
println response.value.books[1].book[0].@available
def list = []
response.value.books.each { books ->
//下面开始对书结点进行遍历
books.book.each { book ->
def author = book.author.text()
if (author.equals(‘李刚’)) {
list.add(book.title.text())
}
}
}
println list.toListString()
2)、获取 XML 数据的两种遍历方式
获取 XML 数据有两种遍历方式:深度遍历 XML 数据 与 广度遍历 XML 数据,下面我们看看它们各自的用法,如下所示: