Groovy~Groovy的Map操作

Map方法

• containsKey()：此映射是否包含此键
• get()：查找此Map中的键并返回相应的值，如果此映射中没有键的条目，则返回null
• keySet()：获取此映射中的一组键
• put()：将指定的值与此映射中的指定键相关联。如果此映射之前包含此键的映射，则旧值将替换为指定的值
• size()：返回此Map种键值映射的数量
• values()：返回此地图中包含的值的集合视图

一、基础操作

• def Map = [key1:value1,key2:value2,key3:value3]：定义Map
• Map.get(key)：获取Map中key的值
• Map.get[key]：获取Map中key的值
• Map.getClass()：获取Map的类
• Map.size()：获取Map中元素的个数
• Map.put(key,value)：向Map中添加元素

class FirstTest{
    static void main(String[] args) {
        def map = [name: 'Gromit', likes: 'cheese', id:1234]
        println map.get('name')
        println map.get('id')
        println map['name']
        println map['id']
        println map.getClass()

        def emptyMap = [:]
        println emptyMap.size()
        emptyMap.put('foo',5)
        println emptyMap.size()
        println emptyMap.get('foo')
    }
}

• Map中，[a:1]等价于['a':1]

class FirstTest{
    static void main(String[] args) {
        def a = 'Bob'
        def ages = [a: 43]
        // 找不到Bob
        println ages['Bob']
        // 因为a是字面值（文本）
        println ages['a']

        // 将a用（）括起来
        ages = [(a):43]
        // 这时就能找到Bob的值了
        println ages['Bob']
    }
}

• Map.clone()：对Map进行浅拷贝

class FirstTest{
    static void main(String[] args) {
        def map = [
                'simple' : 123,
                'complex' : [a: 1, b: 2]
        ]

        def map2 = map.clone()

        println map2.get('simple')
        println map2.get('complex')
        map2.get('complex').put('c',3)
        println map
    }
}

二、属性符号

class FirstTest{
    static void main(String[] args) {
        def map = ['name': 'Gromit', 'likes': 'cheese', id:1234]
        println map.class
        println map.get('class')
        println map.getClass()

        map = [
                1: 'a',
                (true): 'p',
                (false): 'q',
                (null): 'x',
                'null': 'z'
        ]
        // 数字1不是一个标识符，所以得这样调用
        println map.containsKey(1)
        println map.true
        println map.get(true)
        println map.false
        println map.get(false)
        println map.null
        println map.get(null)
    }
}

三、迭代

• Map.each{键值对 -> 执行语句}
• Map.eachWithIndex{键值对,i -> 执行语句}
• Map.each{键，值 -> 执行语句}
• Map.eachWithIndex{键，值，i -> 执行语句}

class FirstTest{
    static void main(String[] args) {
        def map = [
                'Bob': 42,
                'Alice': 54,
                'Max': 33
        ]

        map.each{entry ->
            println "Name: $entry.key Age: $entry.value"
        }

        map.eachWithIndex { entry, i ->
            println "$i - Name: $entry.key Age: $entry.value"
        }

        map.each { key, value ->
            println "Name: $key Age: $value"
        }

        map.eachWithIndex{ key, value, i ->
            println "$i -Name: $key Age: $value"
        }
    }
}

四、增加元素

• Map.put(key,value)：向Map中添加一个元素
• Map[key] = value：向Map中添加一个元素
• Map1.putAll(Map2)：向Map1中添加Map2的所有元素

class FirstTest{
    static void main(String[] args) {
        def defaults = [1: 'a', 2: 'b', 3: 'c', 4: 'd']
        def overrides = [2: 'z', 5: 'x', 13: 'x']
        
        defaults.put(15,'t')
        defaults[17] = 'u'
        defaults.putAll(overrides)
        println defaults
    }
}

五、删除元素

• Map.clear：清空Map中的所有元素

class FirstTest {
    static void main(String[] args) {
        def m = [1: 'a', 2: 'b']
        println m.get(1)
        m.clear()
        println m
    }
}

六、不能使用GString作为Map的键

class FirstTest {
    static void main(String[] args) {
        def key = 'some key'
        def map = [:]
        def gstringKey = "${key.toUpperCase()}"
        map.put(gstringKey, 'value')
        println map.get('SOME KEY')
    }
}

七、keys、values、entries

• Map.keySet：返回Map中的所有key
• Map.valueSet：返回Map中所有value
• Map.entrySet：返回Map中所有的entry

class FirstTest {
    static void main(String[] args) {
        def map = [1: 'a', 2: 'b', 3: 'c']

        def entries = map.entrySet()
        entries.each{ entry ->
            println entry.key
            println entry.value
        }

        def keys = map.keySet()
        println keys
    }
}

八、过滤和搜索

• Map.find{条件}：按照条件查找单个entry
• Map.findAll{条件}：按照条件查找所有的entry
• Map.every{条件}：如果所有的entry都符合条件就返回true
• Map.any{条件}：如果有一个entry符合条件就返回true

class FirstTest{
    static void main(String[] args) {
        def people = [
                1: [name:'Bob', age:32, gender:'M'],
                2: [name:'Johnny', age:36, gender:'M'],
                3: [name:'Claire', age:21, gender:'F'],
                4: [name:'Amy', age:54, gender:'F']
        ]

        // 查找单个entry
        def bob = people.find{it.value.name == 'Bob'}
        def females = people.findAll{it.value.gender == 'F'}

        // 两个都是返回entries，但是可以使用collect来检索年龄
        def ageOfBob = bob.value.age
        def ageOfFemales = females.collect{it.value.age}

        println ageOfBob
        println ageOfFemales

        // 但您也可以使用键/值作为闭包的参数
        def agesOfMales = people.findAll{
            id,person -> person.gender == 'M'
        }.collect{
            id, person -> person.age
        }
        println agesOfMales

        // every，如果所有entries都匹配规则，则返回true
        println people.every{
            id,person -> person.age > 18
        }

        // any,如果任何一个entry匹配规则，则返回true
        println people.any{
            id,person -> person.age == 54
        }
    }
}

九、分组

• Map.groupBy{条件}：将Map按照条件分组

class FirstTest{
    static void main(String[] args) {
        println([
                [name:'Clark',city:'London'],
                [name:'Sharma',city:'London'],
                [name:'Maradona',city:'LA'],
                [name:'Zhang',city:'HK'],
                [name:'Ali',city:'HK'],
                [name:'Liu',city:'HK']
        ].groupBy{it.city})
    }
}