精华内容
下载资源
问答
  • 背景:有时候想不通阿帕奇的BeanUtils是怎么进行map和Bean互相转化的。工作闲暇之余,自己写个一小段代码,一探究竟,试试才发现,原来...辅助实体类Person.java,如下:public classPerson {privateString name;pr...

    背景:有时候想不通阿帕奇的BeanUtils是怎么进行map和Bean互相转化的。

    工作闲暇之余,自己写个一小段代码,一探究竟,试试才发现,原来一切并非我们想的那么什么和复杂。

    注:这里只是简单实例,不追求严密的代码规范和异常处理。

    首先,新建一个工具类BeanUtils.java.

    辅助实体类Person.java,如下:

    public classPerson {privateString name;private intage;private booleanadult;public Person(String name, int age, booleanisAdult) {this.name =name;this.age =age;this.adult =isAdult;

    }

    @OverridepublicString toString() {return "Person [name=" + name + ", age=" + age + ", adult=" + adult + "]";

    }publicPerson() {

    }publicString getName() {returnname;

    }public voidsetName(String name) {this.name =name;

    }public intgetAge() {returnage;

    }public void setAge(intage) {this.age =age;

    }public booleanisAdult() {returnadult;

    }public void setAdult(booleanadult) {this.adult =adult;

    }

    }

    1.JavaBean 转换为Map;

    //bean 转化为map

    public static Map tranferBean2Map(Object obj) throwsException{//obj为空,结束方法

    if(obj==null)return null;

    Map map=new HashMap();/*Introspector 类为通过工具学习有关受目标 Java Bean 支持的属性、事件和方法的知识提供了一个标准方法。

    * java的自省机制

    **/BeanInfo beanInfo=Introspector.getBeanInfo(obj.getClass());

    PropertyDescriptor[] ps=beanInfo.getPropertyDescriptors();for(PropertyDescriptor propertyDescriptor : ps) {

    String key=propertyDescriptor.getName();if(!"class".equals(key)){

    Method getter=propertyDescriptor.getReadMethod();

    Object value=getter.invoke(obj);

    map.put(key, value);

    }

    }returnmap;

    }

    2.Map转换为JavaBean ,使用简单的泛型;

    //map转换为javaBean

    public static T transferMap2Bean(Map map,Class clazz) throwsException{

    T instance=clazz.newInstance();

    BeanInfo beanInfo=Introspector.getBeanInfo(clazz);

    PropertyDescriptor[] descriptors=beanInfo.getPropertyDescriptors();for(PropertyDescriptor property : descriptors) {

    String key=property.getName();if(map.containsKey(key)){

    Object value=map.get(key);

    Method setter=property.getWriteMethod();

    setter.invoke(instance, value);

    }

    }returninstance;

    }

    经过测试,可以成功进行map和javabean的互转。

    Introspector 类为通过工具学习有关受目标 Java Bean 支持的属性、事件和方法的知识提供了一个标准方法。

    展开全文
  • 当获取列表中的第二个元素时,会报错,java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String。这是常见的类型转换错误。当我们将元素放入到列表中,并没有使用指定的类型,在取出...

    引出泛型

    我们通过如下的示例,引出为什么泛型的概念。

    d69360ae714548a2f421b40d6296a208.png

    当获取列表中的第二个元素时,会报错,java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String。这是常见的类型转换错误。

    当我们将元素放入到列表中,并没有使用指定的类型,在取出元素时使用的是默认的 Object 类型。因此很容易出现类型转换的异常。

    我们想要实现的结果是,集合能够记住集合内元素各类型,且能够达到只要编译时不出现问题,运行时就不会出现 java.lang.ClassCastException 异常。泛型刚好能满足我们的需求。

    什么是泛型?

    泛型,即参数化类型。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。

    泛型的本质是为了参数化类型,即在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型。在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口和泛型方法。

    泛型的特点

    Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化,已支持泛型,而且类库也进行了大翻修,所以许多重要的类,比如集合框架,都已经成为泛型化的了。这带来了很多好处:

    1类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在一个高得多的程度上验证类型假设。

    2消除强制类型转换。 泛型的一个附带好处是,消除源代码中的许多强制类型转换。这使得代码更加可读,并且减少了出错机会。

    3潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中,编译器将强制类型转换(没有泛型的话,程序员会指定这些强制类型转换)插入生成的字节码中。

    命名类型参数

    推荐的命名约定是使用大写的单个字母名称作为类型参数。对于常见的泛型模式,推荐的名称是:

    • K:键,比如映射的键
    • V:值,比如 List 和 Set 的内容,或者 Map 中的值
    • E:元素
    • T:泛型
    2bd72044bb486545677639f503b0ab3f.png

    如上定义了一个普通的泛型类,成员变量的类型为 T,T的类型由外部指定。泛型方法和泛型构造函数同样如此。

    1300173967912612bff8d5aa7106b00b.png

    泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。传入的实参类型需与泛型的类型参数类型相同,即为Integer/String。

    如上所述,定义的泛型类,就一定要传入泛型类型实参么?

    并不是这样,在使用泛型的时候如果传入泛型实参,则会根据传入的泛型实参做相应的限制,此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话,在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

    f0339300b8f4f933cd7adb0437eb5b36.png

    如上的代码片段,将会输出如下的结果:

    704b08f54ce769347cf3a81cdb0a21af.png

    在不传入泛型类型实参的情况下,泛型类中使用的泛型防范或成员变量可以为 Integer 或 String 等等其他任意类型。不过需要注意的是,泛型的类型参数只能是类类型,不能是简单类型。且不能对确切的泛型类型使用 instanceof 操作。对于不同传入的类型实参,生成的相应对象实例的类型是不是一样的呢?具体看如下的示例:

    a06db2de06c1025533ce28531de82e1e.png

    由输出结构可知,在使用泛型类时,虽然传入了不同的泛型实参,但并没有真正意义上生成不同的类型,传入不同泛型实参的泛型类在内存上只有一个,即还是原来的最基本的类型(本例中为 Generic),当然在逻辑上我们可以理解成多个不同的泛型类型。

    究其原因,在于 Java 中的泛型这一概念提出的目的,其只是作用于代码编译阶段。在编译过程中,对于正确检验泛型结果后,会将泛型的相关信息擦除。也就是说,成功编译过后的 class 文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

    泛型类型在逻辑上看以看成是多个不同的类型,实际上都是相同的基本类型。

    通配符

    Ingeter 是 Number 的一个子类,同时 Generic 与 Generic 实际上是相同的一种基本类型。那么问题来了,在使用 Generic 作为形参的方法中,能否使用Generic 的实例传入呢?在逻辑上类似于 Generic 和 Generic 是否可以看成具有父子关系的泛型类型呢?下面我们通过定义一个方法来验证。

    04f0b296256b30eb7a5cba39a9d6c9ab.png

    进行如下的调用:

    193d34ca2c8aabd3633d43a79d2643b0.png

    通过提示信息我们可以看到 Generic 不能被看作为 Generic 的子类。由此可以看出:同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。

    我们不能因此定义一个 show(Generic obj)来处理,因此我们需要一个在逻辑上可以表示同时是Generic和Generic父类的引用类型。由此类型通配符应运而生。

    T、K、V、E 等泛型字母为有类型,类型参数赋予具体的值。除了有类型,还可以用通配符来表述类型,? 未知类型,类型参数赋予不确定值,任意类型只能用在声明类型、方法参数上,不能用在定义泛型类上。将方法改写成如下:

    33ab83fd516dfffaf3fe0090dbf5bcbb.png

    此处 ? 是类型实参,而不是类型形参。即和 Number、String、Integer 一样都是实际的类型,可以把 ? 看成所有类型的父类,是一种真实的类型。可以解决当具体类型不确定的时候,这个通配符就是 ?;当操作类型时,不需要使用类型的具体功能时,只使用 Object 类中的功能。那么可以用 ? 通配符来表未知类型。

    泛型上下边界

    在使用泛型的时候,我们还可以为传入的泛型类型实参进行上下边界的限制,如:类型实参只准传入某种类型的父类或某种类型的子类。为泛型添加上边界,即传入的类型实参必须是指定类型的子类型。

    f8f10e16725d55d27dbde5d8b2ba6649.png

    我们在泛型方法的入参限定参数类型为 Number 的子类。

    2194e72872788b3f75409fdbbcc57161.png

    当我们的入参为 String 类型时,编译报错,因为 String 类型并不是 Number 类型的子类。

    类型通配符上限通过形如 Generic extends Number> 形式定义;相对应的,类型通配符下限为Generic super Number>形式,其含义与类型通配符上限正好相反,在此不作过多阐述。

    泛型数组

    在 java 中是不能创建一个确切的泛型类型的数组的,即:

    93681e1f596e503efdba2111247c1141.png

    如上会编译报错,而使用通配符创建泛型数组是可以的:

    c960b573acc827071d07279fe6bf23f1.png

    JDK1.7 对泛型的简化,所以另一种声明也是可以的。

    由于JVM泛型的擦除机制,在运行时 JVM 是不知道泛型信息的。泛型数组实际的运行时对象数组只能是原始类型( T[]为Object[],Pair[]为Pair[] ),而实际的运行时数组对象可能是T类型( 虽然运行时会擦除成原始类型 )。成功创建泛型数组的唯一方式就是创建一个被擦出类型的新数组,然后对其转型。

    daa9cf8311a25e004cb7ce0e21a76946.png

    在运行时,数组对象的出口做转型输出,入口方法在编译期已实现类型安全,所以出口方法可以放心强制类型转换,保证成功。

    小结

    本文主要讲了 Java 泛型的相关概念和应用。泛型使编译器可以在编译期间对类型进行检查以提高类型安全,减少运行时由于对象类型不匹配引发的异常。由泛型的诞生介绍相关的概念,在保证代码质量的情况下,如何使用泛型去简化开发。

    展开全文
  • 我有一个严重创建的容器对象,它保存不同java类型的值(String,Boolean等)public class BadlyCreatedClass {public Object get(String property) {...;}};我们以这种方式从中提取价值String myStr = (String) ...

    我有一个严重创建的容器对象,它保存不同java类型的值(String,Boolean等)

    public class BadlyCreatedClass {

    public Object get(String property) {

    ...;

    }

    };

    我们以这种方式从中提取价值

    String myStr = (String) badlyCreatedObj.get("abc");

    Date myDate = (Date) badlyCreatedObj.get("def");

    我被迫使用这个对象写一些新的代码,我试图看看是否有干净的方法来做到这一点。更具体地说,优选以下哪种方法?

    显性演员

    String myStr = (String) badlyCreatedObj.get("abc")

    Date myDate = (Date) badlyCreatedObj.get("def");

    使用泛型

    public X genericGet(String property) {

    }

    public String getString(String property) {

    return genericGet(property);

    }

    public Date getDate(String property) {

    return genericGet(property);

    }

    使用Class.cast

    T get(String property, Class cls) {

    ;

    }

    谢谢

    展开全文
  • 点击上方Java后端,选择设为星标优质文章,及时送达链接 |www.jianshu.com/p/dd34211f2565这一节主要讲的内容是java泛型的应用,通过该篇让大家更好地理解泛型,以及面试中经常说的泛型类型擦除是什么概念,今天就...

    点击上方 Java后端,选择 设为星标

    优质文章,及时送达be512589bac81757e772d1e4698b26ec.png

    链接 | www.jianshu.com/p/dd34211f2565

    这一节主要讲的内容是java中泛型的应用,通过该篇让大家更好地理解泛型,以及面试中经常说的泛型类型擦除是什么概念,今天就带着这几个问题一起看下:

    举一个简单的例子:

    23fa0b947f3e5099b6822ba14122393e.png

    这里可以看出来在代码编写阶段就已经报错了,不能往string类型的集合中添加int类型的数据。

    那可不可以往List集合中添加多个类型的数据呢,答案是可以的,其实我们可以把list集合当成普通的类也是没问题的,那么就有下面的代码:

    b8e2bdeb1b5834f1f98089a760272bd6.png

    从这里可以看出来,不定义泛型也是可以往集合中添加数据的,所以说泛型只是一种类型的规范,在代码编写阶段起一种限制。

    下面我们通过例子来介绍泛型背后数据是什么类型

    public class BaseBean {
        T value;public T getValue() {return value;
        }public void setValue(T value) {this.value = value;
        }
    }

    上面定义了一个泛型的类,然后我们通过反射获取属性和getValue方法返回的数据类型:

    22c50194e392eee1567aae5201a8b0c8.png

    f7d080ddc9ba41c6f0c1acb1170538cf.png

    从日志上看到通过反射获取到的属性是Object类型的,在方法中返回的是string类型,因此咋们可以思考在getValue方法里面实际是做了个强转的动作,将object类型的value强转成string类型。是的,没错,因为泛型只是为了约束我们规范代码,而对于编译完之后的class交给虚拟机后,对于虚拟机它是没有泛型的说法的,所有的泛型在它看来都是object类型,因此泛型擦除是对于虚拟机而言的。

    下面我们再来看一种泛型结构:

    a89b348a6bb918daf025b26ecd525f22.png

    这里我将泛型加了个关键字extends,对于泛型写得多的伙伴们来说,extends是约束了泛型是向下继承的,最后我们通过反射获取value的类型是String类型的,因此这里也不难看出,加extends关键字其实最终目的是约束泛型是属于哪一类的。所以我们在编写代码的时候如果没有向下兼容类型,会警告错误的:

    b9e09a6024738e513791185ac84a8e47.png

    大家有没有想过为啥要用泛型呢,既然说了泛型其实对于jvm来说都是Object类型的,那咱们直接将类型定义成Object不就是的了,这种做法是可以,但是在拿到Object类型值之后,自己还得强转,因此泛型减少了代码的强转工作,而将这些工作交给了虚拟机。

    比如下面我们没有定义泛型的例子:

    42a1c915de02e54548723d47c77c3d6c.png

    势必在getValue的时候代码有个强转的过程,因此在能用泛型的时候,尽量用泛型来写,而且我认为一个好的架构师,业务的抽取是离不开泛型的定义。

    常见的泛型主要有作用在普通类上面,作用在抽象类、接口、静态或非静态方法上。

    类上面的泛型

    比如实际项目中,我们经常会遇到服务端返回的接口中都有errMsgstatus等公共返回信息,而变动的数据结构是data信息,因此我们可以抽取公共的BaseBean

    public class BaseBean {public String errMsg;public T data;public int status;
    }
    抽象类或接口上的泛型
    public abstract class BaseAdapter<T> {
        List DATAS;
    }public interface Factory<T> {T create();
    }public static T getData() {return null;
    }

    多元泛型

    public interface Base<K, V> {void setKey(K k);V getValue();
    }
    泛型二级抽象类或接口
    public interface BaseCommon<K extends Common1, V> extends Base<K, V> {
    }public abstract class BaseCommon<K extends Common1, V> implements Base<K, V> {
    }

    抽象里面包含抽象

    public interface Base<K, V> {void addNode(Map map);MapgetNode(int index);
    }public abstract class BaseCommon<K, V> implements Base<K, V> {
       LinkedList> DATAS = new LinkedList<>();@Overridepublic void addNode(Map map) {
           DATAS.addLast(map);
       }@Overridepublic MapgetNode(int index) {return DATAS.get(index);
       }
    }

    >通配符

    >通配符区别是>在你不知道泛型类型的时候,可以用>通配符来定义,下面通过一个例子来看看>的用处:

    public class BaseBean<T> {
        T value;public T getValue() {return value;
        }public void setValue(T value) {this.value = value;
        }
    }public class Common1 extends Common {
    }

    dd8b3352a565fcbd6c4107070dd8df27.png

    在定义的时候将Common的泛型指向Common1的泛型,可以看到直接提示有问题,这里可以想,虽然Common1是继承自Common的,但是并不代表BaseBean之间是等量的,在开篇也讲过,如果泛型传入的是什么类型,那么在BaseBean中的getValue返回的类型就是什么,因此可以想两个不同的泛型类肯定是不等价的,但是如果我这里写呢:

    public static void main(String[] args) {
        BaseBean commonBaseBean = new BaseBean<>();
        BaseBean> common1BaseBean = commonBaseBean;try {
            Method setValue = common1BaseBean.getClass().getDeclaredMethod("setValue", Object.class);
            setValue.invoke(common1BaseBean, "123");
            Object value = common1BaseBean.getValue();
            System.out.println("result:" + value);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    在上面如果定义的泛型是通配符是可以等价的,因为此时的setValue的参数是Object类型,所以能直接将上面定义的泛型赋给通配符的BaseBean。

    通配符不能定义在类上面、接口或方法上,只能作用在方法的参数上

    c659e12a62bd13888f2f942f0343ec13.png

    其他的几种情况自己去尝试,正确的使用通配符:

    public void setClass(Class> class){
    }

    、、 extends >、 super >

    表示上限泛型、表示下限泛型
    为了演示这两个通配符的作用,增加了一个类:

    03e9fbcac18de1eb4d4813c7dfd02907.png

    public class Common extends BaseCommon{
    }

    011ec10bda5b48f508b9013af5142199.png

    第二个定义的泛型是不合法的,因为BaseCommon是Common的父类,超出了Common的类型范围。

    不能作用在类、接口、方法上,只能通过方法传参来定义泛型
    在BaseBean里面定义了个方法:

    public void add(Class super Common> clazz) {
    }

    9fca840171aa3aed516534880632b55c.png

    可以看到当传进去的是Common1.class的时候是不合法的,因为在add方法中需要传入Common父类的字节码对象,而Common1是继承自Common,所以直接不合法。

    在实际开发中其实知道什么时候定义什么类型的泛型就ok,在mvp实际案例中泛型用得比较广泛,大家可以根据实际项目来找找泛型的感觉,只是面试的时候需要理解类型擦除是针对谁而言的。

    类型擦除
    其实在开篇的时候已经通过例子说明了,通过反射绕开泛型的定义,也说明了类中定义的泛型最终是以Object被jvm执行。所有的泛型在jvm中执行的时候,都是以Object对象存在的,加泛型只是为了一种代码的规范,避免了开发过程中再次强转。泛型信息只存在于代码编译阶段,在进入 JVM 之前,与泛型相关的信息会被擦除掉,专业术语叫做类型擦除。

    展开全文
  • 下面是我写的一个Java代码, ![图片说明](https://img-ask.csdn.net/upload/201709/12/1505209641_156806.png) 我知道24行的直接转换是不行的,因为内部数组本质是一个Object[]的数组,但是运行该程序是会报错的,...
  • 最近在编写代码的时候,遇到了一个问题,当在Mongodb中查询到Map数据的时候,由于这个Map的结构不固定,没办法用实体来接收封装,就只能用Map来接收,但是没办法返回Map泛型,需要用到强转来处理数据,导致IDEA会...
  • 1.System静态方法:(1)currentTimeMillis() 返回当前时间的毫秒值 用来测试程序的效率 开始时间减去结束时间(2)void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将数组中指定的数据...
  • 如何解决 Java 泛型类型转换时的警告

    千次阅读 多人点赞 2020-03-15 10:55:23
    日常在写 Java 代码时对警告Type safety: Unchecked cast from XXX to YYY一定不会陌生,例如Type safety: Unchecked cast from Object to Map<String,String>。如果仔细观察的话,可以注意到,YYY...
  • java泛型 null_Java泛型

    2021-03-08 09:15:17
    1、什么是泛型泛型就是 参数类型化 ,... 明确类型 避免类型转换如,没有泛型前,从List中取数据都是Object类型的 需要强制转换为确定的类型public static void main(String[] args) {List myList = new ArrayList()...
  • Java泛型详解[]

    2018-03-16 20:11:12
    原文:Java泛型详解 引言 泛型是Java中一个非常重要的知识点,在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java泛型的设计,将会涉及到通配符... private String object; public void set(St...
  • https://www.jianshu.com/p/dd34211f2565这一节主要讲的内容是java泛型的应用,通过该篇让大家更好地理解泛型,以及面试中经常说的泛型类型擦除是什么概念,今天就带着这几个问题一起看下:举一个简单的例子:这里...
  • 一、泛型的概念如果要求在一个类中定义一个保存年龄的属性,这个属性定义为int还可以定义字符串类型:●private int age; .●private String age;此时可以使用什么类型能...ObjectJava提供的一个最大父类,Java提供...
  • Java允许程序员构建一个元素类型为Object的Collection,其中的元素可以是任何类型在Java SE 1.5之前,没有泛型的情况下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要作显式的强制类型...
  • 1、简单泛型使用Object:因为Object类是类层次结构的根,Java中所有的类从根本上都继承自这个类。所以所有的类都能转型为Object类。import java.util.*;public classEx7 {static voidf(Object a) {System.out.println...
  • Java 泛型

    2020-08-26 00:36:10
    Java 泛型 1、泛型介绍 1.1、泛型概述 在前面学习集合时,我们都知道集合中是可以存放任意对象的,只要把对象丢尽集合后,那么这时他们都会被提升成Object类型。当我们在取出每一个对象,并且进行相应的操作,这时...
  • Java泛型

    2019-12-07 14:54:02
    Java泛型 开发人员在使用泛型的时候,很容易根据自己的直觉而犯一些错误。比如一个方法如果接收List<Object>作为形式参数,那么如果尝试将一个List<String>的对象作为实际参数传进去,却发现无法通过...
  • 泛型概述在前面学习集合时,我们都知道集合中是可以存放任意对象的,只要把对象存储集合后,那么这时他们都会被提升成Object类型。当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换。大家观察下面...
  • []Java泛型详解

    2018-07-15 22:17:38
    本文我们将从零开始来看一下Java泛型的设计,将会涉及到通配符处理,以及让人苦恼的类型擦除。 泛型基础 泛型类 我们首先定义一个简单的Box类: public class Box { private String object; public void...
  • List<String> str = new ArrayList<String>(); str.add("11"); str.getClass().getMethod("add", Object.class).invoke(str, 2); System.out.println(str); for (int i=0;i();i++) { System.out....
  • java泛型

    2021-02-25 22:40:24
    文章目录一、泛型的概念二、泛型的定义典型场景泛型类有界类型 一、泛型的概念 泛型是jdk5引入的类型机制,就是将...泛型机制将类型转换时的类型检查从运行时提前到了编译时,使用泛型编写的代码比杂乱的使用object
  • 在深入了解泛型之前我们先来回忆一下向上转型和向下转型,结合以下代码来看:public class TestF{private Object b;public Object getB(){return b;}public void setB(Object b){this.b=b;}public static void main...
  • JAVA泛型

    2013-05-09 16:38:57
    我先对java泛型的注意点还有作用,优势做一个简单的阐述  1. java 泛型参数只能是类类型(如Integer,String,还有一些类类型 ),不能是简单类型.  2.泛型可以说明任何实例方法中的局部变量,类的成员变量,方法的形式...
  • List传入需要转换的clazzMap的值Object转换为T的Field对应类型/*** List> 到 List 数据转换*/public static List setList(List> srcList, Class clazz) {List list = new ArrayList<>();srcList....
  • java 泛型

    2019-09-24 23:42:36
    List 如果不使用泛型, 默认插入和取出都是 Object, 转型有风险 List list = new ArrayList<>(); list.add(123); // String str = (String) list.get(0); ---> java.lang.ClassCastException String ...
  • Java泛型详解【

    2015-12-13 15:36:43
    1. 概述 在引入范型之前,Java类型分为原始类型、复杂类型,其中复杂类型分为数组和类。引入范型后,一个复杂类型 ...他们之间没有继承关系,即使String继承了Object。下面的代码是非法的  List ls = new Arra

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 265
精华内容 106
关键字:

java泛型string转object

java 订阅