Groovy基础语法（自己需要用到的）

Groovy是什么

Groovy是一种动态语言。这种语言比较有特点，它和Java一样，也运行于Java虚拟机中。恩？？对头，简单粗暴点儿看，你可以认为Groovy扩展了Java语言。比如，Groovy对自己的定义就是：Groovy是在 java平台上的、 具有像Python， Ruby 和 Smalltalk 语言特性的灵活动态语言， Groovy保证了这些特性像 Java语法一样被 Java开发者使用。

除了语言和Java相通外，Groovy有时候又像一种脚本语言。前文也提到过，当我执行Groovy脚本时，Groovy会先将其编译成Java类字节码，然后通过Jvm来执行这个Java类。

实际上，由于Groovy Code在真正执行的时候已经变成了Java字节码，所以JVM根本不知道自己运行的是Groovy代码。

下面我们将介绍Groovy，不会过多讨论Groovy中细枝末节的东西，而是把知识点集中在以后和Gradle打交道时一些常用的地方上。

Groovy语法

一些前提知识

Groovy注释标记和Java一样，支持//或者/**/
Groovy语句可以不用分号结尾。Groovy为了尽量减少代码的输入，确实煞费苦心
Groovy中支持动态类型，即定义变量的时候可以不指定其类型。Groovy中，变量定义可以使用关键字def。注意，虽然def不是必须的，但是为了代码清晰，建议还是使用def关键字
   def variable1 = 1   //可以不使用分号结尾
   def varable2 = "I ama person"
   int y =1 //变量定义时，也可以直接指定类型
   def  int x = 1  
函数定义时，参数的类型也可以不指定。比如
String testFunction(arg1,arg2){//无需指定参数类型
  ...
}
除了变量定义可以不指定类型外，Groovy中函数的返回值也可以是无类型的。比如：
//无类型的函数定义，必须使用def关键字
def  nonReturnTypeFunc(){
    last_line   //最后一行代码的执行结果就是本函数的返回值
}
//如果指定了函数返回类型，则可不必加def关键字来定义函数
String getString(){
   return"I am a string"
}

其实，所谓的无返回类型的函数，我估计内部都是按返回Object类型来处理的。毕竟，Groovy是基于Java的，而且最终会转成Java Code运行在JVM上

函数返回值：Groovy的函数里，可以不使用returnxxx来设置xxx为函数返回值。
如果不使用return语句的话，则函数里最后一句代码的执行结果被设置成返回值。比如
//下面这个函数的返回值是字符串"getSomething return value"
def getSomething(){
     "getSomething return value" //如果这是最后一行代码，则返回类型为String
      1000//如果这是最后一行代码，则返回类型为Integer
}

注意，如果函数定义时候指明了返回值类型的话，函数中则必须返回正确的数据类型，否则运行时报错。如果使用了动态类型的话，你就可以返回任何类型了。

Groovy对字符串支持相当强大，充分吸收了一些脚本语言的优点：
1  单引号''中的内容严格对应Java中的String，不对$符号进行转义
   def singleQuote='I am $ dolloar'  //输出就是I am $ dolloar
2  双引号""的内容则和脚本语言的处理有点像，如果字符中有$号的话，则它会$表达式先求值。
   def doubleQuoteWithoutDollar = "I am one dollar" //输出 I am one dollar
   def x = 1
   def doubleQuoteWithDollar = "I am $x dolloar" //输出I am 1 dolloar
3 三个引号'''xxx'''中的字符串支持随意换行 比如
   def multieLines = ''' begin
     line  1
     line  2
     end '''
最后，除了每行代码不用加分号外，Groovy中函数调用的时候还可以不加括号。比如：
println("test") ---> println"test"
注意，虽然写代码的时候，对于函数调用可以不带括号，但是Groovy经常把属性和函数调用混淆。比如
def getSomething(){
  "hello"
}

如果一个类中有名为xxyyzz这样的属性（其实就是成员变量,Groovy会自动为它添加getXxyyzz和setXxyyzz两个函数，用于获取和设置xxyyzz属性值，get和set后第一个字母是大写的。

变量

基本数据类型

byte, short, int, long, float, double, char

容器类型

• List：链表，其底层对应Java中的List接口，一般用ArrayList作为真正的实现类。
• Map：键-值表，其底层对应Java中的LinkedHashMap。
• Range：范围，是List的一种拓展。

代码展示：

1. List类

变量定义：List变量由[]定义，比如
def aList = [5,'string',true] //List由[]定义，其元素可以是任何对象
变量存取：可以直接通过索引存取，而且不用担心索引越界。如果索引超过当前链表长度，List会自动
往该索引添加元素
assert aList[1] == 'string'
assert aList[5] == null //第6个元素为空
aList[100] = 100 //设置第101个元素的值为10
assert aList[100] == 100
那么，aList到现在为止有多少个元素呢？
println aList.size  ===>结果是101

其中 assert 用来测试逻辑是否正确。

assert 1==2

会报告有逻辑错误。

2. Map类

// 变量定义：Map变量由[:]定义，比如
def aMap = ['key1':'value1','key2':true]
// Map由[:]定义，注意其中的冒号。冒号左边是key，右边是Value。
// key必须是字符串，value可以是任何对象。另外，key可以用''或""包起来，也可以不用引号包起来。比如
def aNewMap = [key1:"value",key2:true]
// 其中的key1和key2默认被处理成字符串"key1"和"key2"
// 不过Key要是不使用引号包起来的话，也会带来一定混淆，比如
def key1="wowo"
def aConfusedMap=[key1:"who am i?"]
// aConfuseMap中的key1到底是"key1"还是变量key1的值“wowo”？显然，答案是字符串"key1"。
// 如果要是"wowo"的话，则aConfusedMap的定义必须设置成：
def aConfusedMap=[(key1):"who am i?"]
// Map中元素的存取更加方便，它支持多种方法：
println aMap.keyName    // 这种表达方法好像key就是aMap的一个成员变量一样
println aMap['keyName'] // 这种表达方法更传统一点
aMap.anotherkey = "i am map"  // 为map添加新元素

3. Range类

def aRange = 1..5 // <==Range类型的变量 由begin值+两个点+end值表示左边这个aRange包含1,2,3,4,5这5个值
//如果不想包含最后一个元素，则
def aRangeWithoutEnd = 1..<5  // 包含1,2,3,4这4个元素
println aRange.from
println aRange.to

Range并没有有from和to这两个属性，但是却有getFrom和getTo这两个函数。就是Gradle的“潜规则”，如果一个类中有名为xxyyzz这样的属性（其实就是成员变量），Groovy会自动为它添加getXxyyzz和setXxyyzz两个函数，用于获取和设置xxyyzz属性值。

闭包

闭包，英文名Closure，是Groovy非常重要的一个概念。
定义格式为：

def xxx = {paramters -> code} //或者 def xxx = {无参数，纯code} 这种case不需要->符号

代码展示：

def mClosure = {//闭包是一段代码，所以需要用花括号括起来..
    String param1, int param2 ->  //这个箭头很关键。箭头前面是参数定义，箭头后面是代码
    println "this is code" // 这是代码，最后一句是返回值，
   //也可以使用return，和Groovy中普通函数一样
}

// 调用通过闭包对象.call(参数) 或者 闭包对象(参数)
mClosure.call("this is string",100)  //或者
mClosure("this is string", 100)

如果闭包没定义参数的话，则隐含有一个参数，这个参数名字叫it，和this的作用类似。it代表闭包的参数。

闭包使用注意点：

当函数的最后一个参数是闭包的话，可以省略圆括号。

闭包在Groovy中大量使用，很多类定义的函数最后一个参数都是一个闭包。

def testClosure(int a1,String b1, Closure closure){
      //dosomething
     closure() //调用闭包
}
// 那么调用的时候，就可以免括号！
testClosure (4, "test", {
   println"i am in closure"
} ) 

在定义任务经常看到

task hello {
    doLast {
        println "hello world "
    }
}

// doLast参数唯一并且是闭包
// 完整代码是下方
task hello {
    doLast({
        println "hello world "
    })
}

文件IO

Groovy的I/O操作是在原有Java I/O操作上进行了更为简单方便的封装，并且使用Closure来简化代码编写。

1. 读文件

Groovy中，文件读操作简单到令人发指：
读该文件中的每一行：eachLine的唯一参数是一个Closure。Closure的参数是文件每一行的内容。

def targetFile = new File(文件名) 
 targetFile.eachLine{ 
   StringoneLine ->
    printlnoneLine    
} 

 targetFile.getBytes()  <==文件内容一次性读出，返回类型为byte[] // 注意前面提到的getter和setter函数，这里可以直接使用targetFile.bytes 

// 转换成流InputStream.InputStream
def ism =  targetFile.newInputStream()
//操作ism，最后记得关掉
ism.close

// 闭包操作inputStream 以后在Gradle里会常看到这种搞法
 targetFile.withInputStream{ ism ->
   // 操作ism. 不用close。Groovy会自动替你close
}

Groovy I/O操作相关类的SDK地址

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

2. 写文件

def srcFile = new File(源文件名)
def targetFile = new File(目标文件名)
targetFile.withOutputStream{ os->
  srcFile.withInputStream{ ins->
      os << ins   //利用OutputStream的<<操作符重载，完成从inputstream到OutputStream
       //的输出
   }
}

<< 其实调用的leftShift方法。