Java集合(五二): comparableClassFor(Object x)方法解读

最新推荐文章于 2021-09-24 17:05:56 发布
最新推荐文章于 2021-09-24 17:05:56 发布
阅读量390 收藏 2
点赞数
分类专栏： Java集合 文章标签： java
原文链接：https://blog.csdn.net/qpzkobe/article/details/79533237
版权

目录

1、comparableClassFor(Object x)方法解读

1.1、方法说明

1.2、instanceof

1.3、getClass()

1.4、getGenericInterfaces()

1.5、getGenericSuperclass()和getSuperclass()

1.6、ParameterizedType

1.7、getRawType()

1.8、getActualTypeArguments

1.9、getOwnerType()

2、总结

1、comparableClassFor(Object x)方法解读

1.1、方法说明

        当x的类型为A，且A直接实现了Comparable接口（比较类型必须为A类本身）时，返回x的运行时类型；否则返回null。

 class A implements Comparable<A>{}， A x = new A();

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<C>”这个条件时，返回对象的运行时类型，否则返回null

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 com.sankuai.payrc.demo.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 {
        }

    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;
    }
}

过程详解

1.2、instanceof

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

1.3、getClass()

c = x.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 com.sankuai.payrc.demo.Demo$1
        System.out.println(new B(){}.getClass());   // class com.sankuai.payrc.demo.Demo$2
        System.out.println(new Comparable<Object>(){
            @Override
            public int compareTo(Object o) {
                return 0;
            }}.
                getClass());//class com.sankuai.payrc.demo.Demo$3
        System.out.println(d.c.getClass()); //class com.sankuai.payrc.demo.D$1
        System.out.println(d.getClass()); // class com.sankuai.payrc.demo.D
    }
}

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

1.4、getGenericInterfaces()

ts = c.getGenericInterfaces()

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

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

        public static void main(String[] args) {
            Grand child = new Child();
            System.out.println(child.getClass());
            Type[] types = child.getClass().getGenericInterfaces();
            if (types != null) {
                for (Type type : types) {
                    System.out.println(type.getTypeName());//java.lang.Cloneable
                }
            }
        }
    }

    abstract class Grand implements Comparable<Grand>{}
    abstract class Super extends Grand implements Serializable {}
    class Child extends Super implements Cloneable {public int compareTo(Grand o)     
       {return 0;
    }
}

1.5、getGenericSuperclass()和getSuperclass()

  • 这两个方法虽然没有出现在comparableClassFor(Object x)中，这里也顺便看一下。通过简单的例子，可以看到： 
    • getSuperclass()返回的是直接父类的类型，不包括泛型参数。
    • getGenericSuperclass()返回的是包括泛型参数在内的直接父类。
    • 注意如果父类声明了泛型，但子类继承时没有为父类实现该泛型，这时候也是没有泛型参数的。
public class Demo {

    public static void main(String[] args) {
        Grand child = new Child();
        System.out.println(child.getClass());//class com.sankuai.payrc.demo.Child
        Type type1 = child.getClass().getGenericSuperclass();
        Class<?> class1 = child.getClass().getSuperclass();
        //com.sankuai.payrc.demo.Super<java.lang.Integer, java.lang.Integer>
        System.out.println(type1.getTypeName());
        //com.sankuai.payrc.demo.Super
        System.out.println(class1.getTypeName());   // Super

        Grand child2 = new Child2();
        Type type2 = child2.getClass().getGenericSuperclass();
        Class<?> class2 = child2.getClass().getSuperclass();
        //com.sankuai.payrc.demo.Super<A, B>
        System.out.println(type2.getTypeName());
        //com.sankuai.payrc.demo.Super
        System.out.println(class2.getTypeName());
    }
}
abstract class Grand implements Comparable<Grand>{}
abstract class Super<T,E> extends Grand implements Serializable{}
class Child extends Super<Integer,Integer> implements Cloneable {public int compareTo(Grand o) {return 0;}}
class Child2<A,B,C> extends Super<A,B>{public int compareTo(Grand o) {return 0;}}

1.6、ParameterizedType

((t = ts[i]) instanceof ParameterizedType)
  • ParameterizedType是Type接口的子接口，表示参数化的类型，即实现了泛型参数的类型。需要注意： 
    • 如果直接用bean对象instanceof ParameterizedType，结果都是false。
    • Class对象不能instanceof ParameterizedType，编译会报错。
    • 只有用Type对象instanceof ParameterizedType才能得到想要的比较结果。可以这么理解：一个Bean类不会是ParameterizedType，只有代表这个Bean类的类型（Type）才可能是ParameterizedType。
    • 实现泛型参数，可以是给泛型传入了一个真实的类型，或者传入另一个新声明的泛型参数；只声明泛型而不实现，instanceof ParameterizedType为false。
public class Demo {

        public static void main(String[] args) {
            Grand child1 = new Child();
            Grand child2_1 = new Child2();
            Grand child2_2 = new Child2<String, String>();
            Child2<String, String> child2_3 = new Child2<String, String>();
            Child3<String, String> child3 = new Child3<String,String>();
            System.out.println(child1 instanceof ParameterizedType);    // flase
            System.out.println(child2_1 instanceof ParameterizedType);  // flase
            System.out.println(child2_2 instanceof ParameterizedType);  // flase
            System.out.println(child2_3 instanceof ParameterizedType);  // flase
            
            System.out.println(child1.getClass().getGenericSuperclass().getTypeName());
            //com.sankuai.payrc.demo.Super<java.lang.String, java.lang.String>
            System.out.println(child2_1.getClass().getGenericSuperclass().getTypeName());
            //com.sankuai.payrc.demo.Super<A, B>
            System.out.println(child3.getClass().getGenericSuperclass().getTypeName());
            //com.sankuai.payrc.demo.Super

            System.out.println(child1.getClass().getGenericSuperclass() instanceof ParameterizedType);  // true
            System.out.println(child2_1.getClass().getGenericSuperclass() instanceof ParameterizedType);    // true
            System.out.println(child3.getClass().getGenericSuperclass() instanceof ParameterizedType);  // flase
            // System.out.println(child1.getClass() instanceof ParameterizedType);  // Complie Errors
        }
    }
class Grand{}
class Super<A,B> extends Grand{}
class Child extends Super<String,String>{}
class Child2<A,B> extends Super<A,B>{}
class Child3<A,B> extends Super{}

public class Demo {

    public static void main(String[] args) {
        Grand grand = new Grand();
        Type[] types = grand.getClass().getGenericInterfaces();
        if (types != null) {
            for (Type type : types) {
                System.out.println(type.getTypeName() + " " + (type instanceof ParameterizedType));
//                com.sankuai.payrc.demo.IA<java.lang.String, java.lang.Integer> true
//                com.sankuai.payrc.demo.IB false
//                com.sankuai.payrc.demo.IC<X> true
//                com.sankuai.payrc.demo.ID false
            }
        }
    }
}
interface IG<X,Y>{}
interface IA<X,Y>{}
interface IB extends IG{}
interface IC<X>{}
interface ID<X>{}
class Grand<X> implements IA<String,Integer>,IB,IC<X>,ID{}

1.7、getRawType()

(p = (ParameterizedType)t).getRawType()
  • getRawType()方法返回声明了这个类型的类或接口，也就是去掉了泛型参数部分的类型对象。
public class Demo {

    public static void main(String[] args) {
        Grand grand = new Grand();
        Type[] types = grand.getClass().getGenericInterfaces();
        if (types != null) {
            for (Type type : types) {
                if(type instanceof ParameterizedType){
                    System.out.println(((ParameterizedType) type).getRawType());
//                    interface com.sankuai.payrc.demo.IA
//                    interface com.sankuai.payrc.demo.IC
                }
            }
        }
    }
}
interface IG<X,Y>{}
interface IA<X,Y>{}
interface IB extends IG{}
interface IC<X>{}
interface ID<X>{}
class Grand<X> implements IA<String,Integer>,IB,IC<X>,ID{}

1.8、getActualTypeArguments

(as = p.getActualTypeArguments())
  • 与getRawType()相对应，getActualTypeArguments()以数组的形式返回泛型参数列表。
  • 注意，这里返回的是实现该泛型时传入的参数，可以看下方代码的打印结果： 
    • 当传入的是真实类型时，打印的是全类名。
    • 当传入的是另一个新声明的泛型参数时 ，打印的是代表该泛型参数的符号。
public class Demo {
    public static void main(String[] args) {
        Grand grand = new Grand();
        Type[] types = grand.getClass().getGenericInterfaces();
        if (types != null) {
            for (Type type : types) {
                if(type instanceof ParameterizedType){
                    System.out.println(type.getTypeName());
                    Type[] typeArguments = ((ParameterizedType) type).getActualTypeArguments();
                    if(typeArguments != null){
                        for (Type typeArg : typeArguments) {
                            System.out.println(typeArg.getTypeName());
                            // Output result:
                            // IA<java.lang.String, java.lang.Integer>
                            // java.lang.String
                            // java.lang.Integer
                            // IC<X>
                            // X
                        }
                    }
                }
            }
        }
    }
}
interface IG<X,Y>{}
interface IA<X,Y>{}
interface IB extends IG{}
interface IC<X>{}
interface ID<X>{}
class Grand<X> implements IA<String,Integer>,IB,IC<X>,ID{}

1.9、getOwnerType()

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

public class Demo {
    public static void main(String[] args) {
        Outer<String> outer = new Outer<>();
        Outer<String>.Child<Integer> child = outer.new Child<>();
        Type type = child.getClass().getGenericSuperclass();
        if(type instanceof ParameterizedType){
            System.out.println(((ParameterizedType) type).getOwnerType()); //Outer<X>
        }
    }
}
 
class Outer<X>{
    class Inner<Y>{}
    class Child<Y> extends Inner<Y>{}
}

2、总结

 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;
    }

原文：HashMap.comparableClassFor(Object x)方法解读_qpzkobe的博客-CSDN博客

CodingALife
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HashMap中的comparableClassFor方法
shenshaoming的博客
07-11 1059
/* * 首先判断是否实现了Comparable接口,如果实现了则判断x是不是String类型 * 如果是String类则返回该String.class */ static Class<?> comparableClassFor(Object x) { if (x instanceof Comparable) { Class<?> c; Type[...
Java集合框架总结：TreeSet类的排序问题
01-31
java提供了一个Comparable接口，该接口里定义了一个compareTo(Objectobj)方法，该方法返回一个整数值，实现该接口的类必须实现该方法，实现了该接口的类的对象就可以比较大小。当一个对象调用该方法与另一个对象进行...
HashMap.comparableClassFor(Object x)方法解读：类型/泛型相关方法
weixin_30583563的博客
07-31 161
HashMap.comparableClassFor(Object x) instanceof getClass() getGenericInterfaces() getGenericSuperclass()和getSuperclass() ParameterizedType getRawType() getActualTypeArguments() getOw...
JDK8中HashMap的comparableClassFor方法
weixin_44594041的博客
10-29 241
JDK8中HashMap的comparableClassFor方法作用：Returns x’s Class if it is of the form “class C implements Comparable”, else null. 翻译过来，大概的意思是：如果类C实现了Comparable ,即返回对象x的类C的Class。 例如：String实现了Comparable< String >，那么则返回String.class。若没有，则返回null。 public final clas.
Java集合(五三)：comparableClassFor、compareComparables、tieBreakOrder方法解读
mingyuli的博客
09-24 319
目录 一、概述 二、方法解析 一、概述 在之前的文章里已经分析过，在发生hash碰撞（多个key的hash值相同）的时候，hashMap首先会采用链表进行存储，当链表节点数量达到一定阈值（8）会将链表上的节点再组织成一棵红黑树。红黑树是一种二叉树，每个父节点可以由左右两个节点。 当put一个新元素时，如果该元素键的hash值小于当前节点的hash值的时候，就会作为当前节点的左节点；hash值大于当前节点hash值得时候作为当前节点的右节点。那么hash值相同的时候呢？这时还是会先尝...
jdk1.8 hashmap.comparableClassFor方法解析
qsdnmd的博客
10-01 437
/** * Returns x's Class if it is of the form "class C implements * Comparable&lt;C&gt;", else null. * 如果对象x的类型实现了Comparable&lt;C&gt;接口，那么返回x的类型，否则返回nul * 总之方法的目的就是为了看看x的class是否 imp...
Java总结篇系列：java.lang.Object
01-20
　Java作为一个庞大的知识体系，涉及到的知识点繁多，本文将从Java中基本的类java.lang.Object开始谈起。 　Object类是Java中其他所有类的祖先，没有Object类Java面向对象无从谈起。作为其他所有类的基类，Object...
Java Object toString方法原理解析
08-19
Java Object toString方法原理解析 Java Object 的 toString 方法是每个 Java 开发者都应该了解的基础知识。本文将通过示例代码详细介绍 Java Object toString 方法的原理解析，帮助开发者更好地理解和应用此方法。...
java集合排序方法总结共13页.pdf.zip
最新发布
10-30
本篇总结主要围绕Java集合的排序方法进行详细阐述，共计13页，涵盖了多种排序策略和技术。下面我们将深入探讨这些关键知识点。 1. 集合接口与实现 在Java中，集合主要分为两种类型：List和Set。List接口（如...
Java中List集合对象去重及按属性去重的8种方法
09-08
【Java中List集合对象去重及按属性去重的8种方法】 在Java编程中，当我们处理包含重复元素的List时，有时需要去除其中的重复项。以下文章将详细介绍8种针对List集合对象去重的方法，包括基于对象整体以及按特定属性...
JDK8：HashMap源码解析：comparableClassFor、compareComparables、tieBreakOrder方法
老艮头的后知后觉
06-13 2511
一、概述 在之前的文章里已经分析过，在发生hash碰撞（多个key的hash值相同）的时候，hashMap首先会采用链表进行存储，当链表节点数量达到一定阈值（8）会将链表上的节点再组织成一棵红黑树。红黑树是一种二叉树，每个父节点可以由左右两个节点。 当put一个新元素时，如果该元素键的hash值小于当前节点的hash值的时候，就会作为当前节点的左节点；hash值大于当前节点hash值得时候作为...
HashMap源码分析JDK8：comparableClassFor方法
dabusiGin的博客
12-25 211
源码分析 /** * Returns x's Class if it is of the form "class C implements * Comparable<C>", else null. * * 如果x的类的形式为“Class C implements Comparable<C>”，则返回x的类型 * 否则返回null ...
Java中的Type
weixin_30341735的博客
12-19 211
Type是Java 编程语言中所有类型的公共高级接口（官方解释），也就是Java中所有类型的“爹”；其中，“所有类型”的描述尤为值得关注。它并不是我们平常工作中经常使用的 int、String、List、Map等数据类型，而是从Java语言角度来说，对基本类型、引用类型向上的抽象； Type体系中类型的包括：原始类型(Class)、参数化类型(ParameterizedType)、数组类型(...
object 类 java_Object类
weixin_39519072的博客
02-19 55
本文将要为您介绍的是Object类,具体完成步骤:一、概述Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象(包括数组)都实现这个类的方法。Java 所有类都继承Object 但是没有用 extend 声明，是因为根据JDK版本不同，有的在编译器(JDK1.6)中实现，有的在VM中实现。参考英文：* Class {@code Object} is the root...
从HashMap的comparableClassFor方法看反射
学习小窝
04-06 215
HashMap的comparableClassFor方法主要是为了判断传入的Compare类是否符合 class C implements Comparable <C>，如果符合则返回C，不符合则返回null 下面通过一个例子来看看: public class ComparableClassForStudy{ public static void main(String[]...
Object x与基本类型
Mr_yuntuo的博客
04-03 614
这几天看《ThinkInJava》的时候发现作者大大的很多代码方法中都有使用参数：public void add(Object x){.....}。 后来查了一下，发现如下内容： Object类是Java所有类的超类,在Java中所有类都是由它扩展来的,可以用Object类型的变量来引用(接收)任意类型的对象.但要想对接收的对象进行具体操作,就需要进行类型转换,将Object类型...
java中object类_java基础之Object类解析(一)
weixin_28795975的博客
02-12 185
1. 导读java中每新增一个类, 他的父类都是Object类, 那么Object类中的方法都会被子类继承, 今天主要来看看Object中的5个方法;1.1 getClass();1.2 hashCode();1.3 equals();1.4 clone();1.5 toString();2. getClass方法getClass()方法是用来获取运行时的对象; 当声明对象和.class文件中真正...
java中instanceof的用法
weixin_34203426的博客
03-04 113
A instanceof B 前一个操作数通常是一个引用类型的变量。 后一个操作数通常是一个类（也可以是接口，可以把接口理解为特殊的类）。 它用于判断前面的对象是否是后面的类，或其子类、实现类的实例。 注：instanceof运算符前面的操作数的编译时类型：要么与后面的类相同，要么与后面的类具有父子继承关系（谁继承谁都可以）。 Object hello="Hello"; hel...
Java集合框架基础：灵活存储与Object类equals方法详解
Java的集合框架提供了一种灵活的方式来管理动态数据，理解并熟练运用Object类和equals()方法对于编写健壮和高效的代码至关重要。通过正确地重写equals()方法，你可以确保在比较对象时得到预期的结果，无论是在简单的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值