java中的类型擦除type erasure

最新推荐文章于 2024-12-28 20:27:56 发布
原创 最新推荐文章于 2024-12-28 20:27:56 发布 · 8.9k 阅读 · 2 ·
CC 4.0 BY-SA版权
本文为flydean原创文章，未经博主允许不得转载，更多内容请参考www.flydean.com。
文章标签：

#java #编程语言 #jvm #类型擦除

文章目录


java中的类型擦除type erasure

简介

泛型是java从JDK 5开始引入的新特性，泛型的引入可以让我们在代码编译的时候就强制检查传入的类型，从而提升了程序的健壮度。

泛型可以用在类和接口上，在集合类中非常常见。本文将会讲解泛型导致的类型擦除。

举个例子

我们先举一个最简单的例子：

@Slf4j
public class TypeErase {

    public static void main(String[] args) {
        ArrayList<String> stringArrayList = new ArrayList<String>();
        stringArrayList.add("a");
        stringArrayList.add("b");
        action(stringArrayList);
    }

    public static void action(ArrayList<Object> al){
        for(Object o: al)
            log.info("{}",o);
    }
}

上面的例子中，我们定义了一个ArrayList，其中指定的类型是String。

然后调用了action方法，action方法需要传入一个ArrayList，但是这个list的类型是Object。

乍看之下好像没有问题，因为String是Object的子类，是可以进行转换的。

但是实际上代码编译出错：

Error:(18, 16) java: 不兼容的类型: java.util.ArrayList<java.lang.String>无法转换为java.util.ArrayList<java.lang.Object>

原因

上面例子的原因就是类型擦除（type erasure)。java中的泛型是在编译时做检测的。而编译后生成的二进制文件中并不保存类型相关的信息。

上面的例子中，编译之后不管是ArrayList<String> 还是ArrayList<Object> 都会变成ArrayList。其中的类型Object/String对JVM是不可见的。

但是在编译的过程中，编译器发现了两者的类型不同，然后抛出了错误。

解决办法

要解决上面的问题，我们可以使用下面的办法：

    public static void actionTwo(ArrayList<?> al){
        for(Object o: al)
            log.info("{}",o);
    }

通过使用通配符？，可以匹配任何类型，从而通过编译。

但是要注意这里actionTwo方法中，因为我们不知道传入的类型到底是什么，所以我们不能在actionTwo中添加任何元素。

总结

从上面的例子我们可以看出，ArrayList<String>并不是ArrayList<Object>的子类。如果一定要找出父子关系，那么ArrayList<String>是Collection<String>的子类。

但是Object[] objArray是String[] strArr的父类。因为对Array来说，其具体的类型是已知的。

本文的例子https://github.com/ddean2009/learn-java-collections

更多精彩内容且看：

本文作者：flydean程序那些事

本文链接：http://www.flydean.com/java-type-erasure/

本文来源：flydean的博客

欢迎关注我的公众号:程序那些事，更多精彩等着您！

JAVA中类型擦除与桥接方法的详解
zjw541806的博客
06-27 155
​​类型擦除​​是Java编译器在编译泛型代码时，将泛型类型参数替换为其​​上限类型​​（默认是Object，若指定了上限如则替换为Number）的过程。​​兼容旧代码​​：避免引入新的字节码结构，使泛型代码能与Java 5前的非泛型代码共存。​​消除类型冗余​​：确保泛型仅在编译期提供类型安全检查，运行时不保留具体类型信息。// 泛型父类消除泛型的运行时类型信息，保持与旧版本代码的兼容。通过编译期类型检查和自动插入强制转换，保证运行时类型安全。
Java泛型编程如何避免类型擦除问题
JessicaAustin的博客
04-23 1138
类型擦除是指在编译时，泛型类型信息被擦除，替换为它们的原始类型（如Object）。理解类型擦除的原理和影响，以及掌握如何在编程中处理这些问题，将有助于我们更好地利用Java泛型编程的优势，提高代码的质量和可维护性。因此，在运行时，泛型类型信息不再存在，导致无法直接访问这些类型。例如，我们可以为泛型类添加一个Class类型的类型参数，以便在运行时访问泛型类型。通过利用这些特性，我们可以减少显式类型参数的使用，从而减轻类型擦除带来的负担。通过这种方式，我们可以在运行时访问泛型类型，从而避免一些类型擦除问题。
理解 C++ 中的类型擦除（Type Erasure）
windowshht的博客
08-21 1395
类型擦除是一种编程技术，它允许我们在不暴露具体类型的情况下，使用不同的类型。这意味着我们可以在运行时处理不同类型的对象，而不需要在编译时知道这些类型。类型擦除的主要目的是提供一种灵活的方式来处理多态性，尤其是在泛型编程中。类型擦除是一种强大的技术，它允许我们在 C++ 中以灵活的方式处理不同类型的对象。通过使用基类指针、和类型擦除类，我们可以实现多态性和泛型编程的目标。在实际开发中，合理使用类型擦除可以提高代码的灵活性和可维护性，但也需要注意性能开销和类型安全性的问题。
Java-泛型编程-类型擦除(Type Erasure)
NowOrNever
12-31 6143
Java中的泛型代码和C++中的模板有一个很大的不同：C++中模板的实例化会为每一种类型都产生一套不同的代码，这就是所谓的代码膨胀。 Java中并不会产生这个问题。虚拟机中并没有泛型类型对象，所有的对象都是普通类。 虚拟机中的泛型转换需要记住4条事实： 1) 定义任何一个泛型都会自动产生其原始类型(raw type) 2) 这个过程中，泛型类型会被擦除，替换为其限定类型 ...
从头认识java-13.6 类型擦除（type erasure）（1）-概念
raylee2007的专栏
12-13 294
这一章节我们讨论一下类型擦除。 1.什么是类型擦除？ 在java里面泛型其实是伪泛型，因为他都只是在编译器里面实现的，在jvm里面是没有泛型的概念。 我们看下面的代码： package com.ray.ch11; import java.util.ArrayList; public class Test { public static void main(String[] args...
C++中的类型擦除（type erasure in c++）
weixin_30444105的博客
12-10 472
作者：唐风出处：http://www.cnblogs.com/liyiwen本文版权归作者和博客园共有，欢迎转载，但请保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。 关于类型擦除，在网上搜出来的中文资料比较少，而且一提到类型擦除，检索结果里就跑出很多 Java 和 C# 相关的文章来（它们实现“泛型”的方式）。所以，这一篇我打算写得稍微详细一点。 注意，这是...
关于Java的Type Erasure
hqu_wxf的专栏
07-13 587
像HashMap.class这样的用法在Java里是不允许的，因为Java有个Type Erasure特性——类型擦除。也就是在JVM中运行时，并没有泛型的信息。
什么是 Java 的类型擦除
孔乙己的博客
08-20 971
类型擦除（Type Erasure）是 Java 编程语言中泛型（Generics）的一部分，它是指在编译时将泛型类型转换为原始类型，从而在运行时移除类型参数信息的过程。类型擦除的设计目的是为了兼容 Java 语言的早期版本，使得泛型可以在 Java 1.5 之前的字节码上运行，同时不需要对 JVM 进行重大更改。为了更好地理解类型擦除的实际影响，我们来看一个真实的案例，展示如何在没有类型擦除和泛型支持的情况下创建一个自定义集合类，以及在有泛型支持和类型擦除情况下的变化。
Java中的泛型擦除（Type Erasure）详解
2401_84909321的博客
05-26 622
在Java编程中，泛型（Generics）是一个强大的工具，它允许程序员在编写代码时定义和使用类型参数，从而编写更灵活、可重用的代码。然而，Java的泛型实现有一个重要的特点，即类型擦除（Type Erasure）。这个特性在Java中引入泛型时，为了与Java的旧版本（即1.4及以前版本）保持兼容而设计。下面我们将从技术难点、面试官关注点、回答吸引力以及代码举例四个方面来详细解释Java中的泛型擦除。由于泛型擦除，编译器不会在编译时检查这个转换的安全性。在这个示例中，我们创建了一个泛型列表。
解释 Java 泛型中的类型擦除是什么意思，并讨论它带来的优势和限制。请给出一个实际例子来说明类型擦除的影响。
程序员学习园地。
07-20 758
在Java中，泛型是一种允许你在类、接口和方法中使用类型参数的技术，从而编写更加灵活和类型的代码。Java的泛型实现有一个特殊之处，即类型擦除（Type Erasure）。简单来说，类型擦除意味着在编译后的字节码中，所有的泛型类型信息都会被擦除掉，替换为它们的非泛型上界或者Object类型。换句话说，Java虚拟机（JVM）并不直接知道泛型的具体类型，它看到的只是没有泛型信息的原始类型。
Java泛型: 类型擦除(type erasure)
weixin_34214500的博客
03-16 211
type erasure & reified generic Java的泛型不同于C++的模板：Java泛型是"type erasure"，C++模板是"reified generic"。 type erasure：泛型类型仅存在于编译期间，编译后的字节码和运行时不包含泛型信息，所有的泛型类型映射到同一份字节码。 reifie...
Java：泛型的类型擦除（type erasure）
听海边涛声
12-28 288
Java：泛型的类型擦除（type erasure）
java 泛型 泛型擦除(type erasure)
Claroja
02-26 136
在runtime时期,会将所有的类型形参和类型实参擦除,比如List<String>被转换为List,既raw type 以下类型是相同的 System.out.println(new ArrayList<String>().getClass()); //class java.util.ArrayList System.out.println(new ArrayList<Long>().getClass()); //class java.util.ArrayList 参
Type Erasure
dracularking的竹林小屋
02-22 733
When a generic type is instantiated, the compiler translates those types by a technique called type erasure — a process where the compiler removes all information related to type parameters and type
【java快速入门-泛型篇】- 泛型的实现方式（擦拭法Type Erasure）
foolish的博客
02-17 323
Java语言的泛型实现方式是擦拭法（Type Erasure）。所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。java编译器将<T>擦拭成为Object然后再有所需要泛型转换得时候，自动强制转换为所需得类型。
C++: 类型擦除（type erasure）
Peace
10-23 1664
在 C++ 中，编译器在编译期进行的静态类型检查是比较严格的，但有时候我们却希望能“避过”这样的类型检查，以实现更灵活的功能，同时又尽量地保持类型安全。听起来很矛盾，而且貌似很难办到。但其实 C++ 的库里已经有很多这样的应用了。比如，著名的 boost::function 和 boost::any 。当我们定义一个 function<void(int)> fun 对象，则 fun 即可以存储函数指针，又可以存储函数对象，注意，这两者是不同“类型”的，而且函数对象可以是无限种类型的...
C++中的类型擦除技术
喜欢打篮球的普通人
08-17 2403
在 main() 函数中，我们创建了两个不同类型的 Derived 对象 d1 和 d2，然后创建了一个 Functor 对象 f。通过调用 f(d1) 和 f(d2)，我们将不同类型的对象传递给函数对象 f，它将根据对象的类型调用适当的 foo() 实现。process() 函数接受一个 std::function 类型的参数，它表示一个无返回值、不带参数的可调用对象。C++语境下的类型擦除，技术上来说，是编写一个类，它提供模板的构造函数和非虚函数接口提供功能；所以，这段代码可以过编译。
java 类型擦除_java中的类型擦除type erasure
weixin_35626107的博客
02-22 233
简介泛型是java从JDK 5开始引入的新特性，泛型的引入可以让我们在代码编译的时候就强制检查传入的类型，从而提升了程序的健壮度。泛型可以用在类和接口上，在集合类中非常常见。本文将会讲解泛型导致的类型擦除。举个例子我们先举一个最简单的例子：@Slf4jpublic class TypeErase {public static void main(String[] args) {ArrayList ...
跟我学c++中级篇——类型擦除的应用
fpcc的专栏
12-31 1305
对c++中的类型擦除的应用举一个例子的演进说明
java类型擦除
最新发布
03-12
<think>嗯，用户之前问过Java和C++语法区别，现在接着问Java的类型擦除。看来他对Java的泛型机制不太清楚，特别是和C++模板的区别。类型擦除是Java泛型实现的一个核心点，可能他在实际编程中遇到了泛型相关的问题，或者想深入理解Java的设计选择。 我需要先确认类型擦除的定义，然后解释为什么Java要用类型擦除，比如为了兼容旧版本，保持字节码兼容。然后要举例子说明类型擦除的具体表现，比如编译后的类型信息丢失，无法在运行时获取泛型参数类型。可能还需要对比C++的模板，因为用户之前的问题涉及到两者的比较，这样他能更好地理解两者的差异。 另外，用户可能想知道类型擦除带来的限制，比如不能创建泛型数组，instanceof无法使用，以及重载的问题。这些实际开发中的痛点需要具体例子说明。同时，要提到绕过类型擦除的方法，比如通过传递Class对象，这样用户知道如何处理类型信息丢失的情况。 还要注意用户的技术水平，他可能已经有一定编程经验，但可能对底层机制不熟悉，所以需要用简洁明了的语言，避免过于技术化的术语，但又要准确。可能需要用代码示例来辅助解释，比如ArrayList<Integer>和ArrayList<String>在运行时的类型是一样的，这样更直观。 最后总结类型擦除的意义，优缺点，让用户理解Java设计的选择背后的权衡。可能用户想了解为什么Java不采用C++那样的具体化泛型，所以需要提到兼容性和迁移成本的问题。</think>以下是关于 Java 类型擦除（Type Erasure）的详细说明，从设计原理到实际影响逐步解析： --- ### 一、**什么是类型擦除？** 类型擦除是 Java 泛型（Generics）的核心实现机制。**编译时保留泛型类型信息，但在编译后会将泛型类型替换为原始类型（Raw Type）或边界类型（如 `Object`），并插入强制类型转换**。这一设计是为了兼容 Java 5 之前的旧版本代码。 **示例**： ```java // 编译前代码 List<String> list = new ArrayList<>(); list.add("Hello"); String s = list.get(0); // 编译后等效代码（类型擦除后） List list = new ArrayList(); // 原始类型 list.add("Hello"); String s = (String) list.get(0); // 强制转换 ``` --- ### 二、**类型擦除的具体表现** #### 1. **泛型类型信息丢失** - 运行时无法获取泛型参数的具体类型： ```java List<Integer> intList = new ArrayList<>(); List<String> strList = new ArrayList<>(); // 输出均为 true（运行时类型相同） System.out.println(intList.getClass() == strList.getClass()); ``` #### 2. **泛型类型参数替换规则** - 无界类型参数（如 `<T>`）替换为 `Object`： ```java // 编译前 public class Box<T> { private T value; } // 编译后等效 public class Box { private Object value; } ``` - 有界类型参数（如 `<T extends Number>`）替换为边界类型： ```java // 编译前 public class Box<T extends Number> { private T value; } // 编译后等效 public class Box { private Number value; } ``` --- ### 三、**类型擦除带来的限制** #### 1. **无法创建泛型数组** ```java // 编译错误：Generic array creation T[] array = new T[10]; ``` #### 2. **无法使用 `instanceof` 检查泛型类型** ```java if (list instanceof List<String>) { ... } // 编译错误 ``` #### 3. **重载冲突** ```java // 编译错误：方法签名冲突（擦除后均为 List<Object>） public void print(List<String> list) {} public void print(List<Integer> list) {} ``` #### 4. **无法直接实例化泛型类型** ```java public class Box<T> { private T obj = new T(); // 编译错误：类型擦除后 T 变为 Object } ``` --- ### 四、**如何绕过类型擦除的限制** #### 1. **显式传递 `Class` 对象** ```java public class Box<T> { private Class<T> type; public Box(Class<T> type) { this.type = type; } public T createInstance() throws Exception { return type.getDeclaredConstructor().newInstance(); } } ``` #### 2. **通过反射获取泛型信息（有限场景）** ```java // 获取父类泛型参数类型（需继承带泛型的父类） public class StringList extends ArrayList<String> {} Type genericType = StringList.class.getGenericSuperclass(); if (genericType instanceof ParameterizedType) { Type[] types = ((ParameterizedType) genericType).getActualTypeArguments(); System.out.println(types[0]); // 输出 class java.lang.String } ``` --- ### 五、**类型擦除的意义与争议** #### **优点**： - **兼容性**：确保泛型代码与旧版本 JVM 兼容。 - **性能**：运行时无需维护泛型类型信息，减少开销。 #### **缺点**： - **灵活性降低**：部分泛型高级特性无法实现（如具体化类型）。 - **代码冗余**：需手动处理类型转换（如集合类）。 --- ### 六、**与 C++ 模板的对比** | 特性 | Java 泛型（类型擦除） | C++ 模板 | |------------------|------------------------------------------|-----------------------------------| | **实现机制** | 编译时擦除类型，运行时无类型信息 | 编译时生成具体类型代码（代码膨胀）| | **类型检查** | 编译时检查，运行时无泛型类型 | 编译时生成类型安全检查 | | **性能** | 无额外优化（依赖强制转换） | 可生成高度优化的机器码 | | **灵活性** | 受限于类型擦除 | 支持模板元编程等复杂特性 | --- ### 总结 类型擦除是 Java 泛型实现的核心机制，**在保证兼容性的同时牺牲了部分运行时灵活性**。理解这一机制有助于避免泛型编程中的常见陷阱（如类型转换错误），并合理利用反射等工具突破限制。
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

flydean程序那些事

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值