当泛型被添加到 1.5 时，java.lang.reflect添加了一个 Type与各种子类型接口(interface)以表示类型。 Class retrofit 以实现 Type对于 pre-1.5 类型。 Type子类型可用于 1.5 的新泛型类型。

这一切都很好。有点尴尬Type必须沮丧才能做任何有用的事情，但可以通过试验、错误、摆弄和(自动)测试来实现。除非涉及到实现......

应该怎样equals和 hashCode予以实现。 ParameterizedType 的 API 描述Type 的子类型说:

Instances of classes that implement this interface must implement an equals() method that equates any two instances that share the same generic type declaration and have equal type parameters.

(我猜这意味着 getActualTypeArguments 和 getRawType 但不是 getOwnerType ??)

我们从java.lang.Object总承包契约(Contract)中得知那hashCode也必须实现，但似乎没有关于此方法应产生什么值的规范。

Type 的其他子类型都没有似乎提到 equals或 hashCode ，除此之外 Class每个值都有不同的实例。

那么我在 equals 中放了什么？和 hashCode ？

(如果您想知道，我正在尝试用类型参数替换实际类型。所以如果我知道 在运行时 TypeVariable<?> T 是 Class<?> String 那么我想要替换 Type s，所以 List<T> 变成 List<String> ， T[] 变成 String[] ， List<T>[] (可能发生!)变成 List<String>[] 等)

或者我是否必须创建自己的并行类型层次结构(出于假定的法律原因而无需复制 Type)？ (有图书馆吗？)

编辑: 有几个关于我为什么需要这个的问题。事实上，为什么要查看泛型类型信息？

我从非通用类/接口(interface)类型开始。 (如果你想要一个参数化类型，比如 List<String> 那么你总是可以添加一个新类的间接层。)然后我关注字段或方法。这些可能引用参数化类型。只要他们不使用通配符，我仍然可以在面对 T 之类的东西时计算出实际的静态类型。 .

通过这种方式，我可以用高质量的静态类型做任何事情。这些都不是instanceof动态类型检查就在眼前。

我的具体用法是序列化。但它可以适用于反射的任何其他合理使用，例如测试。

我用于以下替换的代码的当前状态。 typeMap是 Map<String,Type> .作为“原样”快照呈现。根本没有整理(throw null; 如果你不相信我的话)。

   Type substitute(Type type) {
      if (type instanceof TypeVariable<?>) {
         Type actualType = typeMap.get(((TypeVariable<?>)type).getName());
         if (actualType instanceof TypeVariable<?>) { throw null; }
         if (actualType == null) {
            throw new IllegalArgumentException("Type variable not found");
         } else if (actualType instanceof TypeVariable<?>) {
            throw new IllegalArgumentException("TypeVariable shouldn't substitute for a TypeVariable");
         } else {
            return actualType;
         }
      } else if (type instanceof ParameterizedType) {
         ParameterizedType parameterizedType = (ParameterizedType)type;
         Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
         int len = actualTypeArguments.length;
         Type[] actualActualTypeArguments = new Type[len];
         for (int i=0; i<len; ++i) {
            actualActualTypeArguments[i] = substitute(actualTypeArguments[i]);
         }
         // This will always be a Class, wont it? No higher-kinded types here, thank you very much.
         Type actualRawType = substitute(parameterizedType.getRawType());
         Type actualOwnerType = substitute(parameterizedType.getOwnerType());
         return new ParameterizedType() {
            public Type[] getActualTypeArguments() {
               return actualActualTypeArguments.clone();
            }
            public Type getRawType() {
               return actualRawType;
            }
            public Type getOwnerType() {
               return actualOwnerType;
            }
            // Interface description requires equals method.
            @Override public boolean equals(Object obj) {
               if (!(obj instanceof ParameterizedType)) {
                  return false;
               }
               ParameterizedType other = (ParameterizedType)obj;
               return
                   Arrays.equals(this.getActualTypeArguments(), other.getActualTypeArguments()) &&
                   this.getOwnerType().equals(other.getOwnerType()) &&
                   this.getRawType().equals(other.getRawType());
            }
         };
      } else if (type instanceof GenericArrayType) {
         GenericArrayType genericArrayType = (GenericArrayType)type;
         Type componentType = genericArrayType.getGenericComponentType();
         Type actualComponentType = substitute(componentType);
         if (actualComponentType instanceof TypeVariable<?>) { throw null; }
         return new GenericArrayType() {
            // !! getTypeName? toString? equals? hashCode?
            public Type getGenericComponentType() {
               return actualComponentType;
            }
            // Apparently don't have to provide an equals, but we do need to.
            @Override public boolean equals(Object obj) {
               if (!(obj instanceof GenericArrayType)) {
                  return false;
               }
               GenericArrayType other = (GenericArrayType)obj;
               return
                   this.getGenericComponentType().equals(other.getGenericComponentType());
            }
         };
      } else {
         return type;
      }
   }

最佳答案

10 年来，我一直在以令人不满意的方式解决这个问题。首先是 Guice’s MoreTypes.java , 复制粘贴并用 Gson’s GsonTypes.java 修改, 又在 Moshi’s Util.java .

Moshi 有我最好的方法，这并不是说它很好。

您不能调用 equals()在 Type 的任意实现上，并期望它能工作。

这是因为 Java 类型 API 提供了多种不兼容的方法来为简单类的数组建模。你可以做一个Date[]作为 Class<Date[]>或作为 GenericArrayType其组件类型为Date .我相信你会通过对类型字段的反射(reflection)得到前者 Date[]后者来自反射作为类型字段的参数 List<Date[]> .

未指定哈希码。

我还致力于 Android 使用的这些类的实现。非常早期的 Android 版本与 Java 具有不同的哈希码，但您今天在野外发现的所有东西都使用与 Java 相同的哈希码。

toString 方法不好

如果您在错误消息中使用类型，那么不得不编写特殊代码来很好地打印它们是很糟糕的。

复制粘贴和悲伤

我的建议是不要对未知类型的实现使用 equals() + hashCode()。使用规范化函数转换为特定的已知实现，并仅在您控制的实现中进行比较。

关于java - Type 类型层次类型应该如何实现？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/53947920/