Groovy使用指南

groovy简介
groovy类的基本特点
在java项目中引入groovy
定义变量
groovy中的常见类型
- 字符串
- 数组、列表 list
- 元祖 tuple
- 映射 | 字典 | map
范围运算符 ..
切片
方法定义、调用
闭包
类的定义
IO
- 控制台输出
- File类
- 文件读
- 文件写
- 遍历文件树
- 说明
单元测试

groovy简介

Groovy是一种基于 JVM 的编程语言，结合了 python、ruby 和 Smalltalk 的许多强大的特性，面向对象，Groovy 可以与 Java 代码很好地结合，可以直接在groovy中写java代码，既可以用于面向对象编程，又可以用作纯粹的脚本语言。

groovy的主要特点

同时支持静态、动态类型
支持各种标记语言，比如原生支持xml、html
支持闭包
可以在groovy中直接写java代码，可以直接使用现有的java类库，相比于java，groovy更加简洁；
groovy语法和java非常相似，易于java开发者掌握。

groovy类的基本特点

一个.groovy文件中可以包含多个public类，不要求public类的类名月文件名相同；
默认访问修饰符是public，如果类、成员使用public修饰，可以缺省public；
支持动态类型，不管是变量还是方法返回类型，都不需要声明类型；
语句末尾的分号不是必需的，可以省略；
注释和java相同。

groovy 默认会导入以下包、类，无需 import 显式导入

import java.lang.*
import java.util.*
import java.io.*
import java.net.* import java.math.BigInteger
import java.math.BigDecimalimport groovy.lang.*
import groovy.util.*

groovy在 java.lang.Object 的基础上进行了扩展，相比于java的Object类，groovy中的Object类具有更多的方法。

在java项目中引入groovy

很少直接用groovy写一整个大项目，一般是搭配java使用，用来写部分模块、服务、脚本。

pom.xml

<dependency><groupId>org.codehaus.groovy</groupId><artifactId>groovy-all</artifactId><version>3.0.9</version><type>pom</type>
</dependency>

定义变量

groovy自动导入了 java.lang，可以使用java的数据类型

//可以使用具体类型，也可以声明为 def 任意类型、动态类型int x
int y = 5def x
def y = 5

在groovy中，对于自带类型，== 相当于 equals

//true 通过
assert new String("xxx") == new String("xxx")

groovy中的常见类型

字符串

groovy的字符串可以用单引、双引、三引定义，单引中可以使用双引，双引中可以使用单引，三引中可以使用单、双引。

三引类似 html 的 <pre> 标签，可以保证内容格式不变。

//单双引
def str1 = 'hello world'
def str2 = "hello world"//三引
def str3 = '''hello world'''
def str4 = """hello world"""

模板字符串

def user = new User(1, "chy")//字符串内可以通过 ${} 引用变量，可以访问属性、调用方法
println("user: ${user}")
println("name: ${user.name}")
println("name：${user.getName()}")//直接访问对象本身或属性时，可以缺省{}，调用方法时则不能缺省{}
println("user：$user")
print("name：$user.name")

双引中的 $表达式才会被解析，单引、三引中的 $表达式会被当做普通字符串处理。

与java不同，groovy中的字符串可通过下标直接索引

def str = "hello world"//java中可以通过 charAt() 来获取指定位置的字符，但不能直接 [n] 以数组下标方式直接操作
//groovy可以以[n] 数组下标方式来获取字符串指定位置的字符，但不能通过 [n] 来给字符串指定位置赋值
//数组则可以通过 [n] 直接取值、赋值
println str[0]//取 [0,4] 上的字符串
println(str[0..4])//先取 [0,4] 上的字符串，再将字符串反序排列
println(str[4..0])//将字符串重复指定次数，java中没有此操作
println(str * 3)

数组、列表 list

在 groovy 中

大括号是留给闭包（closure）使用的，数组、列表都使用中括号进行定义；
数组、列表的元素都有序，可通过下标索引；
区别：数组元素类型相同，列表元素类型可以不同。

//java中定义数组
int[] array = {1, 2, 3};//groovy中定义数组
int[] array = [1, 2, 3]//groovy中定义列表
def list = [1, 2, "zhangsan"]
//支持嵌套
def list3 = [1, 2, ["zhangsan", "lisi"]]

列表常用方法

def list1 = [1, 2]
def list2 = [3, 4]//在指定位置添加元素，index范围只能是 [0, size]
list1.add(0, "lisi")
//缺省index时默认添加到末尾
list1.add("wangwu")//add是把参数作为一个元素进行添加，参数是集合时，会整个集合作为一个元素添加
list1.add(list2)
//如果要将其它集合中的元素都添加到当前集合汇总，可以用 plus 或 + ，返回副本
list1 = list1 + list2
// list1 = list1.plus(list2)//添加是add、plus（+），移除是remove、minus（-），使用方式相同，add => remove，plus => minus//元素反序排列，返回副本
list1 = list1.reverse()//元素排序，直接修改的原list。默认自然排序，可自定义排序规则
list1.sort()

列表的遍历

def list = ["zhangsan", "lisi", "wangwu"]//传统for循环方式
for (def ele : list) {println(ele)
}
for (i in 0..<list.size()) {println(list[i])
}//lambda表达式
list.each { ele -> println(ele) }//闭包
list.forEach({ ele -> println(ele) })
list.iterator().forEachRemaining({ ele -> println(ele) })

元祖 tuple

tuple是一种特殊的list，和list一样元素有序、类型可以不同，可以通过下标来访问。
与list的区别：不能增删、修改元素（引用类型可以修改内部属性值，但不能修改引用本身），否则会抛出 UnsupportedOperationException。
IDE代码提示中有 add()、remove() 之类的方法，但那是list的方法，tuple实际是不能使用的。

//Tuple 元素数量不限
def tuple = new Tuple(10, "zhangsan", true, new Person())//可以通过下标来访问
println tuple.get(0)
println tuple[0]
println tuple[0..2]//Tuple 1~9，元素最多只能为指定数量，eg. Tuple1 元素最多1个、最少0个
def tuple1 = new Tuple1(10)
println tuple1.firstdef tuple2 = new Tuple2(10, "zhangsan")
println tuple2.seconddef tuple3 = new Tuple3(10, "zhangsan", true)
println tuple3.third

映射 | 字典 | map

映射也叫作字典、map

def userInfo = ["name": "chy", "age": 20]//更新key对应的value
userInfo.name = "zhangsan"//获取key对应的value
println(userInfo.name)
println(userInfo.get("name"))

转换为实体类

def map = ["id": 1, "name": "chy"]//as转换为指定类型，也可以直接用java格式的 (Person) map
def person = map as Person

范围运算符 …

//[1,10] 总共10个数字
def range1 = 1..10//[1,10) 总共9个数字
def range2 = 1..<10//支持 降序|反序 排列
def range3 = 10..1//支持字符
def range4 = 'A'..'D'

本质是一种特殊的 list，可以使用 list 的操作方式，比如 [index] 访问指定位置的元素。

常用方法

//是否是反序排列
println(range.reverse)
println(range.isReverse())println(range.size())println(range.sum())println(range.contains(1))println(range.get(0))

//获取最小元素，包装类型
println(range.from)
println(range.getFrom())//获取最小元素，基本类型
println(range.fromInt)
println(range.getFromInt())//获取最大元素，包装类型
println(range.to)
println(range.getTo())//获取最大元素，基本类型
println(range.toInt)
println(range.getToInt())//获取首尾元素
println(range.first())
println(range.last())//子区域 [0,5]
def list = range.subList(0, 5)//注意：from、to不是range的首尾元素，而是range中最小、最大的元素

切片

arr、list、tuple、string 都可以用范围运算符进行切片

def list = [1, 2, 3, 4, 5]//[0,1]。相当于subList()，区别在于范围运算符左右都是闭合，subList()是左开右闭
def list1 = list[0..2]//[0,2)
def list2 = list.subList(0, 2)

方法定义、调用

方法可以使用 private、static、final 之类的关键字修饰，缺省访问权限时，默认为 public；
groovy的 main 方法声明与 java 相同，只是默认就是public，缺省了关键字 public。

//显式指定类型
int sum(int a, int b) {return a + b
}//参数可以不指定类型，不指定类型时为 def
def sum(a, b) {return a + b
}//运行时会根据实参确定参数类型，可以实现函数重载
sum(1, 2)
sum("hello", " world")//默认参数：放在形参表末尾，调用时可传可不传
def sum(a, b = 0, c = 0) {return a + b + c
}sum(1)
sum(1, 2)

如果方法要给其他人使用，使用 def 有一个很大的缺点，调用者不知道参数要传什么类型、返回值要传什么类型，所以groovy常用于编写单人开发的模块、脚本，很少成为项目的主体语言。

方法调用可以缺省小括号，构造函数除外

def user = new User(1, "chy")//使用()
println(user.name)
printf("user：%s", user)//不使用()
println user
printf "user：%s", user

运行时分派：对应函数重载，groovy是以运行时实参的实际类型来进行方法调用

int method(String arg) {return 1;
}int method(Object arg) {return 2;
}//虽然实参声明为Object，但实际为String，所以实际调用的是第一个方法
Object o = "Object";
int result = method(o);

闭包

闭包（closure）是一个短的匿名代码块，使用大括号定义

//定义闭包
def closure1 = { println("xxx") }
//执行闭包中的代码块
closure1.call()//可以包含多行代码
def closure2 = {println("xxx")println("yyy")
}

//闭包可以使用参数，像定义方法一样
def closure1 = { param -> println(param) }
closure1.call("xxx")//支持多个参数，多个参数不需要像lambda表达式一样放在小括号中
def closure2 = {param1, param2 -> println(param1 + param2)
}
closure2.call(1, 2)
closure2.call("xxx", "yyyy")//参数可以声明具体的类型
def closure3 = {int param1, int param2 -> println(param1 + param2)
}// -> 后有多行代码时，不需要像lambda表达式一样，放在大括号中
def closure4 = { param1, param2 ->println(param1)println(param2)
}

def file = new File("D:/document/1.txt")//闭包可以作为函数参数
file.withWriter({ write -> write.write("xxx") })
file.withWriter("utf-8", { write -> write.write("xxx") })//如果函数体本身的操作就是调用闭包，可以将闭包写成函数体形式
file.withWriter {write -> write.write("xxx")
}
file.withWriter("utf-8") {write -> write.write("xxx")
}

类的定义

class Person {Integer idString namestatic void main(String[] args) {//使用自动提供的map型参数的构造方法def person1 = new Person(["id": 1, "name": "chy"])//可以缺省[]def person2 = new Person("id": 1, "name": "chy")//或者使用java的mapdef map = new HashMap<String, Object>()map.put("id", 1)map.put("name", "chy")def person3 = new Person(map)}}

1、groovy 的访问权限控制符默认是 public，一般也是使用 public。

2、groovy会自动给 public 型成员（包括static成员）添加 getter、setter 方法，实例成员通过实例访问，静态成员通过类名访问。

可以直接通过属性名访问（实质是调用对应的getter、setter方法），也可以通过getter、setter方法访问，或者通过字符串属性名形式的 getProperty()、setProperty() 方法访问。

3、如果没有给 groovy 类显式提供构造器，在 groovy 中会自动提供无参构造器、map型参数的构造器，java 中调用 groovy 类时，则只提供无参构造器

4、在 groovy 类中使用 lombok 的注解会失效，部分注解可以使用 groovy-all 提供的，如下

@Slf4j
@Builder
@ToString
@EqualsAndHashCode

IO

groovy 自动导入了 java.io，可以使用 java 的 io，也可以使用 groovy 的 io，此处介绍 groovy 的 io。

控制台输出

print(user.name)
println(user.name)
printf("user：%s", user)

File类

groovy 的 File 类是在 java File 类的基础上进行增强，提供了更多、更简便的方法

File file = new File("D:/document", "1.txt")
File file1 = new File("D:/document/1.txt")//获取File对象信息
println(file.name)
println(file.getName())
println(file.isDirectory())

文件读

//获取文本文件的全部内容
def text1 = file.text
def text2 = file.getText()
def text3 = file.getText("uft-8")//获取包含全部内容的字节数组，byte[]
def bytes1 = file.bytes
def bytes2 = file.getBytes()

//逐行遍历
file.eachLine {line -> println(line)
}//闭包可以缺省临时变量，直接使用默认的临时变量名 it
file.eachLine {println(it)
}//可以指定字符集
file.eachLine('utf-8') {println(it)
}//可以携带行号
file.eachLine { line, lineNumber ->println("第${lineNumber}行：$line")
}//收集每一行到list中，一行即一个元素
def list = file.collect()//收集每一行到数组中
def arr = file.collect() as String[]

//可以使用 InputStream。手动关闭
def fis1 = file.newInputStream()
//...
fis1.close()//自动关闭
file.withInputStream {fis2 -> //...
}//也可以使用 Reader
def reader1 = file.newReader()
//...
reader1.close()file.withReader {reader -> //...
}//Reader可以指定字符集
def reader2 = file.newReader("utf-8")
//...
reader1.close()file.withReader("utf-8"){reader -> //...
}

文件写

groovy的写操作，如果指定的文件不存在，都会先自动创建再写入

//文本文件可以直接设置内容
file.text="xxx"
file.setText("xxx")
file.setText("xxx","utf-8")//也可以用 bytes、setBytes() 写入byte[]//都是覆盖：先删除全部原内容，再写入

//可以使用 OutputStream
file.withOutputStream {fos2 -> //...
}//也可以使用Writer。覆盖
file.withWriter { write ->write.write("xxx")
}//追加
file.withWriterAppend { write ->write.write("xxx")
}//Writer可以指定字符集
file.withWriter("utf-8") { writer ->writer.write("xxx")
}file.withWriterAppend("utf-8") {write -> //...
}

//都可以手动关闭def fos1 = file.newOutputStream()
//...
fos1.close()def writer1 = file.newWriter()
//是否是append 追加，默认false 直接覆盖
def writer2 = file.newWriter(true)
def writer3 = file.newWriter("utf-8")
def writer4 = file.newWriter("utf-8", true)
//...
writer1.close()
writer2.close()
writer3.close()
writer4.close()def printWriter1 = file.newPrintWriter()
def printWriter2 = file.newPrintWriter("utf-8")
//...
printWriter1.close()
printWriter2.close()

def src = new File("D:/document/1.txt")
def dest = new File("D:/document/2.txt")//追加也可以用运算符 <<
src << '''Into the ancient pondA frog jumpsWater’s sound!'''//把一个文件的内容拷贝到另一个文件中（复制），<< 都是以追加形式写入的
dest << src.text

遍历文件树

def dir = new File("D:/笔记")//遍历直接子文件、子文件夹，只遍历直接的
dir.eachFile() {file -> println(file.absolutePath)
}//递归遍历所有的文件、文件夹
dir.eachFileRecurse() {file -> println(file.absolutePath)
}//可以筛选类型，FILES 文件、DIRECTORIES 目录，默认为 ALL
dir.eachFile(FileType.DIRECTORIES) {file -> println(file.absolutePath)
}dir.eachFileRecurse(FileType.FILES) { file -> println(file.absolutePath)
}

//eachFile包含了文件、文件夹，eachDir则只包含文件夹//遍历直接子文件夹
dir.eachDir {dir1 -> println(dir1.absolutePath)
}//递归遍历所有的文件夹
dir.eachDirRecurse() {dir1 -> println(dir1.absolutePath)
}

说明

1、闭包可以缺省临时变量，直接使用默认的临时变量名 it，it 即 item 的简写。

2、groovy的自动资源管理

groovy提供的闭包形式的IO操作，实质是对 try…finally 的封装，即使执行时发生了异常，也会自动关闭资源，无需手动关闭。

3、可以使用基于字节的 InputStream、OutputStream，也可以使用基于字符的 Reader、Write，基于字符的IO流都可以指定字符集。

单元测试

继承 GroovyTestCase，方法名以 test 开头，空参，返回值类型 void

import org.junit.Assertclass Test1 extends GroovyTestCase {void testXxx() {def str = "xxx"//groovy的断言assert "xxx1" == str//也可以用junit的断言Assert.assertEquals("xxx", str)}}

可以用 GroovyTestSuite 组装多个要执行的测试类，用 TestRunner 执行批量测试

class AllTest extends GroovyTestCase {void testAll() {//组装要执行的多个测试类def allTest = new GroovyTestSuite()allTest.addTestSuite(Test1.class)allTest.addTestSuite(Test2.class)//执行测试TestRunner.run(allTest)}}