我想将一组对象存储在 hashmap 中，其中键应该是两个字符串值的组合。有没有办法做到这一点？
我可以简单地连接两个字符串，但我确信有更好的方法来做到这一点。
问问题
51169 次
9 回答
53
您可以有一个包含两个字符串的自定义对象：
class StringKey {
private String str1;
private String str2;
}
问题是，您需要确定两个此类对象的相等性测试和哈希码。
相等可能是两个字符串的匹配，而哈希码可能是连接成员的哈希码（这是有争议的）：
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();
}
}
于 2012-07-28T11:38:01.960 回答
13
你不需要重新发明轮子。只需使用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
快乐编码！
于 2016-07-07T10:24:30.647 回答
11
public int hashCode() {
return (str1 + str2).hashCode();
}
这似乎是一种生成 hashCode 的糟糕方法：每次计算 hash 码时都创建一个新的字符串实例太糟糕了！（即使生成一次字符串实例并缓存结果也是不好的做法。）
这里有很多建议：
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();
这是一个非常基本的实现。通过链接提供了很多建议，以建议更好的调整策略。
于 2013-08-02T18:37:46.703 回答
8
为什么不创建一个（比如说）Pair对象，其中包含两个字符串作为成员，然后使用它作为键？
例如
public class Pair {
private final String str1;
private final String str2;
// this object should be immutable to reliably perform subsequent lookups
}
不要忘记equals()和hashCode()。有关HashMap 和键的更多信息，请参阅此博客条目，包括关于不变性要求的背景。如果您的密钥不是不可变的，那么您可以更改其组件，随后的查找将无法找到它（这就是为什么不可变对象例如String是密钥的良好候选者的原因）
你是对的，连接并不理想。在某些情况下它会起作用，但它通常是一个不可靠且脆弱的解决方案（例如AB/C与A/BC是否不同？）。
于 2012-07-28T11:36:59.353 回答
5
我有一个类似的案例。我所做的就是连接两个由波浪号 ( ~ ) 分隔的字符串。
所以当客户端调用服务函数从地图中获取对象时，它看起来是这样的：
MyObject getMyObject(String key1, String key2) {
String cacheKey = key1 + "~" + key2;
return map.get(cachekey);
}
这很简单，但它有效。
于 2012-07-28T12:06:25.923 回答
5
我看到很多人使用嵌套地图。也就是说，要映射Key1 -> Key2 -> Value（我使用计算机科学/又名 haskell 通用符号进行(Key1 x Key2) -> Value映射，它有两个参数并产生一个值），您首先提供第一个键 - 这会返回一个（部分）映射 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)
}
我不确定它是否比普通的复合键结构更好。你可以对此发表评论。
于 2014-02-03T16:11:38.197 回答
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
}
}
于 2014-06-04T17:14:43.240 回答
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);}
公共静态字符串 FAKE_KEY_SEPARATOR = "~";
输入： fakeMapKey("keyPart1","keyPart2","keyPart3");
输出：keyPart1~keyPart2~keyPart3
于 2013-03-15T15:10:51.300 回答
0
我想提两个我认为其他答案未涵盖的选项。它们是否适合您的目的，您必须自己决定。
地图<String, Map<String, YourObject>>
您可以使用映射映射，在外部映射中使用字符串 1 作为键，在每个内部映射中使用字符串 2 作为键。
我不认为这在语法方面是一个非常好的解决方案，但它很简单，而且我已经看到它在某些地方使用过。它还应该在时间和内存上是有效的，而这在 99% 的情况下不应该是主要原因。我不喜欢它的是我们丢失了关于密钥类型的显式信息：它只是从代码中推断出有效密钥是两个字符串，阅读不清楚。
地图<你的对象，你的对象>
这是针对特殊情况的。我不止一次遇到过这种情况，所以没有比这更特别的了。如果您的对象包含用作键的两个字符串，并且基于两者定义对象相等性是有意义的，则定义equals并hashCode根据并将对象用作键和值。
在这种情况下，人们可能希望使用 aSet而不是 a Map，但是 JavaHashSet没有提供任何方法来从基于相等对象的集合中检索对象。所以我们确实需要地图。
一个责任是您需要创建一个新对象才能进行查找。这也适用于许多其他答案中的解决方案。
关联
Jerónimo López：HashMaps 中的复合键关于地图映射的效率。
于 2020-12-08T15:38:50.937 回答