Java:哈希映射中的复合键

时间:2012-07-28 11:35:11

标签: java collections hash hashmap

我想在散列映射中存储一组对象,其中键应该是两个字符串值的组合。有没有办法实现这个目标?

我可以简单地连接两个字符串,但我确定有更好的方法来做到这一点。

9 个答案:

答案 0 :(得分:40)

您可以拥有一个包含两个字符串的自定义对象:

class StringKey {
    private String str1;
    private String str2;
}

问题是,您需要确定两个此类对象的相等性测试和哈希码。

Equality可能是两个字符串的匹配,而hashcode可能是连接成员的哈希码(这是有争议的):

class StringKey {
    private String str1;
    private String str2;

    @Override
    public boolean equals(Object obj) {
        if(obj != null && obj instanceof StringKey) {
            StringKey s = (StringKey)obj;
            return str1.equals(s.str1) && str2.equals(s.str2);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return (str1 + str2).hashCode();
    }
}

答案 1 :(得分:10)

public int hashCode() {
    return (str1 + str2).hashCode();
}

这似乎是一种生成hashCode的可怕方法:每次计算哈希码时创建一个新的字符串实例都很糟糕! (即使生成一次字符串实例并缓存结果也是不好的做法。)

这里有很多建议:

How do I calculate a good hash code for a list of strings?

public int hashCode() {
    final int prime = 31;
    int result = 1;
    for ( String s : strings ) {
        result = result * prime + s.hashCode();
    }
    return result;
}

对于一对字符串,变为:

return string1.hashCode() * 31 + string2.hashCode();

这是一个非常基本的实现。通过链接提供了大量建议,以提出更好的调整策略。

答案 2 :(得分:7)

为什么不创建一个(比方说)Pair对象,其中包含两个字符串作为成员,然后将其用作关键字?

e.g。

public class Pair {
   private final String str1;
   private final String str2;

   // this object should be immutable to reliably perform subsequent lookups
}

不要忘记equals()hashCode()。有关HashMaps和密钥的更多信息,请参阅this blog entry,其中包括有关不变性要求的背景信息。如果您的密钥不是不可变的,那么您可以更改其组件,并且后续查找将无法找到它(这就是String等不可变对象是密钥的良好候选者的原因

你认为串联并不理想是正确的。在某些情况下它会起作用,但它通常是一个不可靠和脆弱的解决方案(例如 AB / C A / BC 不同的键?)。

答案 3 :(得分:5)

我有类似的情况。我所做的只是连接由波浪号(〜)分隔的两个字符串。

因此,当客户端调用服务函数从地图中获取对象时,它看起来像这样:

MyObject getMyObject(String key1, String key2) {
    String cacheKey = key1 + "~" + key2;
    return map.get(cachekey);
}

这很简单,但确实有效。

答案 4 :(得分:3)

我看到许多人使用嵌套地图。也就是说,要映射Key1 -> Key2 -> Value(我使用计算机科学/ aka haskell curring表示法为(Key1 x Key2) -> Value映射,它有两个参数并产生一个值),你首先提供第一个键 - 这将返回给你一个(partial) map Key2 -> Value,您将在下一步展开。

例如,

Map<File, Map<Integer, String>> table = new HashMap(); // maps (File, Int) -> Distance

add(k1, k2, value) {
  table2 = table1.get(k1);
  if (table2 == null) table2 = table1.add(k1, new HashMap())
  table2.add(k2, value)
}

get(k1, k2) {
  table2 = table1.get(k1);
  return table2.get(k2)
}

我不确定它是否比普通的复合键构造更好或更好。你可以评论一下。

答案 5 :(得分:3)

您无需重新发明轮子。根据您的需要,只需使用Guava HashBasedTable<R,C,V> Table<R,C,V>接口的实现即可。这是一个例子

Table<String, String, Integer> table = HashBasedTable.create();

table.put("key-1", "lock-1", 50);
table.put("lock-1", "key-1", 100);

System.out.println(table.get("key-1", "lock-1")); //prints 50
System.out.println(table.get("lock-1", "key-1")); //prints 100

table.put("key-1", "lock-1", 150); //replaces 50 with 150

快乐的编码!

答案 6 :(得分:2)

阅读关于spaguetti / cactus堆栈我想出了一个可能用于此目的的变体,包括以任何顺序映射键的可能性,以便map.lookup(“a”,“b”)和map。 lookup(“b”,“a”)返回相同的元素。它也适用于任意数量的键而不仅仅是两个键。

我将它用作实验数据流编程的堆栈,但这里是一个快速而又脏的版本,可用作多键映射(应该进行改进:应该使用集合而不是数组来避免查找重复的数据流键)

public class MultiKeyMap <K,E> {
    class Mapping {
        E element;
        int numKeys;
        public Mapping(E element,int numKeys){
            this.element = element;
            this.numKeys = numKeys;
        }
    }
    class KeySlot{
        Mapping parent;
        public KeySlot(Mapping mapping) {
            parent = mapping;
        }
    }
    class KeySlotList extends LinkedList<KeySlot>{}
    class MultiMap extends HashMap<K,KeySlotList>{}
    class MappingTrackMap extends HashMap<Mapping,Integer>{}

    MultiMap map = new MultiMap();

    public void put(E element, K ...keys){
        Mapping mapping = new Mapping(element,keys.length);
        for(int i=0;i<keys.length;i++){
            KeySlot k = new KeySlot(mapping);
            KeySlotList l = map.get(keys[i]);
            if(l==null){
                l = new KeySlotList();
                map.put(keys[i], l);
            }
            l.add(k);
        }
    }
    public E lookup(K ...keys){
        MappingTrackMap tmp  = new MappingTrackMap();
        for(K key:keys){
            KeySlotList l = map.get(key);
            if(l==null)return null;
            for(KeySlot keySlot:l){
                Mapping parent = keySlot.parent;
                Integer count = tmp.get(parent);
                if(parent.numKeys!=keys.length)continue;
                if(count == null){
                    count = parent.numKeys-1;
                }else{
                    count--;
                }
                if(count == 0){
                    return parent.element;
                }else{
                    tmp.put(parent, count);
                }               
            }
        }
        return null;
    }
    public static void main(String[] args) {
        MultiKeyMap<String,String> m = new MultiKeyMap<String,String>();
        m.put("brazil", "yellow", "green");
        m.put("canada", "red", "white");
        m.put("USA", "red" ,"white" ,"blue");
        m.put("argentina", "white","blue");

        System.out.println(m.lookup("red","white"));  // canada
        System.out.println(m.lookup("white","red"));  // canada
        System.out.println(m.lookup("white","red","blue")); // USA
    }
}

答案 7 :(得分:1)

public static String fakeMapKey(final String... arrayKey) {
    String[] keys = arrayKey;

    if (keys == null || keys.length == 0)
        return null;

    if (keys.length == 1)
        return keys[0];

    String key = "";
    for (int i = 0; i < keys.length; i++)
        key += "{" + i + "}" + (i == keys.length - 1 ? "" : "{" + keys.length + "}");

    keys = Arrays.copyOf(keys, keys.length + 1);

    keys[keys.length - 1] = FAKE_KEY_SEPARATOR;

    return  MessageFormat.format(key, (Object[]) keys);}
public static string FAKE_KEY_SEPARATOR = "~";

INPUT: fakeMapKey("keyPart1","keyPart2","keyPart3");
OUTPUT: keyPart1~keyPart2~keyPart3

答案 8 :(得分:0)

我想提及其他答案中没有提到的两个选项。它们是否对您有好处,您必须自己决定。

Map >

您可以使用地图,在外部地图中使用字符串1作为键,在每个内部地图中使用字符串2作为键。

我认为这不是一个非常好的语法解决方案,但是它很简单,而且我已经在某些地方使用过它。还应该在时间和存储效率上做到这一点,但这并不是99%的情况下的主要原因。我不喜欢它的原因是我们丢失了有关键类型的明确信息:仅从代码中推断出有效键是两个字符串,不清楚阅读。

Map

这是特殊情况。我已经不止一次遇到这种情况,所以没有比这更特别的了。如果您的对象包含用作键的两个字符串,并且根据这两个字符串定义对象相等是有意义的,则根据定义equalshashCode并将对象用作键和值。

在这种情况下,人们希望使用Set而不是Map,但是Java HashSet不提供任何方法来根据一个平等的对象。所以我们确实需要地图。

一个责任是您需要创建一个新对象才能进行查找。这也适用于许多其他答案中的解决方案。

链接

Jerónimo López: Composite key in HashMaps关于地图的效率。