groovy 初探

简介

Groovy 是用于Java虚拟机的一种敏捷的动态语言，它是一种成熟的面向对象编程语言，既可以用于面向对象编程，又可以用作纯粹的脚本语言。

下载安装

下载地址 : http://www.groovy-lang.org/download.html
解压到自定义目录，并配置环境变量
windows环境变量配置：此电脑(右键)--->属性--->高级系统设置--->环境变量--->编辑path变量添加解压路径
linux环境变量配置：打开 /etc/profile在最后添加以下内容即可

export GROOVY_HOME=你的安装路径
export PATH=$GROOVY_HOME/bin:$PATH:.
export GROOVY_HOME
export PATH

完成之后在命令行运行groovy -version命令，即可查看安装groovy的版本信息

特点

完全兼容java,即可以使用java语法编写groovy
Groovy中可以像Java那样写package，然后写类

基本语法

注释：与java相同，//单行注释，/**/多行注释
分号：结尾分号可以省略
单引号：原样输出
双引号：先计算再输出
三引号：原样输出，可以输出换行 '''这里面的内容是原样输出的，可以直接打回车，同样会原样输出'''
变量定义：使用def关键字定义变量，变量类型可以指定，也可以不指定

def i = 0
def str = "字符串"
def double d = 1.0
String str1 = 'this is a test'

变量的作用域：

def var = 1 //定义于run方法中，属于局部变量
var1 = 2//作为一个属性传递于要执行的方法中
@Field var2 = 3 //定义为成员变量

方法定义：

def fun1(){}  //无参方法
def fun2(p1){}  //有参方法，无需指定参数类型
String fun3(){return ""}//有返回值,可以不使用def
def fun4(){1000} //无返回值的，最后一行的执行结果为返回值

方法调用：

println("hello world") //使用括号将参数包起来
println "aa"  //直接使用空格分隔方法和参数
println fun1() //打印方法返回值
fun2 s  //传递参数到自定义方法
fun2 s1,s2 //多个参数传递

条件： 和java语法一致，使用if（条件）{}
循环:

for(i = 0;i<5;i++){println i} //for循环，输出0-4
for(i in 0..5){println i} //for-in循环，输出0-5
for(i in 0..<5){println i} //for-in循环，输出0-5
while(条件){} //while循环,暂不支持do-while循环
4.times { //相当于 for(i = 0;i<5;i++){println i}
    println it  //it为默认变量
}

三目运算： 支持java三目表达式语法，同时可使用groovy语法name?:'aa'表示 name != null ? name : 'aa'
异常： 支持java的异常捕获语法

try{
  print 1 / 0
}catch (e){//不包括Throwable
    e.printStackTrace()
}

switch:

switch (str) {
   case 'a'..'c'://支持多个值
    rate = 1;break
    case 'abc':
    rate = 2;break
    case 'bcd':
    rate = 3;break
    default:
    throw new IllegalArgumentException()
}

数据类型:

包括 java 中的类型
groovy容器：
    list：
        def list = [0,'a',"b",false,new Integer(2)]
        println(list[0])//取值
        println list.size() //长度
        list[10] = 1 // 赋值，前面长度不足补为null
        list<<"123" //添加元素
        println list //打印
    map：
        def map = [a:"a",b:"b","c":"c"]
        println map.size()//长度
        println map.keySet() //所有的key
        println map.values() //所有的value
        println map.a //取值
        println map.c //取值
        map.put("d",'d')//赋值
        def it = map.iterator()
        while(it.hasNext()){//循环遍历
            println it.next()
        }
        println map
    range：
        range = 1..5
        println range
        println range.size()//长度
        range.iterator() //迭代器
        range.get(1)//取值
        range.contains(5)//是否包含5
        range.last()//最后一个
        println range.from //第一个
        println range.to//最后一个

数据类型转换：

s1 = '1'
//String 转成 int
def s2 = s1 as int
//String 转成 Integer
def s3 = s1.asType(Integer)

闭包

定义闭包:

def fun = {
    p->
    println "this is a closure,param is " + p
}

使用闭包：

fun('test') //直接调用
fun.call()
fun.call("test")

参数：

//闭包没定义参数的话，则隐含有一个参数，这个参数名字叫it，和this的作用类似。
def fun2 = {
    it-> //your coding
}

//如果在闭包定义时，采用下面这种写法,表示闭包没有参数,调用时则不能传递参数
def fun3 = {
    -> //your coding
}

//闭包定义多个参数
def a = {
    a,b,c->
        //your coding
}

特性：

//如果方法的最后一个参数是闭包，则可以省略圆括号
def fun(Closure closure){//定义参数为闭包的方法
    closure()
}
//调用参数为闭包的方法
fun {
    println "aa"
}

JSON操作

class Person {//定义Person类
    String name;
    int age;
}
Person person = new Person(); //创建Person类的对象
person.name = "test" //属性复制
person.age = 27 //属性复制
//转换为json
def json = JsonOutput.toJson(person)
println json
//json转换为java（groovy）对象
JsonSlurper jsonSlurper = new JsonSlurper()
Person p = jsonSlurper.parseText(json)
println p.name

IO操作

file = new File("")
file.eachLine {//按行遍历文件
    println it
}
file.eachLine("utf-8") {//按行遍历文件,指定编码格式
    println it
}
file.text//输出文件
file.write("text")//写入文件
file.withPrintWriter {//写入文件
    it.println("test")
}
def out = file.newPrintWriter()
out.println("test")//写入文件
out.close()//关闭流

if (file.isDirectory()){
    //遍历文件夹中文件夹
    file.eachDir {
    println "文件夹："+it.name
    }
    //遍历文件夹中的文件
    file.eachFile {
    println "文件："+ it.name
    }

    //递归遍历目录
    file.eachDirRecurse {
    println it.name
    }
    //递归遍历文件
    file.eachFileRecurse {
    println it.path
    }
}

file.withInputStream {ism->
    // 操作ism. 不用close。Groovy会自动替你close
    ism.eachLine {
    println it  //读取文本
    }
}