Question

是否可能有一个HashMap带有一个统一的键（例如'String'类型），但是其值却有所不同。例如，考虑HashMap m 。我需要以下功能：

brew install freeglut

然后根据所获取的值的类型，可以进行进一步的处理。

Answer 1

您可以执行以下操作：

HashMap<String, Object> m = new HashMap<>();

//Retreive a string:
String myString = (String) m.get("UID1");

//Retreive a variable of any type
MyType variable = (MyType) m.get("UID2");

或者，如果可能，您可以将哈希图的类型设置为所需的类型，如果需要String，则可以执行toString（）。

例如：

HashMap<String, MyObject> m = new HashMap<>();

//Retreive the string representation of your object:
String myString = m.get("UID1").toString();

//Retreive the object:
MyObject object = m.get("UID2");

Answer 2

如果要使用字符串作为键，则将失去类型安全性，并且无法解决。您将只是放弃编译器拥有的所有信息，而您将被迫手动提供它。

相反，您可以对String使用某种包装器类，该包装器类还包含类型信息。这样，您就可以获得合理的类型安全性。

以下是Foo类的示例，该类包装了HashMap并提供了类型安全的put和get方法：

public class Foo {

static class TypedKey<T> {
    final Class<T> clazz;
    final String id;
    public TypedKey(Class<T> clazz, String id) {
        this.clazz = clazz;
        this.id = id;
    }
    @Override
    public int hashCode() {
        return id.hashCode();
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof TypedKey)) {
            return false;
        }
        return id.equals(((TypedKey<?>) obj).id);
    }
    @Override
    public String toString() {
        return id;
    }
}

static final TypedKey<String> STRING_KEY = new TypedKey<>(String.class, "String");
static final TypedKey<Integer> INTEGER_KEY = new TypedKey<>(Integer.class, "Integer");

public static void main(String[] args) {
    Foo foo = new Foo();

    foo.put(STRING_KEY, "bar");
    String bar = foo.get(STRING_KEY);

    foo.put(INTEGER_KEY, 42);
    int baz = foo.get(INTEGER_KEY);

    foo.put(STRING_KEY, 42);
}

final Map<TypedKey<?>, Object> map = new HashMap<>();

public <T> void put(TypedKey<T> key, T value) {
    map.put(key, value);
}

@SuppressWarnings("unchecked")
public <T> T get(TypedKey<T> key) {
    return (T) map.get(key);
}

}

Answer 3

请考虑将类用作键，而不是st。这将使您有机会以类型安全的方式执行此操作，如Joshua Bloch所说的“类型安全的异构容器”：

public static class Container {
  private Map<Class<?>, Object> store = new HashMap<>();

  public <T> void put(Class<T> type, T value) {
    store.put(Objects.requireNonNull(type), value);
  }

  public <T> T get(Class<T> type) {
    return type.cast(store.get(type));
  }
}

您可以放置一个值并以这种类型安全的方式检索它：

Container container = new Container();

container.put(String.class, "test");
container.put(Integer.class, Integer.valueOf(5));

String s = container.get(String.class);
Integer i = container.get(Integer.class);

但这仅在每种类型只有一个值的情况下起作用。

HashMaps中的异构类型获取

3 个答案: