Gradle构建-Groovy基础

接下来我们了解下Gradle所使用的Groovy语言

1.字符串

我们在Gradle中经常看到代码的结尾都没有分号，这是因为在Groovy中，结尾分号不是必须的，这是Groovy语法的特性。

单引号和双引号都可以定义一个字符串常量（Java中单引号代表定义一个字符），但是双引号可以做表达式运算

exp

task printStringVar << {
    def name = "张三"
    print('单引号的变量计算:${name}')//String类型
    print("双引号的变量计算:${name}")//GString类型，通过自动调用toString()返回
    
}

运行./gradlew printStringVar 输出结果

单引号的变量计算:${name}
双引号的变量计算:张三

通过这种嵌套规则，免去了Java中繁琐的+号了 ，只有一个变量可以免去花括号比如$name

Groovy整型和Java类似，如果使用def声明类型，那么整型是可变的，它会通过数值的大小来匹配类型。并且数值可以用_下划线对数字分组

• byte
• char
• short
• int
• long
  *Java.lang.BigInteger
  浮点型 float double java.lang.BigDecimal
  Groovy没有明确的字符类型，通过以下三种方式可以创建

char c = 'A' //声明类型为char
def c2 = 'B' as char //通过as将类型强制指定为char
def c3 = (char)'C' //通过类型转换

2.集合

Groovy完全兼容Java集合，并进行了拓展，使得声明，迭代，查找集合等操作变得非常easy。常见的集合有List、Set、Map、Queue

• 2.1 List
  Java定义List需要实现一个List接口的类，而Groovy就非常简单,

task printList << {
    def numList = [1,2,3,4,5]
    println numList.getClass().name
    println numList[1] // 和Java一样 访问第二个元素
    println numList[-1] //  访问最后一个元素
    println numList[-2] //  访问倒数第二个元素
    println numList[1..3] //  访问第二到第四个元素
//可以使用<<向list末尾追加元素。
numList << 6   
  numList.each {
        print it  // 迭代输出
    }
assert  [1,7,8].grep(numList ) ==[1] // 取交集
}
 for (i in numList[3 ..5]) { //迭代集合的第4-6个
        print i
    }

输出结果

Task :printList
java.util.ArrayList
2
5
4
[2, 3, 4]
123456
456

Groovy中，负下标表示从右开始，-1表示倒数第一个，以此类推 。中间通过两个..可以表示范围下标索引。
通过each表示迭代，通过一个闭包作为参数 it 表示正在迭代的元素，后面会详细讲解闭包的it用法

List中元素可以是不同类型,Groovy定义数组的方式和定义list的方式一样，只不过声明时需要制定类型，或者通过as来强制制定类型为Array。Groovy不支持Java数组的初始化方式。

String[] arrStr = ['Ananas', 'Banana', 'Kiwi']  
 
assert arrStr instanceof String[]    
assert !(arrStr instanceof List)
 
def numArr = [1, 2, 3] as int[]    
 
assert numArr instanceof int[]       
assert numArr.size() == 3
 
//多维数组
 
def matrix3 = new Integer[3][3]         
assert matrix3.size() == 3
Integer[][] matrix2                     
matrix2 = [[1, 2], [3, 4]]
assert matrix2 instanceof Integer[][]

List 实现快速排序

def quickSort(list){
    if(list.size() <2)
        return list
     def pivot = list[list.size().intdiv(2)]
     def left = list.findAll{item->item<pivot}
     def middle =  list.findAll {item->item==pivot}
     def right = list.findAll{item->item>pivot}
     return (quickSort(left)+middle+quickSort(right))
}
assert quickSort([]) == []
assert quickSort([1]) == [1]
assert quickSort([1,2]) == [1,2]
assert quickSort([2,1,3]) == [1,2,3]
assert quickSort([1.0f,'a',10,null]) == [null,1.0f,10,'a']
assert quickSort('Karin and Dierk') == '  DKaadeiiknnrr'.toList()

• 2. Map
     Map跟Java一样 都是接受一个 K：V键值对 ,Groovy穿件的map默认类型为java.util.LinkedHashMap

task printlnMapBase << {
    def map = [ 'w': 1280, 'h':1920 ]
    println map['w']
    println map.w

    map.each {
        println "Key:${it.key},Value ${it.value}"
    }
 
def key = 'name'
def person = [key: 'Guillaume']     // key实际上为"key"
 
assert !person.containsKey('name')   
assert person.containsKey('key')  
 
person = [(key): 'Guillaume']    // key实际上为"name"
 
assert person.containsKey('name')    
assert !person.containsKey('key')
}

Map中通过[key]或.key的方式来获取key对应的value。如果key不存在，则返回null.
当我们使用数字作为key时，这个数字可以明确的认为是数字，并不是Groovy根据数字创建了一个字符串。但是如果以一个变量作为key的话，需要将变量用()包裹起来，否则key为变量，而不是变量所代表的值。

---

引用标识符是.(dot)后的表达式。比如说name是person.name的一部分，那么我们可以通过person."name"或者person.'name'来引用它。这点与Java不同，Java不允许这种格式的引用。eg:

def map = [:]
 
map."an identifier with a space and double quotes" = "ALLOWED"
map.'with-dash-signs-and-single-quotes' = "ALLOWED"

assert map."an identifier with a space and double quotes" == "ALLOWED"
assert map.'with-dash-signs-and-single-quotes' == "ALLOWED"

• 3.方法
  Groovy 中方法括号是可以省略的（我们一般都省略）,甚至返回值return都不用写

    assert 3 == method1(1,2)
    def value = method1 1,2
    assert value == 3

def method1(int a, int b) {
    println a+b
    a+b
}

• 4. 闭包（closure）

在Android 的build.gradle 大量使用闭包closure

之前说的一个参数可以省略 ，通过it 返回迭代

如果是map的话，返回key 和value 一共两个参数 ，那么就不能使用it，需要显示声明出来。

    eachMap({ k,v ->
        println "${k} is ${v}"
    })

def eachMap(closure) {
    def map = ["name":"zhangsan","age":"18"]
    map.each {
        closure(it.key,it.value)
    }
}
输出：
name is zhangsan
age is 18

Groovy的闭包有thisObject、owner、delegate 三个属性

thisObject 默认就是上线文对象来处理闭包中调用的方法

委托（delegate）
closure的上下文是可以改变的，通过Closure#setDelegate()。这个特性非常有用：

def myClosure = {println myVar} //I'm referencing myVar from MyClass class
MyClass m = new MyClass()
myClosure.setDelegate(m)
myClosure()

class MyClass {
    def myVar = 'Hello from MyClass!'
}

output: Hello from MyClass!

在 《Android Gradle权威指南》 看到的委托实例

def person(Closure<Person> closure) { //Closure是groovy.lang下的一个抽象类 ，泛型为Person
    Person p = new Person()
    closure.delegate = p
    closure.setResolveStrategy(Closure.DELEGATE_FIRST)
    closure(p)
}

class Person {
    String name
    String age
    def dumpPerson() {
        println "name is ${name},age is ${age}"
    }
}

task hello {
    person {
        name = "momo"
        age = "18"
        dumpPerson()
    }
}