Groovy 在给定值的映射中查找键

嗨，我有一张这样的地图：

[this:0, is:1, a:2, file:3, anotherkey:4, aa:5]

我希望我能在给定地图的

值的情况下找到
键
。例如，如果给定值
5
，我需要从映射返回
aa

这可能吗？
您可能需要自己迭代，并尝试查找具有匹配项的条目。
我不知道是否有直接方法可以获取给定值的键，但使用获取映射条目然后获取其值就足够了：

def keyForValue(map, value) {
    map.find { it.value == value }?.key
}

def map = [a: 1, b: 2, c: 3]
assert keyForValue(map, 2) == 'b'
assert keyForValue(map, 42) == null

一般来说，映射项之间不需要有顺序关系，但是Groovy的文本映射的默认实现是LinkedHashMap，它是有序的，因此在使用这些映射时，
keyForValue
总是为值生成第一个键。
没有特定的命令

def expect = 5
def m = ['this':0, is:1, a:2, file:3,  aa:5]
def r = m.collectMany{ k,v -> (v == expect) ? [k] : []}

// Result: [aa]

幸运的是，如图所示，您可以轻松获得映射中特定值的键：

def myMap = [this:0, is:1, a:2, file:3, fix:4, aa:5]
def myValue = 5

你可以做：

def myKey = myMap.find{ it.value == myValue }?.key
// 'aa'

如果需要所有钥匙，请执行以下操作：

def myMap = [this:0, is:1, a:2, file:3, fix:4, aa:5, bb:5]
def myValue = 5

def myKeys = []
myMap.findAll{ it.value == myValue }.each{myKeys << it?.key}
// ['aa', 'bb']

Map m = [a: '1', b: '2']
Map mInvert = m.collectEntries { e -> [(e.value): e.key] }

assert mInvert == ['1':'a', '2':'b']

assert mInvert['2'] == 'b'
assert m['b'] == '2'

defmymap=[这个：0，is:1，a:2，文件：3，修复：4，aa:5，bb:5]
def myValue=5
def myKeys=[]
myMap.findAll{it.value==myValue}。每个{myKeys都可以反转映射，如下所示：

def myMap = [this:0, is:1, a:2, file:3, fix:4, aa:5, bb:5]
def myValue = 5

def myKeys = []
myMap.findAll{ it.value == myValue }.each{myKeys << it?.key}
// ['aa', 'bb']

Map m = [a: '1', b: '2']
Map mInvert = m.collectEntries { e -> [(e.value): e.key] }

assert mInvert == ['1':'a', '2':'b']

assert mInvert['2'] == 'b'
assert m['b'] == '2'

不，您的代码很有趣：）但是性能杀手，因为您重新创建了另一个映射。有一种方法可以查找给定值的映射条目，epidemian很久以前就给出了正确答案：myMap.find{it.value==5}.key@ARA事实上，对于重复使用，只要不是每次都重新创建反向集合，crazy4groovy的解决方案就会更快。当可以在O（logN）处使用映射时，不应该迭代列表O（n）当然，无论怎样，性能都应该放在可读性的后面——如果做得好，crazy4groovy的解决方案可能也更具可读性……不过它并不是非常“Groovy”：）@Bill:是的，我说的性能杀手是每次都要重新创建映射，就像使用lambda动态地重新创建映射的示例一样。当然，如果不在每次调用时重新创建并维护映射，这将比迭代快得多。这就是映射的目的。：）我认为映射是O（1）而不是O（log（n）），一个btree应该是O（log（n））？