数值

groovy 中数字表现为对象，都是Interge的实例

1
2
3
4
5
6
7
graph TD;
	Number-->Byte
	Number-->Interge
	Number-->Double
	Number-->Float
	Number-->Short
	Number-->Long

字符串

可以使用单引号（''），双引号（""）,三引号（''''''）三个单引号

双引号""内可使用${var.field}直接写代码

三引号''''''可写多行换行

1
2
3
4
5
6
7
8
9
10
11
12
13
package primary

class StringDemo {

    static void main(String[] args) {
        def str = '''石头人
vs
托儿索 ''';
        println str
    }

}

输出：

1
2
3
石头人
vs
托儿索

范围

groovy的特殊语法可以用 rang来表示一个范围内的序列

例如

1
2
3
4
5
6
7
8
9
static void main(String[] args) {

       def a = 1..10

       for (i in a)
           println i

   }

输出结果为：

1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

groovy的范围序列由首尾两个值表示，可以包含，也可以排除

  • 1..<10 ：不包含10的序列

  • 'a'..'x'：字符序列

  • 'a'..'B':结果为 (a`_^][ZYXWVUTSRQPONMLKJIHGFEDCB),这种序列顺序是按照ASCII码排列，同时可以降序

    序号 方法 用法 描述
    1 contains() println(b.contains(a)) 包含
    2 get() 获取位置元素,同数组下标一致，从0开始
    3 getFrom() 获取上限
    4 getTo() 获取下限
    5 isReverse() 是否逆序
    6 subList() b.subList(0,2) 截取子序列，有趣的是，序列是逆序的时候，只能获取下限所在的元素

列表

简介

groovy里面的列表形式就是数组，列表里面可以用是不同类型的元素，例如：

1
2
3
4
5
6
7
8
9
10

static void main(String[] args) {

        def list1 = [ 'a',1,[1,new File("/root")],10L]

        for (i in list1) {
            println i
        }

}

结果:

1
2
3
4
a
1
[1, \root]
10

在尾部添加元素：

1
list1.plus('ddd')

等效于：

1
list1 + 'ddd'

同理：

1
2
3
list1.minus('a')
// 等效于
list1 - 'a'

这里取得的是子列表，不会对原列表产生影响，相当于数组对象

常用方法

方法 例子 描述
add() list2.add(1) 将新值添加到列表末尾
remove() remove(‘1’)/remove(1) 删除指定index的元素或者指定元素，有意思的地方在于
当你删除[1]中的元素’1’时，不能通过删除元素的方式，
index的优先级是高于元素的remove,会报错超出数组
get() list2.get(1) 和list2[1]效果一样
pop() list2.pop() 彭，弹出第一个元素，值得一提的是groovy之前，这个函数是删除最后一个元素
完全相反的实现，有点东西

映射

就是map啊，别名有：字典、关联数组巴拉巴拉。就是散列键值对。

1
def m = ['name':"张三",'age':1]

方法和java没啥区别

put，get

时间

用的java.util.Date，没区别，也能用jdk8的LocalDateTime :-P

正则表达式

可以直接作为if表达式的条件

1
2
3
4
 def a = ~'Gro*vy'
if('Groovy'  =~ a){
    println true
}

异常处理

和java一样，毕竟都是jvm :-)

1
2
3
4
5
6
7
8
try {
         def arr = new int[3];
         arr[5] = 5;
      } catch(Exception ex) {
         println("Catching the exception");
}finally{
    
}

面向对象

和java一样

  • 接口
  • 抽象类
  • 内部类
  • 继承多态
  • 泛型

特征

groovy的特征 trait 就是有默认方法，同时有自己参数 的接口，参数和方法都可以被实现类继承,特征之间可以继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package primary

class TraitDemo {

    static void main(String[] args) {
       def marks =   new ManStudent()
        marks.name='marks'
        marks.run()
    }

}

class ManStudent implements Student{

}

trait Student implements people{

    def name

    void run(){
        println( "student ${name} is running")
    }
}

interface people{
    void run();
}

结果为

1
student marks is running

话说，java interface也可以用默认方法

闭包

闭包就是匿名代码块

1
2
3
def a = 'a'
def closer = { println " hello ! ${a} " }
closer.call()

闭包可以调用形参，可以使用变量

1
2
3
4
5
6
def a = 'world'
def closer = { println " hello ! ${a} " }
def closerParam = { param1, pram2 -> println "${param1} ${pram2} " }

closer.call()
closerParam.call("李四", "臧三")

可以作为参数传递

1
2
3
4
5
6
7
8
9
10
static void main(String[] args) {

	def closer = { println " hello ! ${a} " }
	display(closer)
	
}

static void display(closer) {
        closer.call()
}

可以在遍历中使用闭包

1
2
3
4
5
def list = 'a'..'f'
list.each { println it }

def m = ['a': '1', "b": "2"]
m.each { println "${it.key}:${it.value}" }

集合常用的方法

1
2
3
4
5
println list.find { it > 'b' }
println list.findAll { it > 'b' }
println list.every { it > 'b' }
println list.any { it > 'b' }
println list.collect { it + 'b' }

结果为：

1
2
3
4
5
c
[c, d, e, f]
false
true
[ab, bb, cb, db, eb, fb]

find、findAll是过滤，every、any是判断，collect是获取数据转换获取结果集。

注释

单行

多行

1
2
3
4
//

/**
*/