HashMap.comparableClassFor(Object x)方法解读：类型/泛型相关方法

• HashMap.comparableClassFor(Object x)
• instanceof
• getClass()
• getGenericInterfaces()
• getGenericSuperclass()和getSuperclass()
• ParameterizedType
• getRawType()
• getActualTypeArguments()
• getOwnerType()
• comparableClassFor(Object x)方法总结

HashMap.comparableClassFor(Object x)

HashMap类中有一个comparableClassFor(Object x)方法，当x的类型为X，且X直接实现了Comparable接口（比较类型必须为X类本身）时，返回x的运行时类型；否则返回null。通过这个方法，我们可以搞清楚一些与类型、泛型相关的概念和方法。

先看一下例子。由于没法直接调用HashMap.comparableClassFor(Object x)，我们将这个方法复制出来。

 

public class Demo {
    public static void main(String[] args) {
        System.out.println(comparableClassFor(new A()));    // null,A does not implement Comparable.
        System.out.println(comparableClassFor(new B()));    // null,B implements Comparable, compare to Object.
        System.out.println(comparableClassFor(new C()));    // class Demo$C,C implements Comparable, compare to itself.
        System.out.println(comparableClassFor(new D()));    // null,D implements Comparable, compare to its sub type.
        System.out.println(comparableClassFor(new F()));    // null,F is C's sub type.
    }

    static class A{}
    static class B implements Comparable<Object>{
        @Override
        public int compareTo(Object o) {return 0;}
    }
    static class C implements Comparable<C>{
        @Override
        public int compareTo(C o) {return 0;}

    }
    static class D implements Comparable<E>{
        @Override
        public int compareTo(E o) {return 0;}
    }
    static class E{}
    static class F extends C{}

    /**
     * Returns x's Class if it is of the form "class C implements
     * Comparable<C>", else null.
     */
    static Class<?> comparableClassFor(Object x) {
        if (x instanceof Comparable) {
            Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
            if ((c = x.getClass()) == String.class) // bypass checks
                return c;
            if ((ts = c.getGenericInterfaces()) != null) {
                for (int i = 0; i < ts.length; ++i) {
                    if (((t = ts[i]) instanceof ParameterizedType) &&
                        ((p = (ParameterizedType)t).getRawType() ==
                         Comparable.class) &&
                        (as = p.getActualTypeArguments()) != null &&
                        as.length == 1 && as[0] == c) // type arg is c
                        return c;
                }
            }
        }
        return null;
    }
}

结果与注释描述的一致，只有当传入对象的运行时类型符合”class C implements Comparable”这个条件时，返回对象的运行时类型，否则返回null。下面看一下这个方法的过程。

 

instanceof

x instanceof Comparable

• insanceof可以理解为是某种类型的实例，无论是运行时类型，还是它的父类，它实现的接口，他的父类实现的接口，甚至它的父类的父类的父类实现的接口的父类的父类，总之，只要在继承链上有这个类型就可以了。

getClass()

c = x.getClass()

• 与instanceof相应对的是getClass()方法，无论该对象如何转型，getClass()返回的只会是它的运行时类型，可以简单的理解为它的实际类型，也就是new它的时候的类型。 
  有一种例外情况，匿名对象。当匿名对象调用getClass()时返回的是依赖它的对象的运行时类型，并以1,2,3…的索引区分。

public class Demo {
    public static void main(String[] args) {
        D d = new D();
        System.out.println(new A(){}.getClass());   // class Demo$1
        System.out.println(new B(){}.getClass());   // class Demo$2
        System.out.println(new Comparable<Object>(){    // class Demo$3
            @Override
            public int compareTo(Object o) {
                return 0;
            }}.getClass());
        System.out.println(d.c.getClass()); // class D$1
    }
}

abstract class A{}
abstract class B{}
abstract class C{}
class D{
    C c;
    D(){
        c= new C(){};
    }
}

getGenericInterfaces()

ts = c.getGenericInterfaces()

getGenericInterfaces()方法返回的是该对象的运行时类型“直接实现”的接口，这意味着： 

• 返回的一定是接口。
• 必然是该类型自己实现的接口，继承过来的不算。

getGenericSuperclass()和getSuperclass()

这两个方法虽然没有出现在comparableClassFor(Object x)中，这里也顺便看一下。通过简单的例子，可以看到： 

• getSuperclass()返回的是直接父类的类型，不包括泛型参数。
• getGenericSuperclass()返回的是包括泛型参数在内的直接父类。
• 注意如果父类声明了泛型，但子类继承时没有为父类实现该泛型，这时候也是没有泛型参数的。

ParameterizedType

((t = ts[i]) instanceof ParameterizedType)

ParameterizedType是Type接口的子接口，表示参数化的类型，即实现了泛型参数的类型。需要注意： 

• 如果直接用bean对象instanceof ParameterizedType，结果都是false。
• Class对象不能instanceof ParameterizedType，编译会报错。
• 只有用Type对象instanceof ParameterizedType才能得到想要的比较结果。可以这么理解：一个Bean类不会是ParameterizedType，只有代表这个Bean类的类型（Type）才可能是ParameterizedType。
• 实现泛型参数，可以是给泛型传入了一个真实的类型，或者传入另一个新声明的泛型参数；只声明泛型而不实现，instanceof Type为false。

getRawType()

• getRawType()方法返回声明了这个类型的类或接口，也就是去掉了泛型参数部分的类型对象。

getActualTypeArguments()

• 与getRawType()相对应，getActualTypeArguments()以数组的形式返回泛型参数列表。
• 注意，这里返回的是实现该泛型时传入的参数，可以看下方代码的打印结果： 
• 当传入的是真实类型时，打印的是全类名。
• 当传入的是另一个新声明的泛型参数时 ，打印的是代表该泛型参数的符号。

getOwnerType()

• ParameterizedType接口还有一个getOwnerType()方法，如果该类型是一个内部类/接口，返回它的外部类/接口。如果该类型不是内部类/接口，返回null。

 

static Class<?> comparableClassFor(Object x) {
        if (x instanceof Comparable) {  // 判断是否实现了Comparable接口
            Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
            if ((c = x.getClass()) == String.class) 
                return c;   // 如果是String类型，直接返回String.class
            if ((ts = c.getGenericInterfaces()) != null) {  // 判断是否有直接实现的接口
                for (int i = 0; i < ts.length; ++i) {   // 遍历直接实现的接口
                    if (((t = ts[i]) instanceof ParameterizedType) &&   // 该接口实现了泛型
                        ((p = (ParameterizedType)t).getRawType() == // 获取接口不带参数部分的类型对象
                         Comparable.class) &&   //  该类型是Comparable
                        (as = p.getActualTypeArguments()) != null &&    // 获取泛型参数数组
                        as.length == 1 && as[0] == c)   // 只有一个泛型参数，且该实现类型是该类型本身
                        return c;   // 返回该类型
                }
            }
        }
        return null;
    }