Groovy

最新推荐文章于 2023-05-28 15:57:30 发布

黄小鸭吖

最新推荐文章于 2023-05-28 15:57:30 发布

阅读量398

点赞数 1

分类专栏： Groovy 文章标签： Groovy Groovy基础

本文链接：https://blog.csdn.net/qq122516902/article/details/84948226

版权

Groovy 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

1.Groovy基本类型

01.所有类型都是包装类

在groovy中只有包装类型，没有基本类型。比如int就是Integer类型，double就是Double类型。

package variable

int i = 10

println(i.class)

double d = 10

println(d.class)

char c = 'c'

println(c.class)

输出结果为：

class java.lang.Integer
class java.lang.Double
class java.lang.Character

02.类型推断

可以用def关键字定义一个变量，编译器会根据赋值情况推断出变量是属于哪种类型

package variable

def i = 11
println i.class
i = '12'
println i.class

控制台打印结果为：

class java.lang.Integer
class java.lang.String

2.GString

在groovy中，还可以用单引号和三引号定义字符串。其中，三引号定义的字符串会保留字符串定义时的格式（如换行等）

def s = '''
    one
    two
    three
'''

控制台输出：


    one
    two
    three

字符串中有扩展表达式，就是GString：

def name = "Tom"
// 这里只能用双引号
def sayHi = "hi ${name}"
println sayHi
println sayHi.class

控制台打印：

hi Tom
class org.codehaus.groovy.runtime.GStringImpl

在${}可以使用表达式。

3.字符串操作

字符串扩充：

主要方法：

center(n): 接收一个参数，从中间向两边扩充字符串，扩充的字符串是空格
center(n, c): 接收两个参数，从中间向两边扩充字符串，扩充的字符串是传入的字符串c
padLeft(n): 接收一个参数，从左边扩充字符串，扩充的字符串是空格
padLeft(n, c): 接收一个参数，从左边扩充字符串，扩充的字符串是传入的字符串c
padRight(n): 接收一个参数，从右边扩充字符串，扩充的字符串是空格
padRight(n, c): 接收一个参数，从右边扩充字符串，扩充的字符串是字符串c

演示代码：

def s = 'groovy'
println s.center(8, '@')
println s.padLeft(8)
println s.padRight(8, '@')

控制台打印：

@groovy@
  groovy
groovy@@

获取：

字符串的获取可以使用java中的charAt方法，groovy中也可以用中括号来获取对应位置的字符s[2]，也可以获取对应区间的字符s[0…3]
演示代码：

def s = 'groovy'
println s.charAt(1)
println s[2]
println s[0..3]

控制台打印：

r
o
groo

字符串的加减操作

字符串中的加（+）同java中的加是一样的，而减（如A-B）就是把字符串A中包含的字符串B删除

> def s = 'groovy'
> def h = 'hello '
> 
> def hs = 'hello groovy'
> 
> println h + s
> println hs - h
hello groovy
groovy

-操作符对应的方法是：

minus(s):从一个字符串中减去字符串s

代码演示：


> def s = 'groovy'
> def h = 'hello '
> 
> def hs = 'hello groovy'
> println hs.minus(h)
groovy

字符串转换其他类型

可以通过字符串.xxx来将字符串转换成其他类型的对象：

> def s = '1'
> println s.toInteger().class
> println s.toLong().class
class java.lang.Integer
class java.lang.Long

4.for循环扩充

对集合循环：

> // 对集合循环
> for (i in [1, 23, 5, '12']) {
>     println i
> }
1
23
5
12

对map循环：

> // 对集合循环
> for (i in  [a: 'a', b: 'ab', c: 1]) {
>     println i.key + " : " + i.value
> }
a : a
b : ab
c : 1

对范围循环：

> // 对范围循环
> for (i in 2..10) {
>     print i  + " "
> }
2 3 4 5 6 7 8 9 10

5.闭包

闭包是一个代码块，类似于方法。

闭包的基本定义和使用

定义一个简单的闭包和对闭包的调用：

> // 定义一个简单的闭包
> def closure= {
>     println 'hello groovy'
> }
> 
> // 闭包的调用方式一
> closuer()
> // 闭包的调用方式二
> closure.call()
hello groovy
hello groovy

闭包传递参数

闭包的默认参数 it

> // 闭包有一个默认参数 it
> def closure= {
>     println "hello ${it}"
> }
> 
> closure.call("groovy")
hello groovy

自定义参数
下面闭包的有两个参数，分别是 name 和age，参数可以指定具体的类型也可以不指定

> def clou
> ser = { String name, age ->
>     println "我的名字是${name}, 我的年龄是 ${age}"
> }
> 
> closure("zhangsan", 18)
我的名字是zhangsan, 我的年龄是 18

闭包的返回值
闭包中一定有返回值（返回值可以不写return）

> def closure= { String name, age ->
>     println "我的名字是${name}, 我的年龄是 ${age}"
>     // 返回值是Hello
>     return "Hello"
> }
> 
> def res = closure("zhangsan", 18)
> 
> println  res
我的名字是zhangsan, 我的年龄是 18
Hello

也可以不写return:

> def closure= {
>     "Hello"
> }
> 
> def res = closure()
> println res
Hello

没有显示返回，就是返回null

闭包常见的使用场景

upTo方法

从一个值A到另一个值的B的循环（A<B）

def n = 3

def add(int param) {
    def result = 0
    1.upto(param, {
        x -> result += x
    })
    result
}

println add(n)

上面程序完成了从1到3的累加。
控制台打印结果：

除了upTo，还有一个相同的方法downTo，是一个大数到一个小数的循环。

times方法

不同于upTo和downTo是从一个数A到一个数B的遍历，times方法只从0开始遍历到指定的数：

def n = 3

n.times {
    x -> print x
}

上面程序实现了从0到3的遍历.
控制台打印结果为：

each方法

each方法可以完成对字符串的遍历操作

def s = 'hello world'

s.each {
	// 向右扩充为两位  相当于加个空格
    c -> print c.padRight(2)
}

控制台输出：

h e l l o   w o r l d

find方法

find方法可以完成遍历并返回第一个满足的结果:

def s = 'hello 2 world 4'

def num = s.find {
    x -> x.isNumber()
}

print num

控制台输出：

findAll方法

与find方法类似，不同的是，findAll方法会返回所满足的结果:

def s = 'abc123def456'

def  all = s.findAll {
	//判断遍历的值是否是数值，如果是就转换成Integer，再和3比较
    x -> x.isNumber() && x.toInteger() >= 3
}
println all

控制台输出：

[3, 4, 5, 6]

any方法

判断是否有一个满足条件

def s = 'abc123def456'

def res = s.any {
	// it是闭包的默认参数
    it.isNumber()
}
println res

控制台打印：

true

every方法

every方法用于判断遍历的数据是否全部都满足条件

def s = 'abc123def456'

def res = s.every {
    it.isNumber()
}
println res

控制台打印：

false

collect方法

collect方法是用于对遍历的每一项数据作操作的，返回操作后的每一项数据的集合：

    def s = 'abc123def456'

    def res = s.collect {
        it.toUpperCase()
    }
    println res

控制台打印：

[A, B, C, 1, 2, 3, D, E, F, 4, 5, 6]

6.闭包中的 this,owner,delegate对象

在闭包中有三个内置对象，分别是this,owner和delegate，它们三个的作用分别是：

this：this向的是当前闭包所属的类或对象
owner: owner指向当前闭包所属的类或对象，如果当前闭包是定义在另一个闭包内，那么owner指向当前闭包所属的闭包
delegate: delegate与owner一致，只有手动修改delegate的值，delegate才会改变为与owner不一致

def closure = {
    println "this" + this
    println "owner" + owner
    println "delegate" + delegate
}

closure.call()

控制台：

this : ideaGroovyConsole@3eb25e1a
owner : ideaGroovyConsole@3eb25e1a
delegate : ideaGroovyConsole@3eb25e1a

闭包内定义闭包：

def c = {
    def closure = {
        println "this : " + this
        println "owner : " + owner
        println "delegate : " + delegate
    }
    // 调用内部闭包
    closure.call()
}

c.call()

控制台输出：

this : ideaGroovyConsole@3bf7ca37
owner : ideaGroovyConsole$_run_closure1@4d1c00d0
delegate : ideaGroovyConsole$_run_closure1@4d1c00d0

只有delegate才能修改

7.闭包的委托策略

class Dog {
    String name
    def eat = {
        "${name} is eating"
    }

    void life() {
        print eat.call()
    }
}

class Cat {
    String name
}

Dog dog = new Dog(name: "dog")
Cat cat = new Cat(name: "cat")
//  dog.life() 这里执行的话还没有修改委托策略，在闭包中获取的name属性还是dog中的name属性
dog.eat.delegate = cat // 修改eat闭包的委派给cat
// 这里修改委派策略为使用 delegate 也可以使用owner等
dog.eat.resolveStrategy = Closure.DELEGATE_ONLY
dog.life()

8.数据结构

列表

定义一个列表：

def list = [1,2,3, "aa"] // 这样就定义了一个列表了

上面定义出来的列表使用的是java中的ArrayList，这种定义方式类似于java中定义数组的方式。如果要在groovy中定义数组的话要使用如下方式：

def arr1 = [1, 2, 3, 'a', "ab"] as Object[]
int[] arr2 = [1,2,3,4]

列表排序

直接使用列表对象的sort方法对列表排序：

def list = [1,-1,2,-2,3,-4]
list.sort()
println list

也可以自定义排序规则：

def list = [1,-1,2,-2,3,-4]
list.sort({ x, y ->
    y - x
})
println list

通过传入一个闭包，完成自定义排序。

列表查找

def list = ["1", '2', '3', 'a', 'b', 'c']

println list.find({ x -> x.isNumber() })
println list.findAll { x -> x.isNumber() }
println list.any { x -> x.isNumber() }
println list.every { x -> x.isNumber() }

映射（Map)

定义Map

可以使用java中定义列表的方式，而groovy定义方式如下：

def map = [name: "zhangsan", age: "18", country: "China"]

groovy中的映射使用的是：LinkedHashMap。

获取值

获取值可以通过以下三种方法获取值：

def map = [name: "zhangsan", age: "18", country: "China"]

println map.get("name")
println map.name
println map['name']

修改值

修改值的方式有如下三种：

def map = [name: "zhangsan", age: "18", country: "China"]
// 如果map中不存在这个属性，就会添加，存在就修改
map.addresss = 'sz'
map.age = 19
map['name'] = 'lisi'

遍历

each { target -> } ：一个参数
eachWithIndex {target, index -> } : 两个参数 

map.eachWithIndex {key, value, index -> } ：三个参数

分组

def map = [p: [name: "zhangsan", age: 17, country: "China"],q: [name: "zhangsan", age: 18, country: "China"]]

def res = map.groupBy { x ->
    println x.value.age
    return x.value.age < 18 ? '未成年' : '成年'
}

println res

控制台输出：

[未成年:[p:[name:zhangsan, age:17, country:China]], 成年:[q:[name:zhangsan, age:18, country:China]]]

范围

定义：

def range = 1..10

使用A…B来表示一个边界A到边界B的范围，可以通过[]获取对应索引的值，也可以通过from和to属性获取边界。

def range = 1..10

def r2 = range[2]
def from = range.from
def to = range.to

A…B，表示的区间是[A,B]，即A和B都能取到。
如果要表示不包含的话可以是：

 def 1..<10

<括号只能写在右边。

黄小鸭吖

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Groovy

Groovy1.Groovy基本类型01.所有类型都是包装类02.类型推断2.GString1.Groovy基本类型01.所有类型都是包装类在groovy中只有包装类型，没有基本类型。比如int就是Integer类型，double就是Double类型。package variableint i = 10println(i.class)double d = 10println...
复制链接

扫一扫