Groovy 集合

  • 列表集合的定义和元素的操作；
  • 数组的定义和元素的操作；
  • 键值对集合的定义和元素的操作；
  • 范围 Rnnge 的定义和元素的操作；
  • 闭包参数的确定；

  • 总结；

    列表集合

    列表集合的定义

  • 定义一个列表集合的方式有点像 Java 中的定义数组一样。

  • 默认的类型就是 ArrayList 。
  • 集合元素可以接收任意的数据类型。 ```groovy //定义一个集合 //1. 在 Groovy 中定义的集合默认就是对应于 Java 中 ArrayList 集合 def list = [1, 2, 3] println list.class//class java.util.ArrayList

assert list instanceof List

//2. 在集合中可以介绍任意类型的数据,例如当前传入的是数字,字符串,boolean值 def list2 = [1, “groovy”, true]

  1. 疑问：假如我想定义一个 LinkedList集合，我该如何去指定一个集合的类型呢？
  3. - 通过 as 关键字来指定。
  4. - 通过强类型来定义你想要的类型。
  5. ```groovy
  6. //3. 指定集合的类型有两种方式
  7. //方式1 通过 as 操作符来指定
  8. //方式2 通过强类型定义的方式来指定
  10. def list3 = [1, 2, 3] as LinkedList
  11. //println list3.class//class java.util.LinkedList
  12. LinkedList list4 = [4, 5, 6]
  13. //println list4.class//class java.util.LinkedList

列表集合元素的操作

在定义好集合之后，我们就可以要操作集合的元素了。

根据角标获取元素的值

  • 获取指定角标下的元素
    1. 可以通过角标访问集合指定位置的元素,正数角标是从0位置左往右算起,负数角标是从0位置往反方向算。
    2. 下面的代码片段中出现的负数角标,就有别于 JAVA ,因为在 JAVA 中出现负数角标,基本就会报异常了。
    3. 0 就是第一个位置的元素,-1就是最后一个位置的元素，一次类推即可。
    ```groovy //获取单个元素 def list5 = [1, 2, 3, 4, 5] assert 2 == list5[1] assert 5 == list5[-1]

//获取多个元素 //list[index1,index2,indexn]获取指定位置的元素，如果角标不存在，那么对应的值就返回null println list5[1,3,0].toListString()//[2, 4, 1]

//println list5[1,9].toListString()//[2, null]

  2. - 获取指定范围的元素
  3. ```groovy
  4. def list5 = [1, 2, 3, 4, 5]
  5. //取出指定范围的元素集合
  6. println list5[1..3].toListString()//[2, 3,4]

添加元素到集合

  • list.add()
  • leftShift
  • << ```groovy def list5 = [1, 2, 3, 4, 5]

list5.add(2) list5.leftShift 2 //括号是可以省略的 list5.leftShift(2) //leftshift可以使用操作符<<表示 list5 << 2

  1. <a name="cMreq"></a>
  2. #### 移除集合中的元素
  3. ```groovy
  4. def list = [2, 1, 8, -9, 6, 3, 5, 0]
  5. //移除的是角标为2的元素
  6. list.remove(2)
  7. //移除元素为2
  8. list.remove((Object) 2)
  9. list.removeLast()

元素的遍历

在 Groovy 中使用 each 来遍历集合。
在遍历时，可以选择是否带有角标来选择不同的遍历方法。

  1. def list = [2, 1, 8, -9, 6, 3, 5, 0]
  3. //不带有角标的遍历，类似于 java 中的 foreach
  4. list.each {print it+"  "}//2  1  8  -9  6  3  5  0
  6. //带有角标的遍历，类似于普通的for循环
  7. list.eachWithIndex { int value, int index ->
  8.     println "value is ${value} and index is ${index}"
  9. }

查找元素

在 Groovy 中提供了 find，findAll，every，any 相关的 API 来查找结合的元素。

  1. //(1)find 找到第一个符合条件的值
  2. def findList = [2, 1, 8, -9, 6, 3, 5, 0]
  4. //找到第一个元素的偶数的元素
  5. println findList.find {it->it%2==0}
  7. //(2)findAll 查找所有偶数的值
  8. println findList.findAll {it->it%2==0}//[2, 8,6, 0]
  10. //(3)any 只有一个符合条件就返回true,否则返回false
  11. def result = findList.any { it -> it == 8 }
  12. println result
  14. //(4)every 集合中每一元素都是偶数就返回true
  15. println findList.every {it->it%2==0 }

计数

Groovy 中提供 count 方法来计数

  1. def findList = [2, 1, 8, -9, 6, 3, 5, 0]
  2. //凡是奇数就累积，返回符合条件的元素个数
  3. println findList.count { it -> it % 2 == 1 }

最大值和最小值

Groovy 中提供了 min() 和max()方法可以获取集合的最小最大值，当前也可以使用其重载带有闭包参数的方法，来自定义规则获取最大值，下面演示的就是最小值的获取，最大值是一样的，

  1. def findList = [2, 1, 8, -9, 6, 3, 5, 0]
  2. //min() 查看最小值
  3. println findList.min()
  4. //通过闭包修改对应的最小值
  5. //将每一个元素取绝对值，然后找到一个最小值返回
  6. println findList.min{Math.abs(it)}

集合元素比较器

  1. def sortList = [9, -8, 2, 0, 4, -1]
  3. //定义比较器
  4. //Comparator comparator = { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 }
  6. //方式1 自定义排序方式
  7. Collections.sort(sortList, new Comparator<Integer>() {
  8.     @Override
  9.     int compare(Integer a, Integer b) {
  10.         return a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1
  11.     }
  12. })
  14. //方式2
  15. sortList.sort()//自然顺序排序
  16. println sortList.toListString()
  18. //方式3
  19. sortList.sort(comparator)
  20. //println sortList.toListString()//[0, -1, 2, 4, -8, 9]
  23. def sortList2 = ["java", "Groovy", "c", "c++"]
  25. sortList2.sort {
  26.     it -> it.size()
  27. }
  28. println sortList2.toListString()//[c, c++, java, Groovy]

数组

数组的定义

因为 Groovy中使用[] 表示就是一个 List 集合,如果要定义 Array ,那么就必须要强制指定为一个数组类型。

  • 使用强类型定义。
  • 使用 as 关键字定义数组 ```groovy //使用强类型定义 String[] arr1 = [“Java”, “Groovy”, “Android”]

assert arr1 instanceof String[]

//使用 as 关键字定义数组 def arr2 = [“Java”, “Groovy”, “Android”] as String[]

assert arr2 instanceof String[]

//定义多维数组 def arr3 = new int[3][4]

//println arr3.class

assert arr3.length == 3

assert arr3.size() == 3

  1. <a name="DVebL"></a>
  2. ### 数组元素的操作
  3. 数组的操作基本上和 Java 是一样的，这里就贴代码了。
  4. <a name="DZvfd"></a>
  5. ## 键值对集合 Map
  6. <a name="LSA8J"></a>
  7. ### Map 集合的定义
  9. - Map 集合的定义有别于 Java 的定义方式，格式如下
  10. - Groovy 中定义的 Map 默认类型是 java.util.LinkedHashMap
  11. ```groovy
  12. def map1 =[name:"六号表哥",age:26]
  14. println map1.getClass()//class java.util.LinkedHashMap

Map 集合元素的操作

获取元素值

Map 集合中指定 key 下的值有有两种方式：

  • map.get(key)
  • map[key]
  • map.key ```groovy

def map1 =[name:”六号表哥”,age:26]

println “the name is ${map1[‘name’]} and age is ${map1[‘age’]}”//the name is 六号表哥 and age is 26 println “the name is ${map1.name} and age is ${map1.age}”//the name is 六号表哥 and age is 26

//获取一个不存的key对应值,那么会得到null println map1.top//null

  2. - 使用数字作为 key
  3. ```groovy
  4. def map2 =[1:"java",2:"c"]
  5. println map2.get(1)//java
  6. println map2[1]//java
  7. //println map2.1//编译不过
  • 关于 map 的 key 需要注意的点 ```groovy def key = ‘name’ //这里传入的key并不是上面定义的key变量，groovy会将其进行转化为’key’字符串作为map的key。 def map3 = [key:”六号表哥”]

println map3.key//六号表哥 //这里的key是上面的变量key，因此取出来的值为null println map3[key]//null;

println map3.containsKey(‘name’)//false println map3.containsKey(‘key’)//true

  1. ```groovy
  2. def key = 'name'
  3. def map4 = [(key):"六号表哥"]
  5. println map4.containsKey('name')//true
  6. println map4.containsKey('key')//false

添加元素

  1. def map1 =[name:"六号表哥",age:26]
  2. map1.level = 'middle'
  3. //the name is 六号表哥 and age is 25 and level is middle
  4. println "the name is ${map1['name']} and age is ${map1['age']} and level is ${map1['level']}"

修改集合元素

  1. def map1 =[name:"六号表哥",age:26]
  2. map1['age'] = 25
  4. //the name is 六号表哥 and age is 25
  5. println "the name is ${map1['name']} and age is ${map1['age']}"

Map 遍历

  2. //不带角标的遍历
  3. def map = [name: "六号表哥", age: 26]
  5. map.each { key, value ->
  6.     println key + "-" + value
  7. }
  9. //带有角标的遍历
  10. map.eachWithIndex { Map.Entry entry, int i ->
  12.     //name-六号表哥 index = 0
  13.     //age-26 index = 1
  14.     println entry.key + "-" + entry.value + " index = " + i//age-26 index = 1
  15. }

查找

在 Groovy 中提供了 find，findAll，every，any 相关的 API 来查找结合的元素。

  • find ```groovy def mapFindResult = map.find { key, value ->

    if (key.equals(‘age’) && value == 26) {

    1.   return map[key]

    } return null }

println “查找结果:${mapFindResult}”//查找结果:age=26

def mapFindResult2 = map.find { Map.Entry entry ->

  1. if (entry.key.equals('age') && entry.value == 26) {
  2.     return map[entry.key]
  3. }
  4. return null

} println “查找结果:${mapFindResult2}”//查找结果:age=26

  2. - findAll
  3. ```groovy
  4. def map2 = [1:[name: "六号表哥", age: 26],
  5.             2:[name: "Koobe", age: 23],
  6.             3:[name: "Jerry", age: 26], 
  7.             4:[name: "Kai", age: 22],
  8.             5:[name: "kimi", age: 18]
  9. ]
  11. println map2.findAll {key, person ->
  13.     if (person.age > 18) {
  14.         return true
  15.     }
  16.     return false
  17. }.toMapString()
  18. //[1:[name:六号表哥, age:26], 2:[name:Koobe, age:23], 3:[name:Jerry, age:26], 4:[name:Kai, age:22]]
  21. map2.findAll {key, person ->
  23.     if (person.age > 18) {
  24.         return true
  25.     }
  26.     return false
  27.     //collect 过滤
  28. }.collect {key,value->
  30.     print  value.name+" "//六号表哥 Koobe Jerry Kai 
  31. }

  • every

    1. //判断是否所有的人都是成年的
    2. println map2.every {key, person ->
    4.   if (person.age > 18) {
    5.       return true
    6.   }
    7.   return false
    8. }//false

  • any

    1. //查找是否有未成年的人
    2. println map2 {key, person ->
    4.   if (person.age <18) {
    5.       return true
    6.   }
    7.   return false
    8. }//false

    排序

    1. println map2.sort {
    2.  Map.Entry element1,  Map.Entry element2 ->
    4.       if (element1.value.age == element2.value.age) {
    5.           return 0;
    6.       } else if (element1.value.age > element2.value.age) {
    7.           return 1
    8.       } else {
    9.           return -1
    10.       }
    11. }.toMapStrin