5

我想创建一个地图，它将提供泛型的好处，同时支持多种不同类型的值。我认为以下是泛型集合的两个主要优点：

  • 编译时警告将错误的东西放入集合中
  • 从集合中取出东西时无需强制转换

所以我想要的是一张地图：

  • 它支持多个值对象，
  • 检查放入地图的值（最好在编译时）
  • 知道从地图获取时对象值是什么。

使用泛型的基本情况是：

Map<MyKey, Object> map = new HashMap<MyKey, Object>();
// No type checking on put();
map.put(MyKey.A, "A");  
map.put(MyKey.B, 10);
// Need to cast from get();
Object a = map.get(MyKey.A); 
String aStr = (String) map.get(MyKey.A);

我找到了解决第二个问题的方法，方法是创建一个 AbstractKey，它由与此键关联的值类生成：

public interface AbstractKey<K> {
}
public enum StringKey implements AbstractKey<String>{
  A,B;  
}
public enum IntegerKey implements AbstractKey<Integer>{
  C,D;
}

然后我可以创建一个 TypedMap，并覆盖 put() 和 get() 方法：

public class TypedMap extends HashMap<AbstractKey, Object> {
  public <K> K put(AbstractKey<K> key, K value) {
    return (K) super.put(key, value);
  }
  public <K> K get(AbstractKey<K> key){
    return (K) super.get(key);
  }
}

这允许以下操作：

TypedMap map = new TypedMap();
map.put(StringKey.A, "A");
String a = map.get(StringKey.A);

但是，如果我为键输入错误的值，我不会收到任何编译错误。相反，我ClassCastException在 get() 上获得了运行时。

map.put(StringKey.A, 10); // why doesn't this cause a compile error?
String a = map.get(StringKey.A); // throws a ClassCastException

如果这个 .put() 可以给出编译错误，那将是理想的。作为当前的第二好，我可以ClassCastException在 put() 方法中抛出运行时。

// adding this method to the AbstractKey interface:
public Class getValueClass();

// for example, in the StringKey enum implementation:
public Class getValueClass(){
  return String.class;
}

// and override the put() method in TypedMap:
public <K> K put(AbstractKey<K> key, K value){
  Object v = key.getValueClass().cast(value);
  return (K) super.put(key, v);
}

现在，在ClassCastException放入地图时会抛出 ，如下所示。这是更可取的，因为它允许更轻松/更快的调试来识别错误的键/值组合已放入 TypedMap 的位置。

map.put(StringKey.A, 10); // now throws a ClassCastException

所以，我想知道：

  • 为什么不会map.put(StringKey.A, 10)导致编译错误？

  • 我如何调整此设计以在放置时获得有意义的编译错误，其中值不是键的关联泛型类型？

  • 这是一个合适的设计来实现我想要的（见顶部）？（任何其他想法/评论/警告也将不胜感激......）

  • 是否有替代设计可以用来实现我想要的？

编辑 - 澄清：

  • 如果你认为这是一个糟糕的设计——你能解释一下为什么吗？
  • 我使用 String 和 Integer 作为示例值类型 - 实际上，我有许多不同的键/值类型对，我希望能够使用它们。我想在一张地图中使用它们——这就是目标。
4

4 回答 4

3

你在搞乱泛型并以一种糟糕的方式重载。您正在扩展HashMap<AbstractKey, Object>，因此您的类正在继承方法Object put(AbstractKey k, Object v)。在您的类中，您正在定义另一个put具有不同签名的方法，这意味着您只是重载该put方法，而不是覆盖它。

当您编写map.put(StringKey.A, 10)时，编译器会尝试找到符合参数类型的方法put(StringKey, Integer)。您的方法的签名不适用，但继承put的 's 确实 -StringKey兼容AbstractKey并Integer兼容Object. 因此，它将该代码编译为对HashMap.put.

解决此问题的方法：重命名put为某个自定义名称，例如typedPut.

顺便说一句，从经验中谈起您的方法非常有趣且引人入胜，但在现实生活中，这不值得麻烦。

于 2012-05-03T10:16:23.683 回答
3

第 29 条：考虑类型安全的异构容器。—<a href="http://my.safaribooksonline.com/9780137150021?portal=informit" rel="nofollow">Joshua Bloch，Effective Java，第二版，第 5 章：泛型。

于 2012-05-03T11:14:19.087 回答
1

恕我直言，每个问题都来自原始设计的味道：想要将不同类型的值放入地图中。我会将您的 Integer 和 String 值包装成一个通用Value类型。像这样的东西：

public class Value {
    private enum Type {
        STRING, INTEGER;
    }

    private Type type;
    private Object value;

    private Value(Object value, Type type) {
        this.value = value;
        this.type = type;
    }

    public static Value fromString(String s) {
        return new Value(s, Type.STRING);
    }

    public static Value fromInteger(Integer i) {
        return new Value(i, Type.INTEGER);
    }

    public Type getType() {
        return this.type;
    }

    public String getStringValue() {
        return (String) value;
    }

    public Integer getIntegerValue() {
        return (Integer) value;
    }

    // equals, hashCode
}

这样，您只需要一个Map<SomeKey, Value>，就可以安全地从地图中获取值：

Value v = map.get(someKey);
if (v.getType() == Type.STRING) {
    String s = v.getStringValue();
}
else if (v.getType() == Type.INTEGER) {
    Integer i = v.getIntegerValue();
}
于 2012-05-03T10:24:58.730 回答
0

考虑一下：（感谢 Effective java）

public class TypedMap {

    private Map<AbstractKey<?>, Object> map = new HashMap<AbstractKey<?>, Object>();

    public <T> T get(AbstractKey<T> key) {
        return key.getType().cast(map.get(key));
    }

    public <T> T put(AbstractKey<T> key, T value) {
        return key.getType().cast(map.put(key, key.getType().cast(value)));
    }

    public static interface AbstractKey<K> {

        Class<K> getType();
    }

    public static enum StringKey implements AbstractKey<String> {

        A, B;

        public Class<String> getType() {
            return String.class;
        }
    }

    public static enum IntegerKey implements AbstractKey<Integer> {

        C, D;

        public Class<Integer> getType() {
            return Integer.class;
        }
    }
  }

这会产生编译时错误

TypedMap map = new TypedMap();
TypedMap.AbstractKey<Integer> intKey = TypedMap.IntegerKey.C;
TypedMap.AbstractKey<String> strKey = TypedMap.StringKey.A;
map.put(strKey, "A");
map.put(intKey, 10);
map.put(strKey, 10); // this cause a compile error?
于 2012-05-03T13:06:39.903 回答