Groovy 如何检查列表中的映射中的元素

我有一张地图清单。我想检查是否有任何映射包含特定的键值对

myKey = myValue

最常规的方法是什么？

给定方法：

List findMaps( List<Map> m, Map pattern ) {
    m.findAll { map -> pattern.findAll { k, v -> map[ k ] == v }.size() == pattern.size() }
}

可能会有更简单的方法。。。我想一想；-）

编辑：这较短：

List findMaps（列表m，映射模式）{
m、 findAll{map->map.subMap（pattern.keySet（））==pattern}
}

；-）

更短的

List findMaps（列表m，映射模式）{
m、 findAll{map->！（模式-映射）}
} 

给定方法：

List findMaps( List<Map> m, Map pattern ) {
    m.findAll { map -> pattern.findAll { k, v -> map[ k ] == v }.size() == pattern.size() }
}

可能会有更简单的方法。。。我想一想；-）

编辑：这较短：

List findMaps（列表m，映射模式）{
m、 findAll{map->map.subMap（pattern.keySet（））==pattern}
}

；-）

更短的

List findMaps（列表m，映射模式）{
m、 findAll{map->！（模式-映射）}
} 

我想蒂姆在找这个。：）

List findMaps（列表m，映射模式）{
m、 findAll{map->map.findResults{map.intersect（pattern）==pattern？it:null}
}
def listofmap=[[a:1，b:2]，[a:3，b:4]，[a:5，b:2]]
断言findMaps（listofmap[a:3]）=[[a:3，b:4]]
断言findMaps（listOfMaps[a:1，b:2]）==[[a:1，b:2]]
断言findMaps（listofmap[b:2]）=[[a:1，b:2]，[a:5，b:2]]
断言findMaps（listofmap[c:4]）=[]

如果您只需要匹配任何条目而不是匹配整个地图，那么您可以放松模式与交叉点的匹配，让Groovy Truth完成它的工作：

List findMaps( List<Map> m, Map pattern ) {
    m.findAll{ map -> map.findResults{ map.intersect(pattern) ? it : null } }
}

assert findMaps( listOfMaps, [ a:3 ] )      == [ [ a:3, b:4 ] ]
assert findMaps( listOfMaps, [ a:1, b:2 ] ) == [ [ a:1, b:2 ], [a:5, b:2] ]
assert findMaps( listOfMaps, [ b:2 ] )      == [ [ a:1, b:2 ], [ a:5, b:2 ] ]
assert findMaps( listOfMaps, [ c:4 ] )      == []

List findMaps（列表m，映射模式）{
m、 findAll{map->map.findResults{map.intersect（模式）？it:null}
}
断言findMaps（listofmap[a:3]）=[[a:3，b:4]]
断言findMaps（listofmap[a:1，b:2]）=[[a:1，b:2]，[a:5，b:2]]
断言findMaps（listofmap[b:2]）=[[a:1，b:2]，[a:5，b:2]]
断言findMaps（listofmap[c:4]）=[]

编辑：这是最短的：

List findMaps( List<Map> m, Map pattern ) {
    m.findAll { map -> !( pattern - map ).intersect( pattern ) }
}

List findMaps（列表m，映射模式）{
m、 findAll{map->！（模式-地图）.intersect（模式）}
}

：D

更新：
很高兴看到蒂姆推出了更短的版本。我只是简单地复制了他的想法，并声称我已经找到了最短的ssstttt代码

List findMaps( List<Map> m, Map pattern ) {
    m.findAll { !( pattern - it ) }
}

List findMaps（列表m，映射模式）{
m、 findAll{！（模式-it）}
}

---

哈哈

我想蒂姆在找这个。：）

List findMaps（列表m，映射模式）{
m、 findAll{map->map.findResults{map.intersect（pattern）==pattern？it:null}
}
def listofmap=[[a:1，b:2]，[a:3，b:4]，[a:5，b:2]]
断言findMaps（listofmap[a:3]）=[[a:3，b:4]]
断言findMaps（listOfMaps[a:1，b:2]）==[[a:1，b:2]]
断言findMaps（listofmap[b:2]）=[[a:1，b:2]，[a:5，b:2]]
断言findMaps（listofmap[c:4]）=[]

如果您只需要匹配任何条目而不是匹配整个地图，那么您可以放松模式与交叉点的匹配，让Groovy Truth完成它的工作：

List findMaps( List<Map> m, Map pattern ) {
    m.findAll{ map -> map.findResults{ map.intersect(pattern) ? it : null } }
}

assert findMaps( listOfMaps, [ a:3 ] )      == [ [ a:3, b:4 ] ]
assert findMaps( listOfMaps, [ a:1, b:2 ] ) == [ [ a:1, b:2 ], [a:5, b:2] ]
assert findMaps( listOfMaps, [ b:2 ] )      == [ [ a:1, b:2 ], [ a:5, b:2 ] ]
assert findMaps( listOfMaps, [ c:4 ] )      == []

List findMaps（列表m，映射模式）{
m、 findAll{map->map.findResults{map.intersect（模式）？it:null}
}
断言findMaps（listofmap[a:3]）=[[a:3，b:4]]
断言findMaps（listofmap[a:1，b:2]）=[[a:1，b:2]，[a:5，b:2]]
断言findMaps（listofmap[b:2]）=[[a:1，b:2]，[a:5，b:2]]
断言findMaps（listofmap[c:4]）=[]

编辑：这是最短的：

List findMaps( List<Map> m, Map pattern ) {
    m.findAll { map -> !( pattern - map ).intersect( pattern ) }
}

List findMaps（列表m，映射模式）{
m、 findAll{map->！（模式-地图）.intersect（模式）}
}

：D

更新：
很高兴看到蒂姆推出了更短的版本。我只是简单地复制了他的想法，并声称我已经找到了最短的ssstttt代码

List findMaps( List<Map> m, Map pattern ) {
    m.findAll { !( pattern - it ) }
}

List findMaps（列表m，映射模式）{
m、 findAll{！（模式-it）}
}

---

哈哈

我是为你想的…；-）@德玛哈帕特罗，怎么样？达恩。为什么我没看到？太棒了。现在是时候放下冗长的

映射了
m.findAll{！（pattern-it）}
应该是它。你在挑战中表现出色。我欠你一杯啤酒我是为你想的…；-）@德玛哈帕特罗，怎么样？达恩。为什么我没看到？太棒了。现在是时候放下冗长的
映射了
m.findAll{！（pattern-it）}
应该是它。你在挑战中表现出色。我欠你一杯啤酒美好的我找到了一个较短的方法tho；-）我找到了另一个较短的：-PNice！我找到了一个较短的方法tho；-）我找到了另一个较短的：-P
List findMaps( List<Map> m, Map pattern ) {
    m.findAll { !( pattern - it ) }
}