我需要的是一个允许多个键访问单个对象的集合。
我需要对这个对象进行频繁的更改。
它还必须对 500k+ 条目有效。
问问题
42259 次
5 回答
20
的任何实现都java.util.Map<K,V>可以做到这一点——对于可以在单独的键下添加特定值的次数没有限制：
Map<String,Integer> m = new HashMap<String, Integer>();
m.put("Hello", 5);
m.put("World", 5);
System.out.println(m); // { Hello->5, World->5 }
如果您想要一个单个键与多个值相关联的映射，这称为多映射，您可以从google java collections API或Apache 的 commons-collections获得一个
于 2009-08-06T08:24:12.093 回答
7
我对他的要求有不同的解释。如果一个人想要两个完全不同的键集来访问相同的底层值怎么办。例如：
"Hello" ------|
|----> firstObject
3 ------|
"Monkey" ------|
|----> secondObject
72 ------|
14 -----------> thirdObject
"Baseball" ------|
|----> fourthObject
18 ------|
显然有两个映射，一个用于整数键，一个用于字符串键，是行不通的，因为一个映射中的更新不会反映在另一个映射中。假设您修改了Map<String,Object>，更新“Monkey”以映射到 FifthObject。这种修改的结果是改变了Entry<String,Object>该地图内的内容，但这当然对另一张地图没有影响。因此，虽然您的意图是：
"Monkey" ------|
|----> fifthObject
72 ------|
你在现实中得到的是这样的：
"Monkey" -----------> fifthObject
72 -----------> secondObject
在这种情况下，我要做的是让两个并排映射，但不是让他们说Map<String, Integer>我会做他们Map<String, Integer[]>，其中关联的数组是单个成员数组。第一次将键与值关联时，如果尚不存在数组并且该键返回 null，则创建该数组，并将我希望与它关联的任何其他键（在该键的映射中）。随后，我只修改了数组的内容，但从不修改对数组本身的引用，这很有魅力。
"Monkey" -------> fifthObjectArray ------|
|-----> fifthObjectArray[0]
72 -------> fifthObjectArray ------|
于 2010-06-17T23:29:29.043 回答
5
嗯……</p>
Map map = new HashMap();
Object someValue = new Object();
map.put(new Object(), someValue);
map.put(new Object(), someValue);
现在地图包含两次相同的值，可以通过不同的键访问。如果这不是你要找的，你应该修改你的问题。:)
于 2009-08-06T08:25:31.250 回答
3
这可能会做你想要的：
import java.util.*;
class Value {
public String toString() {
return x.toString();
}
Integer x=0;
}
public class Main {
public static void main(String[] arguments) {
Map m=new HashMap();
final Value v=new Value();
m.put(1,v);
m.put(2,v);
System.out.println(m.get(1));
System.out.println(m.get(2));
v.x=42;
System.out.println(m.get(1));
System.out.println(m.get(2));
}
于 2009-08-06T09:09:46.447 回答
1
你的问题实际上让我想到让这门课来处理这样的事情。我目前正在研究 2D 游戏引擎，您的问题完全让我想到了我需要什么。
顺便说一句，我相信你想要的是；
一个保存键和值的对象，但您也可以获得保存的公共键值（我专门使用这个对象来减少 cpu 的使用，但只需要使用更多的内存。）
这个类的K类型是主键类型。T 类型是 HashSet 值类型。
您实现和使用此对象的方式是：
MapValueSet<ObjectType1,ObjectType2> mainmap = new
MapValueSet<ObjectType1,ObjectType2>()
HashSet<Integer> tags = new HashSet<Integer>();
public void test(){
ObjectType1 = new ObjectType1();
ObjectType2 = new ObjectType2();
tags.add(mainmap.put(ObjectType1,ObjectType2);
mainmap.get(ObjectType1,Integer);
}
您需要将唯一标签保存在您实现此功能的任何类中的集合或数组列表中，因为如果您不这样做，您将存储实体并且不知道哪个是哪个。因此，将从 put() 方法获得的整数存储到数组列表或集合中，并对其进行迭代。
您可以检查此类的值是否存在，或者该值设置为哪些键对象。
这是类 MapValueSet；
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class MapValueSet<K,T> {
Indexer indxK = new Indexer();
Indexer indxT = new Indexer();
Map<K,Integer> kTags = new HashMap<K,Integer>();
Map<T,Integer> tTags = new HashMap<T,Integer>();
Map<Integer,HashSet<Integer>> MapK = new HashMap<Integer,HashSet<Integer>>();
Map<Integer,HashSet<Integer>> MapT = new HashMap<Integer,HashSet<Integer>>();
public int put(K k, T t){
int tag = -1;
if(!kTags.containsKey(k)){
kTags.put(k, indxK.getNextTag());
}
if(!MapK.containsKey(kTags.get(k))){
MapK.put(kTags.get(k), new HashSet<Integer>());
}
if(!tTags.containsKey(t)){
tTags.put(t, tag = indxT.getNextTag());
}
if(!MapT.containsKey(tTags.get(t))){
MapT.put(tag = tTags.get(t), new HashSet<Integer>());
}
MapK.get(kTags.get(k)).add(tTags.get(t));
MapT.get(tag = tTags.get(t)).add(kTags.get(k));
return tag;
}
@SuppressWarnings("unchecked")
public T get(K k, int tag){
Object[] tArr = tTags.keySet().toArray();
for(int i = 0; i < tArr.length; i++){
if(tTags.get((T)tArr[i])== tag){
return (T)tArr[i];
}
}
return null;
}
public boolean removeAtKey(K k, T t){
int kTag = -1;
int tTag = -1;
if(kTags.get(k) != null){
kTag = kTags.get(k);
}
if(tTags.get(t) != null){
tTag = tTags.get(t);
}
if(kTag == -1 || tTag == -1){
System.out.println("Keys are Blank at: removeAtKey(k,t)");
return false;
}
boolean removed = false;
if(MapK.get(kTag) != null){
removed = MapK.get(kTag).remove(tTag);
}
if(MapT.get(tTag) != null){
MapT.get(tTag).remove(kTag);
}
if(!MapK.containsKey(kTag)){
kTags.remove(k);
indxK.removeTag(kTag);
}
if(MapK.containsKey(kTag)){
tTags.remove(t);
indxT.removeTag(tTag);
}
return removed;
}
public void removeAtValue(T t){
if(!tTags.containsKey(t)){
return;
}
Object[] keyArr = MapT.get(tTags.get(t)).toArray();
for(int i = 0; i < keyArr.length; i++){
MapK.get(keyArr[i]).remove(tTags.get(t));
}
indxT.removeTag(tTags.get(t));
MapT.remove(tTags.get(t));
tTags.remove(t);
}
public boolean mapContains(T t){
if(tTags.get(t) == null){
return false;
}
int tTag = tTags.get(t);
return MapT.get(tTag) != null && !MapT.get(tTag).isEmpty();
}
public boolean containsKey(K k){
if(kTags.get(k) == null){
return false;
}
return MapK.containsKey(kTags.get(k));
}
public boolean keyContains(K k, T t){
if(kTags.get(k) != null && tTags.get(t) != null){
return MapK.get(kTags.get(k)).contains(tTags.get(t));
}
return false;
}
@Override
public String toString(){
String s = "";
s = s+ "Key Map: " + MapK.toString() + "\n";
s = s+ "Value Map: " + MapT.toString() + "\n";
s = s+ "KeyTag Map: " + kTags.toString() + "\n";
s = s+ "ValueTag Map: " + tTags.toString() + "\n";
s = s+ "KeyTag List: " + indxK.activeSet().toString() + "\n";
s = s+ "ValueTag List: " + indxT.activeSet().toString();
return s;
}
}
于 2014-10-31T21:05:52.157 回答