Groovy-蒲公英云

Groovy

- 1.Groovy基本类型
- - 01.所有类型都是包装类
  - 02.类型推断
- 2.GString
- 3.字符串操作
- - 字符串扩充：
  - 获取：
  - 字符串的加减操作
  - 字符串转换其他类型
- 4.for循环扩充
- 5.闭包
- - 闭包的基本定义和使用
  - 闭包传递参数
  - 闭包常见的使用场景
  - - upTo方法
    - times方法
    - each方法
    - find方法
    - findAll方法
    - any方法
    - every方法
    - collect方法
- 6.闭包中的 this,owner,delegate对象
- 7.闭包的委托策略
- 8.数据结构
- - 列表
  - - 定义一个列表：
    - 列表排序
    - 列表查找
  - 映射（Map)
  - - 定义Map
    - 获取值
  - 修改值
  - 遍历
  - 分组
  - 范围

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

<括号只能写在右边。

Groovy

1.Groovy基本类型

01.所有类型都是包装类

02.类型推断

2.GString

3.字符串操作

字符串扩充：

获取：

字符串的加减操作

字符串转换其他类型

4.for循环扩充

5.闭包

闭包的基本定义和使用

闭包传递参数

闭包常见的使用场景

upTo方法

times方法

each方法

find方法

findAll方法

any方法

every方法

collect方法

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

7.闭包的委托策略

8.数据结构

列表

定义一个列表：

列表排序

列表查找

映射（Map)

定义Map

获取值

修改值

遍历

分组

范围

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

随便看看

教程文章

热评文章

1江湖小白之一起学Python （二）爬取数据的保存

2Java Shiro：简化身份验证和授权的安全框架

3Java中try()catch{}的使用方法

4Swagger注解-@ApiModel 和 @ApiModelProperty

5windows下强制杀死tomcat进程

6uni-app 条形码(一维码)/二维码生成实现

标签列表