在groovy中从列表创建地图的快捷方式？

Question

我想要一些排序：

Map rowToMap(row) {
    def rowMap = [:];
    row.columns.each{ rowMap[it.name] = it.val }
    return rowMap;
}

鉴于 GDK 的方式，我希望能够做类似的事情：

Map rowToMap(row) {
    row.columns.collectMap{ [it.name,it.val] }
}

但我在文档中没有看到任何内容......我错过了什么吗？还是我太懒了？

Answer 1

我最近发现需要这样做：将列表转换为地图。这个问题是在Groovy版本1.7.9出来之前发布的，所以方法 collectEntries 还不存在。它的工作原理与 collectMap 方法 所提议的:

Map rowToMap(row) {
    row.columns.collectEntries{[it.name, it.val]}
}

如果由于某种原因您无法使用旧的 Groovy 版本， inject 也可以使用方法（如建议的 这里）。这是一个稍微修改过的版本，在闭包内只需要一个表达式（只是为了保存字符！）：

Map rowToMap(row) {
    row.columns.inject([:]) {map, col -> map << [(col.name): col.val]}
}

这 + 也可以使用运算符来代替 <<.

Answer 2

查看“注入”。真正的函数式编程专家称之为“折叠”。

columns.inject([:]) { memo, entry ->
    memo[entry.name] = entry.val
    return memo
}

而且，当您这样做时，您可能希望将方法定义为类别，而不是直接在元类上。这样，您可以为所有集合定义一次：

class PropertyMapCategory {
    static Map mapProperty(Collection c, String keyParam, String valParam) {
        return c.inject([:]) { memo, entry ->
            memo[entry[keyParam]] = entry[valParam]
            return memo
        }
    }
}

用法示例：

use(PropertyMapCategory) {
    println columns.mapProperty('name', 'val')
}

Answer 3

是 通过...分组 提出这个问题时方法不可用？

Answer 4

另外，如果您使用谷歌收藏（http://code.google.com/p/google-collections/），你可以这样做：

  map = Maps.uniqueIndex(list, Functions.identity());

Answer 5

好的...我已经玩过更多了，我认为这是一个非常酷的方法......

def collectMap = {Closure callback->
    def map = [:]
    delegate.each {
        def r = callback.call(it)
        map[r[0]] = r[1]
    }
    return map
}
ExpandoMetaClass.enableGlobally()
Collection.metaClass.collectMap = collectMap
Map.metaClass.collectMap = collectMap

现在 Map 或 Collection 的任何子类都有这个方法......

这里我用它来反转 Map 中的键/值

[1:2, 3:4].collectMap{[it.value, it.key]} == [2:1, 4:3]

在这里我用它从列表创建地图

[1,2].collectMap{[it,it]} == [1:1, 2:2]

现在我只是将其弹出到一个类中，该类在我的应用程序启动时被调用，并且该方法在我的代码中可用。

编辑：

将该方法添加到所有数组...

Object[].metaClass.collectMap = collectMap

Answer 6

如果你需要的是一个简单的键值对，那么该方法 collectEntries 应该足够了。例如

def names = ['Foo', 'Bar']
def firstAlphabetVsName = names.collectEntries {[it.charAt(0), it]} // [F:Foo, B:Bar]

但是，如果您想要一个类似于 Multimap 的结构，其中每个键有多个值，那么您需要使用 groupBy 方法

def names = ['Foo', 'Bar', 'Fooey']
def firstAlphabetVsNames = names.groupBy { it.charAt(0) } // [F:[Foo, Fooey], B:[Bar]]

Answer 7

我找不到任何内置的东西...但使用 ExpandoMetaClass 我可以这样做：

ArrayList.metaClass.collectMap = {Closure callback->
    def map = [:]
    delegate.each {
        def r = callback.call(it)
        map[r[0]] = r[1]
    }
    return map
}

这将collectMap方法添加到所有ArrayLists...我不确定为什么将其添加到列表或集合不起作用。我想这是另一个问题......但现在我可以做到这一点...

assert ["foo":"oof", "42":"24", "bar":"rab"] ==
            ["foo", "42", "bar"].collectMap { return [it, it.reverse()] }

从 List 到带有一个闭包的计算 Map...正是我正在寻找的。

编辑：我无法将方法添加到接口 List 和 Collection 的原因是因为我没有这样做：

List.metaClass.enableGlobally()

在该方法调用之后，您可以向接口添加方法。在这种情况下，这意味着我的collectMap方法将在如下范围内工作：

(0..2).collectMap{[it, it*2]}

生成地图：[0:0、1:2、2:4]

Answer 8

像这样的事情怎么办？

// setup
class Pair { 
    String k; 
    String v; 
    public Pair(def k, def v) { this.k = k ; this.v = v; }
}
def list = [ new Pair('a', 'b'), new Pair('c', 'd') ]

// the idea
def map = [:]
list.each{ it -> map.putAt(it.k, it.v) }

// verify
println map['c']