上一节，咱们了解了Gradle的基础编程知识1，涉及字符串/数组/集合等；java
本章咱们将学习系列的基础编程知识2，如：列表/map/数组/范围等经常使用数据结构，对象使用，文件操做等编程
（1）列表的定义：json
def list = [1, 3, -1, -2]
printlin list.class
复制代码
（2）列表的排序：数组
printlin "默认排序规则，排序后：" + list.sort().toListString()
printlin "指定排序规则，排序后：" + list.sort {a, b ->
a == b ? 0 :Math.abs(a) < Math.abs(b) ? 1 : -1
}.toListString()
复制代码
（3）列表的查找：markdown
//打印偶数
printlin list.find { return it % 2 == 0 }.toListString()
//打印基数
printlin list.find { return it % 2 != 0 }.toListString()
//打印all
printlin list.toListString()
//任意偶数
printlin list.any { return it % 2 == 0 }.toListString()
//全部基数
printlin list.every() { return it % 2 != 0 }.toListString()
复制代码
定义：数据结构
def arr = [1, 2, 3, 4] as int[]
int[] arr2 = [1, 2, 3, 4]
复制代码
（1）定义：app
def map = [
red : '0xffff',
blue: '0xooo'
]
复制代码
（2）索引：ide
printlin map['red']
printlin map.red
复制代码
（3）添加元素：post
map.add = '0xccc'
printlin map.toMapString()
复制代码
（4）遍历：学习
def map2 = [
1: [age: '16', name: 'davi'],
2: [age: '15', name: 'xiaoming'],
3: [age: '7', name: 'xiaohong']
]
map2.each { obj ->
printlin "each的遍历：key is ${obj.key}, value is ${obj.value}"
}
复制代码
（5）查找：
printlin "年龄为16的：" + map2.find { def o -> return o.value.age == 16 }.toMapString()
printlin "年龄大于0的：" + map2.findAll { def o -> return o.value.age > 0 }.toMapString()
printlin "年龄大于0的数量有：" + map2.count { def o -> return o.value.age > 0 }.toMapString()
printlin "年龄大于7的同窗名称有：" + map2.findAll {
def o -> return o.value.age > 7
}.collect {
return it.value.name
}.toMapString()
复制代码
（1）定义：
def rang = 1..10
println "范围的第一个元素：" + rang[0]
println "范围的开始元素：" + rang.from
println "范围的最后一个元素：" + rang.to
复制代码
（2）遍历
rang.each {
println "循环：" + it
}
复制代码
（3）结合case应用：
首先定义一个方法
String rangResult(Number number) {
def result = "默认值"
switch (number) {
case 0..<60:
result = "不及格"
break
case 60..<70:
result = "及格"
break
}
return result
}
复制代码
而后方法的使用
println "成绩：" + rangResult(65)
复制代码
（1）定义：
class Person implements IAction, GroovyObject, Serializable {
String name int age def incAge() {
return name + age
}
@Override
void eat() {
println "-- eat --"
}
def invokeMethod(String methodName, Object param) {
return "methodName is : ${methodName}, param is : ${param}"
}
}
复制代码
（2）对象的访问
def p = new Person(name: "davi", age: 18)
println "name is : ${p.name}"
println "from obj，name is : ${p.getName()}"
println "age is : ${p.age}"
复制代码
（3）对象的元编程思想
在java中，若是类中方法没有，那边会直接编译报错；
可是在groovy中，没有方法编译是不会报错的，只有在运行时候才会去执行一个机制，这个机制以下：
类中方法是否存在？
（1）存在，直接调用
（2）不存在，MetaClass中是否有此方法
（2.1）存在，直接调用
（2.2）不存在，是否重写类methodMissing方法
（2.2.1）有重写，直接调用
（2.2.2）没有重写，再看下是否重写了invokeMethod方法
（2.2.2.1） 有重写，直接调用
（2.2.2.2） 没有重写，throw MissingMethodException异常
复制代码
（4）动态添加属性
Person.metaClass.sex = 'boy'
def p1 = new Person(name: "davi", age: 18)
printlin "动态添加的属性sex为：" + p1.sex
复制代码
（5）动态添加方法
Person.metaClass.sexPrint = { -> printlin "sexPrint 里面的sex = " + sex }
def p2 = new Person(name: "davi", age: 18)
p2.sexPrint()
复制代码
（6）动态添加属性/方法的好处：
正常来讲，咱们须要在第三方库的一个类里面添加属性或者方法，通常会选择继承，而后添加方法；
可是，若是类是一个final类，那么继承的方式就不行了
采用groovy的运行时注入属性/方法等能够实现
（1）对象转json字符串
def list = [
new Person(name: 'davi1', age: 18),
new Person(name: 'davi2', age: 19)
]
println "对象转json字符串：" + JsonOutput.prettyPrint(JsonOutput.toJson(list))
复制代码
（2）json 转对象
def json = ''' { "name": "davi", "age": "18" } '''
def j = new JsonSlurper()
println "json 转对象 ： name is " + j.parseText(json).name
复制代码
（1）xml解析
def xml = ''' <note> <to>George</to> <from>John</from> <heading>Reminder</heading> </note> '''
def xmlP = new XmlSlurper()
def xmlObj = xmlP.parseText(xml)
println "xml to is " + xmlObj.note
复制代码
（2）xml生成
经过以下代码：
def sw = new StringWriter()
def xmlBuilder = new MarkupBuilder(sw)
xmlBuilder.langs(type: 'cur') {
language(flavor: 'static', 'kotlin')
}
println "my xml is : " + sw
复制代码
生成以下格式的xml：
<langs type = 'cur'>
<language flavor = 'static'>kotlin</language>
</langs>
复制代码
（1）基本操做
//定义
String sourcePath = "你的文件路径"
def file = new File(sourcePath)
//一行行读取
file.eachLine { line ->
println "eachLine模式读取每一行：" + line
}
//读取文件部份内容
def reader = file.withReader { render ->
char[] buffer = new char[100]
render.read(buffer)
return buffer
}
println "读取文件部份内容 : " + reader
复制代码
（2）文件拷贝
static def copy(String sourcePath, String desc) {
try {
def descFile = new File(desc)
if (!descFile.exists()) {
descFile.createNewFile()
}
//开始拷贝
new File(sourcePath).withReader { render ->
def lines = render.readLines()
descFile.withWriter { writer ->
//一行行写入
lines.each { line ->
writer.append(line + "\r\n")
}
}
}
//ok
return true
} catch (Exception e) {
e.printStackTrace()
}
//default
return false
}
复制代码
（3）对象存储到文件
static def saveObj(Object o, String path) {
try {
def descFile = new File(path)
if (!descFile.exists()) {
descFile.createNewFile()
}
descFile.withObjectOutputStream { out ->
out.writeObject(o)
}
//ok
return true
} catch (Exception e) {
e.printStackTrace()
}
//default
return false
}
复制代码
（4）从文件中读取对象
static def readObj(String path) {
def obj = null
try {
def descFile = new File(path)
if (descFile == null || !descFile.exists()) {
return null
}
descFile.withObjectInputStream { inputStream ->
obj = inputStream.readObject()
}
return obj
} catch (Exception e) {
e.printStackTrace()
}
//default
return null
}
复制代码
哈哈，该篇就写到这里（一块儿体系化学习，一块儿成长）