Groovy笔记(三)之集合

List

1. List的创建与元素获取

       class ListTest {
           public static void main(String[] args) {
               //创建ArrayList
               def list = [1, 2, 3, 4, 5]
               //[1, 2, 3, 4, 5]
               println list
               //java.util.ArrayList
               println list.getClass().getName()
               //1
               println list[0]
               //最后一个元素 5
               println list[list.size() - 1]
               //最后一个元素 5
               println list[-1]
               //倒数第二个元素 4
               println list[-2]
               //使用Range对象获取集合中的几个连续值[3, 4, 5]
               println list[2..4]
       
               def subList = list[2..4]
               //<java.util.ArrayList@1c3e4a2 elementData=[1, 2, 3, 4, 5] size=5 modCount=1>
               println list.dump()
               //<java.util.ArrayList@8023 elementData=[3, 4, 5] size=3 modCount=1>
               println subList.dump()
               //[1, 2, 3, 4, 5]
               println list[0..list.size() - 1]
               //[2, 3, 4, 5]
               println list[1 - list.size()..-1]
               
               //true
               println ![]
               //true
               println([1] && ['a'] && [0] && [0.0] && [false] && [null])
       
               //正向迭代 12345
               list.each { print it }
               //反向迭代 54321
               list.reverseEach { print it }
       
               println()
       
               //如果关注迭代的索引和计数
               list.eachWithIndex { int entry, int i -> println "value:" + entry.intValue() + "==index:" + i }
               //闭包中的元素求和 15
               def sum = 0
               list.each { sum += it }
               println sum
       
               //[2, 4, 6, 8, 10]
               def result = []
               //<< 操作符映射到leftShitf()方法
               list.each { result << it * 2 }
               println result
       
               //在集合中的每个元素上执行操作并返回一个结果集合使用collect
               //[3, 6, 9, 12, 15]
               println list.collect { it * 3 }
       
               //find会对集合进行迭代，当闭包返回true则终止迭代(匹配第一个)，会将当前元素返回
               //如果遍历结束也找到，则返回null.以下输出:4
               println list.find { it == 4 }
               //以下输出索引3
               println list.findIndexOf { it == 4 }
               //findAll 查找所有返回的是对象[3, 4, 5]
               println list.findAll { it > 2 }
       
           }
       }
   

2. List的迭代、收集、查找

       def static listIterator() {
   
           def list = [1, 2, 3, 4, 5]
   
           //正向迭代 12345
           list.each { print it }
           //反向迭代 54321
           list.reverseEach { print it }
   
           println()
   
           //如果关注迭代的索引和计数
           list.eachWithIndex { int entry, int i ->
               println "value:" + entry.intValue() + "==index:" + i
           }
           //闭包中的元素求和 15
           def sum = 0
           list.each { sum += it }
           println sum
   
           //[2, 4, 6, 8, 10]
           def result = []
           //<< 操作符映射到leftShitf()方法
           list.each { result << it * 2 }
           println result
   
           //在集合中的每个元素上执行操作并返回一个结果集合使用collect
           //[3, 6, 9, 12, 15]
           println list.collect { it * 3 }
   
           //find会对集合进行迭代，当闭包返回true则终止迭代(匹配第一个)，会将当前元素返回
           //如果遍历结束也没找到，则返回null.以下输出:4
           println list.find { it == 4 }
           //以下输出索引3
           println list.findIndexOf { it == 4 }
           //findAll 查找所有返回的是对象[3, 4, 5]
           println list.findAll { it > 2 }
           
            //30
           println list.collect({ it * 2 }).sum()
   
           //inject对集合中的每个元素都调用闭包,0为初始值 。输出:15
           println list.inject(0) { total, ele -> total + ele }
           //连接集合中的每个元素，输出:1,2,3,4,5
           println list.join(",")
       }
   
   

Map

1. Map

       def static mapBasic(){
               //定义空map
               def emptyMap = [:]
               println emptyMap
       
               //定义多个key的map ，默认情况下 没有引号，''或者""的key都是字符串类型
               def map = [aa: "jannal", '2': "lisi", "3": "wangwu"]
               //java.util.LinkedHashMap
               println map.getClass().name
       
               //添加key
               map << ['4': "jannal2"]
               map.put('5', "jannal3");
               //移除key
               map = map - ['4': "jannal2"]
               map -= ['4': "jannal2"]
               map.remove("5")
       
       
               //访问键的值 输出:jannal
               println map["aa"]
               //可通过.来访问，如果key特殊，可通过""
               println map."aa"
               println map.aa
       
               //如果key不存在，返回一个默认值
               println map.get("4","44444")
       
       
           }
       
       
           def  static mapCollect(){
               // 通过list创建map
               def wordList = ['Apple', 'Banana', 'Cat']
               //[Apple:5, Banana:6, Cat:3]
               def wordCountMap = wordList.collectEntries{ [(it):it.length()] }
               println(wordCountMap)
       
       
               def longWords = wordCountMap.count { key, value->
                   value >= 4
               }
               //2
               println "${longWords}"
       
       
               //合并map
               def map1 = [p1:100, p2:200]
               def map2 = [p3:300, p4:400]
               def map3 = map1 + map2
               //[p1:100, p2:200, p3:300, p4:400]
               println "${map3}"
       
               //取交集
               def map4 = [p1:100, p2:200, p3:300, p4:400, p5:500]
               def map5 = [p4:400, p5:500, p6:600, p7:700]
               def map6 = map4.intersect(map5)
               //[p4:400, p5:500]
               println "${map6}"
       
           }
       
           def static iterator(){
               def map = [aa: "jannal", '2': "lisi", "3": "wangwu"]
               //如果只要一个参数，就得到entry，两个参数得到key和value
               //迭代 输出: aa : jannal ;2 : lisi ;3 : wangwu ;
               map.each { entry ->
                   print "$entry.key : $entry.value ;"
               }
               println()
       
       
               //迭代 输出: aa : jannal ;2 : lisi ;3 : wangwu ;[aa1, 21, 31]
               map.each { key, value ->
                   print "$key : $value ;"
               }
               println()
               //[aa1, 21, 31]
               println map.collect { key, value ->
                   key + "1"
               }
       
               //找到即返回该map的key和value aa=jannal
               println map.find { key, value ->
                   key == "aa"
               }
               //找到所有匹配的 [2:lisi, 3:wangwu]
               println map.findAll { key, value ->
                   key == '2' || key == '3'
               }
       
               //不想得到元素，只是确定map中是否有任何元素满足条件用any
               // 输出:true
               //any会查找至少一个满足给定条件
               println map.any { key, value ->
                   key == "2"
               }
       
               //是否所有的元素都满足条件 输出:false
               println map.every { key, value ->
                   key == '2' || key == '3'
               }
       
           }