Groovy~Groovy的语法增强

92 阅读 0 评论 61 点赞

我是靠谱客的博主刻苦睫毛膏，这篇文章主要介绍Groovy~Groovy的语法增强，现在分享给大家，希望可以做个参考。

一、Graph

Map.key：查找Map中所有键为key的值，不适用于空值
Map*.key：查找Map中所有键为key的值,适用于空值
Map.collect{it?.a}：查找Map中所有键为key的值，适用于空值

复制代码

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
class FirstTest{
    static void main(String[] args) {
        def listOfMaps = [
                ['a':11,'b':12],
                ['a':21,'b':22]
        ]
        // GPath标记
        println listOfMaps.a
        // 扩展点符号
        println listOfMaps*.a

        listOfMaps = [
                ['a':11,'b':12],
                ['a':21,'b':22],
                null
        ]
        // 适用于空值
        println listOfMaps*.a
        // 等价符号
        println listOfMaps.collect{it?.a}
        // 但这只会收集非空值
        println listOfMaps.a
    }
}

二、扩展运算符

扩展运算符可以用于将集合"内联"到另一个集合中

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class FirstTest{
    static void main(String[] args) {
        println ([
                'z':900,
                *:['a':100,'b':200],
                'a':300
        ])
        // 在map定义中的扩展map符号
        println([
                [*:[3:3,*:[5:5]],7:7]
        ])

        def f = {[1:'u',2:'v',3:'w']}
        println([*:f(),10:'zz'])
        // 函数参数中的扩展map符号
        f = {map -> map.c}
        println (f(*:['a':10,'b':20,'c':30],'e':50))

        f = {m,i,j,k -> [m,i,j,k]}
        // 使用具有混合为命名和命名参数的展开map符号
        println (f('e':100,*[4,5],*:['a':10,'b':20,'c':30],6))
    }
}

三、星号*运算符

*运算符是一个快捷运算符，允许您对集合的所有元素调用方法或属性

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class FirstTest{
    static class Person{
        String name
        int age
    }

    static void main(String[] args) {
        println (['a','few','words']*.size())
        
        def persons = [new Person(name:'Hugo',age:17),new Person(name:'Sandra',age:19)]
        println (persons*.age)
    }
}

四、使用下标运算符切片

可以使用下标表达式将其索引到list，数组和map中。字符串在这种情况下被视为特殊类型的集合

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class FirstTest{
    static void main(String[] args) {
        def text = 'nice cheese gromit!'
        def x = text[2]

        println x
        println x.class

        def sub = text[5..10]
        println sub

        def list = [10,11,12,13]
        def answer = list[2,3]
        println answer
    }
}

可以使用Range提取集合的一部分

复制代码

1
2
3
4
5
6
7
8
class FirstTest{
    static void main(String[] args) {
        def list = 100..200
        def sub = list[1,3,20..25,33]
        println sub
    }
}

下标运算符可用于更新现有集合(对于不可变的集合类型)

复制代码

1
2
3
4
5
6
7
8
class FirstTest{
    static void main(String[] args) {
        def list = ['a','x','x','d']
        list[1..2] = ['b','c']
        println list
    }
}

可以使用负索引，从集合的末尾更容易提取，可以使用负指数从List，array，String等结尾计数

复制代码

1
2
3
4
5
6
7
8
9
10
11
class FirstTest{
    static void main(String[] args) {
        def text = 'nice cheese gromit!'
        def x = text[-1]
        println x

        def name = text[-7..-2]
        println name
    }
}

如果使用向后Range（开始索引大于结束索引），则结果将反过来

复制代码

1
2
3
4
5
6
7
8
class FirstTest{
    static void main(String[] args) {
        def text = "nice cheese gromit!"
        def name = text[3..1]
        println name
    }
}