Java里泛型有什么作用？我怎么觉得那个可写可不写_编程 - QQ志乐园
您的当前位置： &
Java里泛型有什么作用？我怎么觉得那个可写可不写
来源： |人气：295 ℃|时间： 10:03:20
为了解决用户可能碰到关于"Java里泛型有什么作用？我怎么觉得那个可写可不写"相关的问题，志乐园经过收集整理为用户提供相关的解决办法，请注意，解决办法仅供参考，不代表本网同意其意见,如有任何问题请与本网联系。"Java里泛型有什么作用？我怎么觉得那个可写可不写"相关的详细问题如下:
一直没整明白泛型是怎么回事，高手详细讲解下啊！！！举个例子来说你的钱包里你规定只装钱那么你去出来的想也不想就是钱，管他是￥还是$不用转换的--&都是钱(确定里面是什么)不用泛型的话就不规定放什么那么你取出来的东西就不一定是钱,这样你就要转换了,那要是石头的话你要转换成钱就错了(不确定里面到底是什么)网友回答
||||点击排行Java中泛型的本质 - Peng的技术博客 - ITeye技术网站
博客分类：
泛型在Java中经常用到。泛型在本质上是指类型参数化。所谓类型参数化，是指用来声明数据的类型本身，也是可以改变的，它由实际参数来决定。在一般情况下，实际参数决定了形式参数的值。而类型参数化，则是实际参数的类型决定了形式参数的类型。
举个简单的例子。方法max()要求返回两个参数中较大的那个，可以写成：
Integer max(Integer a, Integer b){
return a&b?a:b;
这样编写代码当然没有问题。不过，如果需要比较的不是Integer类型，而是Double或是Float类型，那么就需要另外再写max()方法。参数有多少种类型，就要写多少个max()方法。但是无论怎么改变参数的类型，实际上max()方法体内部的代码并不需要改变。如果有一种机制，能够在编写max()方法时，不必确定参数a和b的数据类型，而等到调用的时候再来确定这两个参数的数据类型，那么只需要编写一个max()就可以了，这将大大降低程序员编程的工作量。
在C++中，提供了函数模板和类模板来实现这一功能。而从JDK1.5开始，也提供了类似的机制：泛型。从形式上看，泛型和C++的模板很相似，但它们是采用完全不同的技术来实现的。
在泛型出现之前，Java的程序员可以采用一种变通的办法：将参数的类型均声明为Object类型。由于Object类是所有类的父类，所以它可以指向任何类对象，但这样做不能保证类型安全。
泛型则弥补了上述做法所缺乏的类型安全，也简化了过程，不必显示地在Object与实际操作的数据类型之间进行强制转换。通过泛型，所有的强制类型转换都是自动和隐式的。因此，泛型扩展了重复使用代码的能力，而且既安全又简单。
兼职做外包 挣Money！
浏览: 507745 次
来自: 未来
楼下新增的测试都不准，都没有一定的前提：ArrayList需要 ...
Mark太少了
&div class=&quote_title ...
6楼的兄弟又给我们普及了知识 3q
&div class=&quote_title ...1041人阅读
java（17）
java 里 泛型中 &T&代表什么类型呀？
public &T& List&T& find(String sql, Class&T& entityClass, Map&String, Object& paramMap) {}
&T& 是什么意思？ 有T这种类型么？
这里 public &T& 这个是什么意思 还有 List&T& 这个是什么意思
&&T&&可以代表任意类型的。
解释： “&T&”是泛型的默认值，可以被任意类型所代替，如：
List&String&
list = new ArayList&String&()；这个就定义了一个String类型的数组，那么T的类型就是字符串。
list = new ArayList&T&()；之后也有可以：list.add(&StringBatch&);
这个时候T的类型也是String。也就是说T是动态的，可以被任意指定类型。
&&相关文章推荐
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：16476次
排名：千里之外
原创：14篇
转载：56篇
(3)(3)(5)(15)(14)(19)(12)trackbacks-0
泛型的好处：&&&&泛型的主要好处就是让编译器保留参数的类型信息，执行类型检查，执行类型转换（casting）操作，编译器保证了这些类型转换（casting）的绝对无误。
&&&&&&&&/*******&不使用泛型类型&*******/&&&&&&&&List&list1&=&new&ArrayList();&&&&&&&&list1.add(<span style="color: #80);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& //编译器不检查值&&&&&&&&String&str1&=&(String)list1.get(<span style="color: #);&//需手动强制转换,如转换类型与原数据类型不一致将抛出ClassCastException异常&&&&&&&&&&&&&&&&/*******&使用泛型类型&*******/&&&&&&&&List&String&&list2&=&new&ArrayList&String&();&&&&&&&&list2.add("value");&&&&&&&&&&&&&&&& //[类型安全的写入数据]&编译器检查该值,该值必须是String类型才能通过编译&&&&&&&&String&str2&=&list2.get(<span style="color: #);&//[类型安全的读取数据]&不需要手动转换&&&&&&&&泛型的类型擦除：&&&&Java 中的泛型只存在于编译期，在将 Java 源文件编译完成 Java 字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。&&&&这个过程就称为类型擦除（type erasure）。
&&&&&&&&List&String&&& &list1&=&new&ArrayList&String&();&&&&&&&&List&Integer&&list2&=&new&ArrayList&Integer&();&&&&&&&&&&&&&&&&System.out.println(list1.getClass()&==&list2.getClass());&//&输出结果：&true&&&&&&&&System.out.println(list1.getClass().getName());&//&输出结果：&java.util.ArrayList&&&&&&&&System.out.println(list2.getClass().getName());&//&输出结果：&java.util.ArrayList&&&&&&&&在以上代码中定义的 List&String& 和 List&Integer& 等类型，在编译之后都会变成 List，而由泛型附加的类型信息对 JVM 来说是不可见的，所以第一条打印语句输出 true，第二、第三条打印语句都输出 java.util.ArrayList，这都说明 List&String& 和 List&Integer& 的对象使用的都是同一份字节码，运行期间并不存在泛型。来看一个简单的例子：
package&import&java.util.L/**&*&-----------------------------------------&*&&#64;描述&&类型擦除&*&&#64;作者&&fancy&*&&#64;邮箱&&fancydeepin&#64;yeah.net&*&&#64;日期&&&&p&&*&-----------------------------------------&*/public&class&GenericsApp&{&&&&&&&&public&void&method(List&String&&list){&&&&&&&&&&&&}&&&&&&&&/*&&&&&*&编译出错,这两个方法不属于重载,由于类型的擦除,使得这两个方法的参数列表的参数均为List类型,&&&&&*&这就相当于同一个方法被声明了两次,编译自然无法通过了&&&&&*&&&&&public&void&method(List&Integer&&list){&&&&&&&&&&&&}&&&&*/&&&&}以此类为例，在 cmd 中 编译 GenericsApp.java 得到字节码，然后再反编译这份字节码：从图中可以看出，经反编译后的源码中 method 方法的参数变成了 List 类型，说明泛型的类型被擦除了，字节码文件中不存在泛型，也就是说，运行期间泛型并不存在，它在编译完成之后就已经被擦除了。泛型类型的子类型：&&&&泛型类型跟其是否是泛型类型的子类型没有任何关系。
&&&&&&& List&Object&&list1;&&&&&&&&List&String&&list2;&&&&&&&&&&&&&&&&list1&=&list2;&//&编译出错&&&&&&&&list2&=&list1;&//&编译出错在 Java 中，Object 类是所有类的超类，自然而然的 Object 类是 String 类的超类，按理，将一个 String 类型的对象赋值给一个 Object 类型的对象是可行的，但是泛型中并不存在这样的逻辑，泛型类型跟其是否子类型没有任何关系。泛型中的通配符（?）：&&&&由于泛型类型与其子类型存在不相关性，那么在不能确定泛型类型的时候，可以使用通配符（?），通配符（?）能匹配任意类型。
&&&&&&& List&?&&&&&&&&&&List&Object&&list1&=&null;&&&&&&&&List&String& &list2&=&null;&&&&&&&&&&&&&&&&list&=&list1;&&&&&&&&list&=&list2;限定通配符的上界：
&&&&&&&&ArrayList&?&extends&Number&&collection&=&null;&&&&&&&&&&&&&&&&collection&=&new&ArrayList&Number&();&&&&&&&&collection&=&new&ArrayList&Short&();&&&&&&&&collection&=&new&ArrayList&Integer&();&&&&&&&&collection&=&new&ArrayList&Long&();&&&&&&&&collection&=&new&ArrayList&Float&();&&&&&&&&collection&=&new&ArrayList&Double&();&&&&&&&&&? extends XX，XX 类是用来限定通配符的上界，XX 类是能匹配的最顶层的类，它只能匹配 XX 类以及 XX 类的子类。在以上代码中，Number 类的实现类有：AtomicInteger、AtomicLong、 BigDecimal、 BigInteger、 Byte、 Double、 Float、 Integer、 Long、 Short ，因此以上代码均无错误。限定通配符的下界：
&&&&&&&&ArrayList&?&super&Integer&&collection&=&null;&&&&&&&&&&&&&&&&collection&=&new&ArrayList&Object&();&&&&&&&&collection&=&new&ArrayList&Number&();&&&&&&&&collection&=&new&ArrayList&Integer&();&&&&&&&&&? super XX，XX 类是用来限定通配符的下界，XX 类是能匹配的最底层的类，它只能匹配 XX 类以及 XX 类的超类，在以上代码中，Integer 类的超类有：Number、Object，因此以上代码均能通过编译无误。通过反射获得泛型的实际类型参数：&&&&java.lang.Class 类从 Java 1.5 起（如果没记错的话），提供了一个 getGenericSuperclass() 方法来获取直接超类的泛型类型
package&import&java.lang.reflect.ParameterizedT/**&*&-----------------------------------------&*&&#64;描述&&泛型的实际类型参数&*&&#64;作者&&fancy&*&&#64;邮箱&&fancydeepin&#64;yeah.net&*&&#64;日期&&&&p&&*&-----------------------------------------&*/public&class&Base&T&&{&&&&private&Class&T&&entityC&&&&&&&&//代码块,也可将其放置到构造子中&&&&{&&&&&&&&entityClass&=(Class&T&)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[<span style="color: #];&&&&&&&&&&&&&&&&}&&&&&&&&//泛型的实际类型参数的类全名&&&&public&String&getEntityName(){&&&&&&&&&&&&&&&&return&entityClass.getName();&&&&}&&&&&&&&//泛型的实际类型参数的类名&&&&public&String&getEntitySimpleName(){&&&&&&&&&&&&&&&&return&entityClass.getSimpleName();&&&&}&&&&//泛型的实际类型参数的Class&&&&public&Class&T&&getEntityClass()&{&&&&&&&&return&entityC&&&&}&&&&}(Class&T&)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];&& 相当于：
&&&&//代码块,也可将其放置到构造子中&&&&{&&&&&&&&//entityClass&=(Class&T&)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];&&&&&&&&try&{&&&&&&&&&&&&Class&?&&clazz&=&getClass();&//获取实际运行的类的&Class&&&&&&&&&&&&Type&type&=&clazz.getGenericSuperclass();&//获取实际运行的类的直接超类的泛型类型&&&&&&&&&&&&if(type&instanceof&ParameterizedType){&//如果该泛型类型是参数化类型&&&&&&&&&&&&&&&&Type[]&parameterizedType&=&((ParameterizedType)type).getActualTypeArguments();//获取泛型类型的实际类型参数集&&&&&&&&&&&&&&&&entityClass&=&(Class&T&)&parameterizedType[<span style="color: #];&//取出第一个(下标为0)参数的值&&&&&&&&&&&&}&&&&&&&&}&catch&(Exception&e)&{&&&&&&&&&&&&e.printStackTrace();&&&&&&&&}&&&&&&&&&&&&&&&&}&&&&注意，获取 Class 实例的时候是用 getClass()，而不是用 Base.class，获取 Class 的方式有三种，这是其中的两种，还有一种是 Class.forName("类全名")，如需了解反射的基础知识请前往上一篇随笔& 那么，Base.class 与 getClass()，这两个方法来获取类的字节码的时候，Base.class 是写死了的，它得到的永远是 Base 类的字节码，而 getClass() 方法则不同，在上面代码注释中的第一、二行注释我用了&#8220;实际运行的类&#8221;6个字，这几个字很重要，是一定要理解的。为了方便大家的理解，下面插加一个小例子来加以说明 类.class 与 getClass() 两种方法来获取类的字节码有什么区别：
package&/**&*&-----------------------------------------&*&&#64;描述&&超类&*&&#64;作者&&fancy&*&&#64;邮箱&&fancydeepin&#64;yeah.net&*&&#64;日期&&&&p&&*&-----------------------------------------&*/public&class&Father&{&&&&public&Father&(){&&&&&&&&&&&&&&&&System.out.println("Father&类的构造子：");&&&&&&&&System.out.println("Father.class&："&+&Father.class);&&&&&&&&System.out.println("getClass()&&&&& ："&+&getClass());&&&&}&&&&}
package&/**&*&-----------------------------------------&*&&#64;描述&&超类的子类（超类的实现类）&*&&#64;作者&&fancy&*&&#64;邮箱&&fancydeepin&#64;yeah.net&*&&#64;日期&&&&p&&*&-----------------------------------------&*/public&class&Children&extends&Father{&&&&}
package&/**&*&-----------------------------------------&*&&#64;描述&&测试类&*&&#64;作者&&fancy&*&&#64;邮箱&&fancydeepin&#64;yeah.net&*&&#64;日期&&&&p&&*&-----------------------------------------&*/public&class&Test&{&&&&public&static&void&main(String[]&args){&&&&&&&&&&&&&&&&new&Children();&//实际运行的类是Children（Father类的子类或者说是实现类）&&&&}&&&&}后台打印输出的结果：
Father&类的构造子：Father.class&：class&test.FathergetClass()&&&&& ：class&test.Children&从打印出的结果看来，类.class 与 getClass() 的区别很明了了，getClass() 获取的是实际运行的类的字节码，它不一定是当前类的 Class，有可能是当前类的子类的 Class，具体是哪个类的 Class，需要根据实际运行的类来确定，new 哪个类，getClass() 获取的就是哪个类的 Class，而 类.class 获取得到的 Class 永远只能是该类的 Class，这点是有很大的区别的。如果 getClass() 理解了，那 clazz.getGenericSuperclass() 也应该能够理解了的，千万不要以为 clazz.getGenericSuperclass() 获取得到的是 Object 类那就成了，实际上假如当前运行的类是 Base 类的子类，那么 clazz.getGenericSuperclass() 获取得到的就是 Base 类。(Class&T&) parameterizedType[0]，怎么就知道第一个参数（parameterizedType[0]）就是该泛型的实际类型呢？很简单，因为 Base&T& 的泛型的类型参数列表中只有一个参数，所以，第一个元素就是泛型 T 的实际参数类型。
package&/**&*&-----------------------------------------&*&&#64;描述&&测试类&*&&#64;作者&&fancy&*&&#64;邮箱&&fancydeepin&#64;yeah.net&*&&#64;日期&&&&p&&*&-----------------------------------------&*/public&class&Test&{&&&&public&static&void&main(String[]&args){&&&&&&&&&&&&&&&&Base&String&&base&=&new&Base&String&();&&&&&&&&System.out.println(base.getEntityClass());&&&&&&&&&&&&&&&&&&&&&& &//打印输出&null&&&&//&&&&System.out.println(base.getEntityName());&&&&&&&&&&&&&&& //抛出&NullPointerException&异常&&&&//&&&&System.out.println(base.getEntitySimpleName());&//抛出&NullPointerException&异常&&&&}&&&&}从打印的结果来看，Base 类并不能直接来使用，为什么会这样？原因很简单，由于 Base 类中的 clazz.getGenericSuperclass() 方法，如果随随便便的就确定 Base 类的泛型的类型参数，则很可能无法通过 Base 类中的 if 判断，导致 entityClass 的值为 null，像这里的 Base&String&，String 的 超类是 Object，而 Object 并不能通过 if 的判断语句。Base 类不能够直接来使用，而是应该通过其子类来使用，Base 应该用来作为一个基类，我们要用的是它的具体的子类，下面来看下代码，它的子类也不是随便写的：
package&/**&*&-----------------------------------------&*&&#64;描述&&Base类的实现类&*&&#64;作者&&fancy&*&&#64;邮箱&&fancydeepin&#64;yeah.net&*&&#64;日期&&&&p&&*&-----------------------------------------&*/public&class&Child&extends&Base&Child&{}从上面代码来看，Base 的泛型类型参数就是 Base 的子类本身，这样一来，当使用 Base 类的子类&Child 类时，Base 类就能准确的获取到当前实际运行的类的 Class，来看下怎么使用
package&/**&*&-----------------------------------------&*&&#64;描述&&测试类&*&&#64;作者&&fancy&*&&#64;邮箱&&fancydeepin&#64;yeah.net&*&&#64;日期&&&&p&&*&-----------------------------------------&*/public&class&Test&{&&&&public&static&void&main(String[]&args){&&&&&&&&&&&&&&&&Child&child&=&new&Child();&&&&&&&&System.out.println(child.getEntityClass());&&&&&&&&System.out.println(child.getEntityName());&&&&&&&&System.out.println(child.getEntitySimpleName());&&&&}&&&&}后台打印输出的结果：
class&test.Childtest.ChildChild好了，文章接近尾声了，如果你能理解透这个例子，你可以将这个思想运用到 DAO 层面上来，以 Base 类作为所有 DAO 实现类的基类，在 Base 类里面实现数据库的 CURD 等基本操作，然后再使所有具体的 DAO 类来实现这个基类，那么，实现这个基类的所有的具体的 DAO 都不必再实现数据库的 CURD 等基本操作了，这无疑是一个很棒的做法。（通过反射获得泛型的实际类型参数）补充：泛型反射的关键是获取 ParameterizedType 接口，再调用 ParameterizedType 接口中的 getActualTypeArguments() 方法就可获得实际绑定的类型。由于去参数化(擦拭法)，也只有在&超类（调用 getGenericSuperclass 方法） 或者成员变量（调用 getGenericType 方法）或者方法（调用 getGenericParameterTypes 方法）像这些有方法返回 ParameterizedType 类型的时候才能反射成功。上面只谈到超类如何反射，下面将变量和方法的两种反射补上：通过方法，反射获得泛型的实际类型参数：
package&import&java.lang.reflect.Mimport&java.lang.reflect.ParameterizedTimport&java.lang.reflect.Timport&java.util.C/**&*&-----------------------------------------&*&&#64;描述&&测试类&*&&#64;作者&&fancy&*&&#64;邮箱&&fancydeepin&#64;yeah.net&*&&#64;日期&&&&p&&*&-----------------------------------------&*/public&class&Test&{&&&&public&static&void&main(String[]&args){&&&&&&&&/**&&&&&&&&&*&泛型编译后会去参数化（擦拭法），因此无法直接用反射获取泛型的参数类型&&&&&&&&&*&可以把泛型用做一个方法的参数类型，方法可以保留参数的相关信息，这样就可以用反射先获取方法的信息&&&&&&&&&*&然后再进一步获取泛型参数的相关信息，这样就得到了泛型的实际参数类型&&&&&&&&&*/&&&&&&&&try&{&&&&&&&&&&&&Class&?&&clazz&=&Test.class;&//取得&Class&&&&&&&&&&&&Method&method&=&clazz.getDeclaredMethod("applyCollection",&Collection.class);&//取得方法&&&&&&&&&&&&Type[]&type&=&method.getGenericParameterTypes();&//取得泛型类型参数集&&&&&&&&&&&&ParameterizedType&ptype&=&(ParameterizedType)type[<span style="color: #];//将其转成参数化类型,因为在方法中泛型是参数,且Number是第一个类型参数&&&&&&&&&&&&type&=&ptype.getActualTypeArguments();&//取得参数的实际类型&&&&&&&&&&&&System.out.println(type[<span style="color: #]);&//取出第一个元素&&&&&&&&}&catch&(Exception&e)&{&&&&&&&&&&&&e.printStackTrace();&&&&&&&&}&&&&}&&&&&&&&//声明一个空的方法,并将泛型用做为方法的参数类型&&&&public&void&applyCollection(Collection&Number&&collection){&&&&&&&&&&&&}}后台打印输出的结果：
class&java.lang.Number通过字段变量，反射获得泛型的实际类型参数：
package&import&java.lang.reflect.Fimport&java.lang.reflect.Mimport&java.lang.reflect.ParameterizedTimport&java.lang.reflect.Timport&java.util.Cimport&java.util.M/**&*&-----------------------------------------&*&&#64;描述&&测试类&*&&#64;作者&&fancy&*&&#64;邮箱&&fancydeepin&#64;yeah.net&*&&#64;日期&&&&p&&*&-----------------------------------------&*/public&class&Test&{&&&&private&Map&String,&Number&&&&&&&&&&public&static&void&main(String[]&args){&&&&&&&&&&&&&&&&try&{&&&&&&&&&&&&&&&&&&&&&&&&Class&?&&clazz&=&Test.class;&//取得&Class&&&&&&&&&&&&Field&field&=&clazz.getDeclaredField("collection");&//取得字段变量&&&&&&&&&&&&Type&type&=&field.getGenericType();&//取得泛型的类型&&&&&&&&&&&&ParameterizedType&ptype&=&(ParameterizedType)&//转成参数化类型&&&&&&&&&&&&System.out.println(ptype.getActualTypeArguments()[<span style="color: #]);&//取出第一个参数的实际类型&&&&&&&&&&&&System.out.println(ptype.getActualTypeArguments()[<span style="color: #]);&//取出第二个参数的实际类型&&&&&&&&&&&&&&&&&&&&}&catch&(Exception&e)&{&&&&&&&&&&&&e.printStackTrace();&&&&&&&&}&&&&}&&&&}后台打印输出的结果：
class&java.lang.Stringclass&java.lang.Number&&
阅读(13135)
&re: java 泛型 深入
那就精华经过作者的分析有点似懂非懂&&&&&&
&re: java 泛型 深入[未登录]
既然泛型信息在编译后已完全抹去，那在后面的例子中是如何在运行时得到参数化的类型呢&&&&&&
&re: java 泛型 深入
回复 &#64;Kane：
这个问题问的好！我也跟你有一样的疑惑，当时我立即去查 java.lang.Class 的源码，找到 getGenericSuperclass() 的实现：
public Type getGenericSuperclass() {
if (getGenericSignature() != null) {
// Historical irregularity:
// Generic signature marks interfaces with superclass = Object
// but this API returns null for interfaces
if (isInterface())
return getGenericInfo().getSuperclass();
return getSuperclass();
}
但是以上实现中的 getGenericSignature 和 getSuperclass 两个方法都是用 native 声明的本地方法，找不到它们的源码，没有收获。
文章中的 Base 类和 Child 类在编译完成后的字节码文件中，你通过反编译来看，真真切切是没有保留泛型信息，编译期间泛型被擦除：
在文章的代码中，如果想输出查看一下type的类型：
……
Type type = clazz.getGenericSuperclass();
System.out.println(type);
……
打印确实能够输出我们想要的：test.Base&test.Child&
getGenericSuperclass() 具体是怎么取到泛型的信息的我也不太清楚，只是知道用这个方法能取得到，就我知道的，想通过反射取得泛型信息有三种方法，一种就是文章中提到的，一种是变量，另外一种就是通过把泛型用做一个方法的参数类型，方法可以保留参数的相关信息，这样就可以用反射来先获取方法的信息，然后再进一步获取泛型参数的相关信息，这样也能得到泛型的实际参数类型。
&re: java 泛型 深入
写得不错！&&&&&&
&re: java 泛型 深入[未登录]
条理挺清晰的，不错的入门文章&&&&&&
&re: java 泛型 深入
感谢写的这么好,好久的小疑惑解决了&&&&&&
&re: java 泛型 深入
楼主，我做了一个试验，我反编译的结果跟你的有出入。试验的情况写在我的博客上，你移步过去看看，帮忙解答一下，多谢！&&&&&&
&re: java 泛型 深入
博客文章地址：&&&&&&
&re: java 泛型 深入
泛型信息在运行时会进行擦除，主要是为了向前兼容，因为JDK5 以前的版本并没有泛型。但是泛型参数等信息在JVM中仍然可以获取，并没有从class文件中去除，用其它的反编译工具是可以看得到的。&&&&&&
随笔分类(8)
随笔档案(104)
积分与排名
阅读排行榜